xyzshop/helper/refill/policy/quaility.php

<?php

namespace refill;

use Log;
use mtopcard;
use scope_trace;

class Quality
{
    const LowestQuality  = 1;
    const Normal = 1;
    const Quick = 2;
    const CardKey = 3;
    const ThirdShop = 4;
    const SlowTwentyFour = 5;
    const SlowSix = 6;
    const SlowTwo = 7;
    const SlowFortyEight = 8;
    const SlowSeventyTwo = 9;
    const Fastest = 10;
    const HighestQuality = 10;

    const SlowNormal  = 11;  // 7 -> 1
    const ThirdNormal  = 12; // 4 -> 1
    const DefSuccess = 13;   // 4 -> 3 -> 1 -> 2
    const NormalQuick = 14;
    const SlowSixNormal = 15;
    const NormalCardkey = 16;
    const NormalQuickCardkey = 17; //1->2->3
    const QuickCardkey = 18; //2 -> 3

    const OilWithoutSN = 1;
    const OilQuick = 2;
    const OilCardKey   = 3;
    const OilWithSN    = 5;

    const OilSN_NONE_HAS   = 20;
    const OilSN_HAS_NONE   = 21;
    const OIL_SN_CARDKEY        = 22;
    const OIL_SNNONE_CARDKEY    = 23;
    const OIL_SN_SNNONE_CARDKEY = 24;
    const OIL_SNNONE_SN_CARDKEY = 25;
    const OIL_SNNONE_SN_CARDKEY_QUICK = 26;

    protected $mMchPhonectl;
    protected $mMchoilctl;
    protected $mSpeeds;
    protected $mQualities;
    protected $mTryAdjuster;

    protected $mRatioCtl;

    public function __construct()
    {
        $this->mMchPhonectl = new mchctl();
        $this->mMchoilctl = new mchoilctl();
        $this->mTryAdjuster = new try_judge();
        $this->mRatioCtl = null;
    }

    public function load()
    {
        $this->mMchPhonectl->load();
        $this->mMchoilctl->load();
        $this->mTryAdjuster->load();
    }

    public function setRatioCtl($ratio_ctl) {
        $this->mRatioCtl = $ratio_ctl;
    }

    public function qualities($quality)
    {
        if (array_key_exists($quality, $this->mQualities)) {
            return $this->mQualities[$quality];
        } else {
            return [];
        }
    }

    public function mechants_quality() {
        return $this->mMchPhonectl->mechants_quality();
    }

    public function find_quality($mchid, $card_type, $spec, $org_quality, $cur_quality, $used_times, $used_time, $caller): array
    {
        if($card_type == mtopcard\ChinaMobileCard || $card_type == mtopcard\ChinaUnicomCard || $card_type == mtopcard\ChinaTelecomCard) {
            return $this->mobile_quality($mchid, $card_type, $spec, $org_quality, $cur_quality, $used_times, $used_time);
        }
        elseif($card_type == mtopcard\PetroChinaCard || $card_type == mtopcard\SinopecCard) {
            [$org,$qualities] = $this->oil_quality($mchid, $org_quality, $used_times,$used_time,$caller);
            return [$org,$qualities,false];
        }
        else {
            return [0, [],false];
        }
    }

    private function oil_quality($mchid, $quality, $times,$used_time,$caller): array
    {
        Log::record("oil_quality mchid={$mchid},quality={$quality},times={$times}",Log::DEBUG);
        if($quality == 0)
        {
            [$success,$setting_quality,$time_out] = $this->mMchoilctl->getCtls($mchid);
            if($success)
            {
                if(array_key_exists($setting_quality,$this->mQualities)) {
                    $org = $setting_quality;
                    $qualities = $this->mQualities[$setting_quality];
                }
                else {
                    $org = $setting_quality;
                    $qualities = [$setting_quality];
                }
            }
            else {
                $org = self::Normal;
                $qualities = $this->mQualities[$org];
            }
        }
        elseif(array_key_exists($quality,$this->mQualities)) {
            $org = $quality;
            $qualities = $this->mQualities[$quality];
        }
        else {
            Log::record("find_quality: cannot find any quality",Log::DEBUG);
            return [0,[]];
        }

        Log::record("oil_quality find qualities = " . implode(',',$qualities),Log::DEBUG);
        $qualities = $this->calc_oil_quality($qualities,$times,$used_time,$caller);

        return [$org,$qualities];
    }

    //通过每种类型通道耗时，倒推当前可用通道，并优先走推荐通道.
    private function calc_oil_quality($qualities, $times, $used_time, $caller)
    {
        $result = [];
        if($used_time > 900) {
            return $result;
        }

        $total_times = 0;
        foreach ($qualities as $quality)
        {
            $cur_times = $caller->calc_times($quality);
            if($cur_times <= 0) continue;

            $total_times += $cur_times;
            if($total_times > $times) {
                $result[] = $quality;
            }
        }

        Log::record("calc_oil_quality result = " . implode(',',$result),Log::DEBUG);
        return $result;
    }


