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;   // 1 -> 3 -> 2
    const NormalQuick = 14;
    const SlowSixNormal = 15;
    const NormalCardkey = 16;
    const NormalQuickCardkey = 17; //1->2->3
    const QuickCardkey = 18; //2 -> 3
    const CardkeyNormalQuick = 19;

    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(order $order, $caller): array
    {
        $card_type = $order->card_type();
        $is_phone = function ($card_type)
        {
            $types = [mtopcard\ChinaMobileCard, mtopcard\ChinaUnicomCard, mtopcard\ChinaTelecomCard];
            if (in_array($card_type, $types)) {
                return true;
            }
            else {
                return false;
            }
        };

        $is_oil = function ($card_type)
        {
            $types = [mtopcard\PetroChinaCard, mtopcard\SinopecCard];
            if (in_array($card_type, $types)) {
                return true;
            }
            else {
                return false;
            }
        };

        if($is_phone($card_type)) {
            return $this->mobile_quality($order);
        }
        elseif($is_oil($card_type)) {
            [$org, $qualities] = $this->oil_quality($order, $caller);
            return [$org,$qualities,false];
        }
        else {
            return [0, [],false];
        }
    }

    private function oil_quality(order $order, $caller): array
    {
        $mchid = $order->mchid();
        $quality = $order->org_quality();
        $times = $order->commit_times();
        $used_time = $order->elapse_secs();

        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);
        $order->set_can_overprice(true, false);

        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(order $order): array
    {
        $mchid = $order->mchid();
        $org_quality = $order->org_quality();

        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(!empty($qualities)) {
            $order->set_first_quality($qualities[0]);
        }

        //有成功率控制，需要用大数据计算的
        if ($this->mRatioCtl->exist($mchid)) {
            Log::record("ratio_phone_quality exist=true",Log::DEBUG);
            [$qualities, $match_ratio] = $this->ratio_phone_quality($order, $qualities);
            return [$org_quality, $qualities, $match_ratio];
        } else {
            $fMixed = PolicyUtil::mixed_quality($org_quality);
            $qualities = $this->calc_phone_quality($order, $qualities, $fMixed, $time_out, $max_times);
            return [$org_quality, $qualities, false];
        }
    }

    private function time_checker(order $order, $qualities)
    {
        $mchid = $order->mchid();
        $commit_times  = $order->commit_times();
        $used_time   = $order->elapse_secs();
        $ch_filter   = $order->filter();
        $cur_quality = $order->cur_quality();
        $order_time = $order->order_time();

        //用于计算
        $calc_steps = function ($mchid, $qualities) use ($ch_filter, $order_time)
        {
            $steps = [];

            $cdf = [0,0];
            foreach ($qualities as $quality)
            {
                $qua_times = $this->mRatioCtl->times($mchid, $quality);
                $qua_secs =  $this->mRatioCtl->seconds($mchid, $quality);

                if($qua_times == false || $qua_secs == false) {
                    continue;
                }

                $cdf[0] += $qua_times;
                $cdf[1] += $qua_secs;
                $cdf[2]  = $qua_times;

                Log::record("ratio_phone_quality time_checker time=$cdf[0] secs=$cdf[1]", Log::DEBUG);
                $steps[$quality] = $cdf;

                $ch_filter->set_timeout($quality,$order_time + $cdf[1]);
            }

            return $steps;
        };

        $calc_usable_qualities = function ($qualities, $steps) use ($cur_quality, $commit_times, $used_time, $ch_filter)
        {
            $usable = [];

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

                if($compare === false) {
                    continue;
                }

                if(!array_key_exists($quality,$steps)) {
                    continue;
                }

                [$max_times,$max_secs,$qua_times] = $steps[$quality];
                $per_secs = $ch_filter->per_secs($quality);
                Log::record("ratio_phone_quality time_checker a per_secs=$per_secs", Log::DEBUG);

                if($per_secs == 0) {
                    $per_secs = $this->mSpeeds[$quality]['per_secs'];
                    Log::record("ratio_phone_quality time_checker b per_secs=$per_secs", Log::DEBUG);
                }

                if($max_times > $commit_times and $max_secs > $used_time + $per_secs)
                {
                    [$cur_times,$cur_secs] = $ch_filter->total($quality);
                    if($qua_times > $cur_times) {
                        $usable[] = $quality;
                    }
                }
            }

            return $usable;
        };

        $steps = $calc_steps($mchid,$qualities);
        $matches = $calc_usable_qualities($qualities, $steps);

        return $matches;
    }
    
    private function ratio_phone_quality(order $order, $all_qualities)
    {
        $mchid = $order->mchid();
        $org_quality = $order->org_quality();

        $spec  = $order->spec();
        $card_type = $order->card_type();
        $used_times = $order->commit_times();
        $used_time = $order->elapse_secs();

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

        $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);

            $order->set_can_overprice($match_ratio,$can_last);

            $pre_qualities = $this->time_checker($order, $all_qualities);
            $qualities_log("ratio_phone_quality $mchid-$card_type-$spec usable_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;
        }
        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(order $order, $qualities, $fMixed, $time_out, $max_times)
    {
        $mchid = $order->mchid();
        $used_times = $order->commit_times();
        $used_time = $order->elapse_secs();

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

        $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($used_times > 0)
        {
            $qualities = $this->time_checker($order, $qualities);
            Log::record("calc_phone_quality times_checker result = " . implode(',', $qualities), Log::DEBUG);

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

        return $qualities;
    }
}