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 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, $times, $used_time, $caller): array
    {
        $trace = new scope_trace(__METHOD__);
        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, $times, $used_time);
        }
        elseif($card_type == mtopcard\PetroChinaCard || $card_type == mtopcard\SinopecCard) {
            return $this->oil_quality($mchid, $org_quality, $times,$used_time,$caller);
        }
        else {
            return [0, []];
        }
    }

    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, $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,[]];
        }

        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 = $this->ratio_phone_quality($org_quality, $qualities, $cur_quality, $times, $used_time, $mchid, $card_type, $spec);
            return [$org_quality, $qualities];
        } else {
            $fMixed = PolicyUtil::mixed_quality($org_quality);
            $qualities = $this->calc_phone_quality($qualities, $fMixed, $cur_quality, $times, $used_time, $time_out, $max_times, $mchid);
            return [$org_quality, $qualities];
        }
    }

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

        $left_time = $time_out - $used_time;
        if ($left_time <= 0 || $max_times <= $times) {
            return [];
        }

        $match_ratio = $this->mRatioCtl->ratio_match($mchid, $org_quality, $cur_quality, $card_type, $spec, $qualities);

        Log::record("ratio_phone_quality begin qualities= " . implode(',',$qualities),Log::DEBUG);
        $times_checker = function ($qualities, $times) use ($match_ratio, $cur_quality, $max_times, $mchid)
        {
            $result = [];
            $pre_times = 0;

            $compare = $cur_quality > 0 ? false : true;
            foreach ($qualities as $quality)
            {
                if($compare == false)
                {
                    if($quality == $cur_quality) {
                        $compare = true;
                    }
                }
                if($compare == false) continue;

                if ($match_ratio) {
                    $result[] = $quality;
                }
                else
                {
                    $qtimes = $this->mRatioCtl->times($mchid, $quality);
                    if($qtimes == false) continue;

                    $pre_times += $qtimes;
                    if ($times < $pre_times) {
                        $result[] = $quality;
                    }
                }
            }

            return $result;
        };

        $timeout_checker = function ($qualities, $left_time) use($cur_quality,$match_ratio,$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) {
                        $left_time -= $per_secs;
                        $result[] = $quality;
                    }
                    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;
        };

        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;

    }

    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;
    }
}