    private function mobile_quality($mchid, $card_type, $spec, $org_quality, $cur_quality, $used_times, $used_time): array
    {
        if($org_quality == 0)
        {
            [$success,$setting_quality,$time_out] = $this->mMchPhonectl->getCtls($mchid);
            if($success)
            {
                if(array_key_exists($setting_quality,$this->mQualities)) {
                    $org_quality = $setting_quality;
                }
                else {
                    $org_quality = $setting_quality;
                }
            }
            else {
                $org_quality = self::Normal; //如果没设置质量，默认为普通
                $time_out = $this->mSpeeds[$org_quality]['retry_timeout'];
            }
        }
        elseif(array_key_exists($org_quality,$this->mQualities)) {
            [$success, $setting_quality, $time_out] = $this->mMchPhonectl->getCtls($mchid);
        }
        else {
            Log::record("find_quality: cannot find any quality",Log::DEBUG);
            return [0,[],false];
        }

        if($time_out <= 0) {
            $time_out = $this->mSpeeds[$org_quality]['retry_timeout'];
        }

        $qualities = $this->qualities($org_quality);
        $max_times = $this->max_times($mchid, $org_quality, $qualities);
        if ($this->mRatioCtl->exist($mchid)) {
            Log::record("ratio_phone_quality exist=true",Log::DEBUG);
            [$qualities,$match_ratio] = $this->ratio_phone_quality($org_quality, $qualities, $cur_quality, $used_times, $used_time, $mchid, $card_type, $spec);
            return [$org_quality, $qualities,$match_ratio];
        } else {
            $fMixed = PolicyUtil::mixed_quality($org_quality);
            $qualities = $this->calc_phone_quality($qualities, $fMixed, $cur_quality, $used_times, $used_time, $time_out, $max_times, $mchid);
            return [$org_quality, $qualities,false];
        }
    }

    private function ratio_phone_quality($org_quality, $all_qualities, $cur_quality, $used_times, $used_time, $mchid, $card_type, $spec)
    {
        [$succ,$max_times,$time_out] = $this->mRatioCtl->total($mchid,$all_qualities);

        $left_time = $time_out - $used_time;
        Log::record("left_time = {$left_time} used_time={$used_time}",Log::DEBUG);
        if ($left_time <= 0 || $max_times <= $used_times) {
            Log::record("max_times=$max_times used_times=$used_times",Log::DEBUG);
            return [[],false];
        }
        
        if (count($all_qualities) == 1) {
            Log::record("all_qualities count = 1",Log::DEBUG);
            return [$all_qualities, true];
        }

        $times_checker = function ($cur_quality_match_ratio, $qualities, $used_times) use ($cur_quality, $mchid)
        {
            $result = [];
            $pre_times = 0;

            //默认不配置的情况下，首次$cur_quality等于0
            $compare = $cur_quality > 0 ? false : true;

            foreach ($qualities as $quality)
            {
                if($compare == false)
                {
                    if($quality == $cur_quality) {
                        $compare = true;
                    }
                }

                $qtimes = $this->mRatioCtl->times($mchid, $quality);
                if ($qtimes == false) {
                    continue;
                } else {
                    $pre_times += $qtimes;
                }

                if($compare == false) continue;

                if ($cur_quality_match_ratio) {
                    $result[] = $quality;
                } elseif ($used_times < $pre_times) {
                    $result[] = $quality;
                }
            }

            return $result;
        };

        $timeout_checker = function ($match_ratio, $qualities, $left_time) use ($cur_quality, $mchid)
        {
            if($match_ratio)
            {
                $result = [];
                $compare = $cur_quality > 0 ? false : true;
                foreach ($qualities as $quality)
                {
                    if($compare == false)
                    {
                        if($quality == $cur_quality) {
                            $compare = true;
                        }
                    }
                    if($compare == false) continue;

                    $per_secs = $this->mSpeeds[$quality]['per_secs'];
                    $left_time -= $per_secs;
                    if($left_time > 0) {
                        $result[] = $quality;
                    } else {
                        break;
                    }
                }

                return $result;
            }
            else
            {
                $result = [];

                $qualities = array_reverse($qualities);
                foreach ($qualities as $quality) {
                    $per_secs = $this->mSpeeds[$quality]['per_secs'];
                    $qsecs = $this->mRatioCtl->seconds($mchid, $quality);
                    Log::record("left_time={$left_time} quality={$quality} secs={$qsecs}", Log::DEBUG);

                    if ($qsecs == false) continue;

                    if ($left_time - $qsecs > 0) {
                        //时间满足该质量配置
                        $left_time -= $qsecs;
                        $result[] = $quality;
                    } elseif ($left_time - $per_secs > 0) {
                        //时间够跑一次，不能再找其它质量
                        $result[] = $quality;
                        break;
                    } else {
                        //时间完全不够跑一次
                        break;
                    }

                    if ($quality == $cur_quality) {
                        break;
                    }
                }

                $result = array_reverse($result);
                return $result;
            }
        };

        $pTryAdjuster = $this->mTryAdjuster;
        $timeing_checker = function ($qualities) use($pTryAdjuster,$mchid)
        {
            foreach ($qualities as $quality)
            {
                $ret = $pTryAdjuster->can_try($mchid,$quality);
                if($ret == false) {
                    return false;
                }
            }

            return true;
        };

        $qualities_log = function ($tag,$qualities)
        {
            $str = implode(',',$qualities);
            Log::record("{$tag}={$str}", Log::DEBUG);
        };

        if($used_times > 0)
        {
            $qualities_log("ratio_phone_quality {$mchid}-{$card_type}-{$spec} all_qualities", $all_qualities);
            [$match_ratio, $can_last] = $this->mRatioCtl->ratio_match($mchid, $org_quality, $card_type, $spec, $all_qualities);
            Log::record("ratio_phone_quality mchid={$mchid} must calc next quality match_ratio={$match_ratio} can_last={$can_last}", Log::DEBUG);

            $times_qualities = $times_checker($match_ratio, $all_qualities, $used_times);
            $qualities_log("ratio_phone_quality {$mchid}-{$card_type}-{$spec} times_qualities", $times_qualities);

            $timeout_qualities = $timeout_checker($match_ratio, $all_qualities, $left_time);
            $qualities_log("ratio_phone_quality {$mchid}-{$card_type}-{$spec} timeout_qualities", $timeout_qualities);

            $pre_qualities = array_intersect($times_qualities, $timeout_qualities, $all_qualities);
            $qualities_log("ratio_phone_quality {$mchid}-{$card_type}-{$spec} pre_qualities", $pre_qualities);


            if (!$timeing_checker($pre_qualities)) {
                $pre_qualities = [];
                Log::record("calc_quality timeing_checker result is empty", Log::DEBUG);
            }

            $qualities_log("ratio_phone_quality {$mchid}-{$card_type}-{$spec} after timeing_checker qualities", $pre_qualities);
            $cur_qualities = $pre_qualities;

            if (!$can_last) {
                $all = $this->qualities($org_quality);
                $cur_qualities = PolicyUtil::mixed_remove_last($org_quality, $cur_qualities, $all);
            }
        }
        else {
            $match_ratio = true;
            $cur_qualities = $all_qualities;
        }


        return [$cur_qualities,$match_ratio];

    }

    private function max_times($mchid,$quality,$qualities)
    {
        [$succ, $times,$secs] = $this->mRatioCtl->total($mchid,$qualities);
        if ($succ) {
            return $times;
        } else {
            return $this->mSpeeds[$quality]['retry_times'];
        }
    }

    //通过每种类型通道耗时，倒推当前可用通道，并优先走推荐通道.
    private function calc_phone_quality($qualities,$fMixed, $cur_quality, $times, $used_time, $time_out, $max_times, $mchid)
    {
        $left_time = $time_out - $used_time;
        if(!$fMixed)
        {
            if($left_time <= 0 || $max_times <= $times) {
                return [];
            }
        }

        Log::record("calc_phone_quality begin qualities= " . implode(',',$qualities),Log::DEBUG);
        $times_checker = function($qualities, $times)
        {
            $result = [];
            $pre_times = 0;
            foreach ($qualities as $quality)
            {
                $pre_times += $this->mSpeeds[$quality]['retry_times'];
                if($times < $pre_times) {
                    $result[] = $quality;
                }
            }

            return $result;
        };

        $timeout_checker = function ($qualities, $left_time) use($fMixed,$cur_quality)
        {
            $qualities = array_reverse($qualities);
            if ($fMixed) {
                $fLasted = $cur_quality != $qualities[0];
            } else {
                $fLasted = false;
            }

            $result = [];
            foreach ($qualities as $quality)
            {
                $per_secs = $this->mSpeeds[$quality]['per_secs'];
                $left_time -= $per_secs;
                if($left_time > 0) {
                    $result[] = $quality;
                } else {
                    break;
                }
            }

            if(empty($result) && $fLasted) {
                $result[] = $qualities[0];
            }
            $result = array_reverse($result);
            return $result;
        };

        $pTryAdjuster = $this->mTryAdjuster;
        $timeing_checker = function ($qualities) use($pTryAdjuster,$mchid)
        {
            foreach ($qualities as $quality)
            {
                $ret = $pTryAdjuster->can_try($mchid,$quality);
                if($ret == false) {
                    return false;
                }
            }

            return true;
        };

        if($times > 0)
        {
            $qualities = $times_checker($qualities,$times);
            Log::record("calc_quality times_checker result = " . implode(',', $qualities), Log::DEBUG);
            $qualities = $timeout_checker($qualities,$left_time);
            Log::record("calc_quality timeout_checker result = " . implode(',', $qualities), Log::DEBUG);

            if(!$timeing_checker($qualities)) {
                $qualities = [];
                Log::record("calc_quality timeing_checker result is empty", Log::DEBUG);
            }
        }

        return $qualities;
    }
}