<?php

namespace addons\Agent\common\logic\reward;

use addons\Agent\common\enums\AgentEnum;
use addons\Agent\common\enums\ComputingEnum;
use addons\Agent\common\models\Agent;
use addons\Agent\common\models\AgentLevel;
use addons\Agent\common\models\AgentSupplierOrder;
use addons\PointUpperLimit\common\service\ScoreLogService;
use common\enums\AddonsEnum;
use common\enums\OrderStatusEnum;
use common\enums\RabbitMqEnum;
use common\enums\StatusEnum;
use common\helpers\FormatHelper;
use common\helpers\TaskHelper;
use common\models\order\OrderDetail;
use common\models\user\User;
use common\models\user\UserDigital;
use common\models\user\UserPartitionRelationship;
use PhpAmqpLib\Message\AMQPMessage;
use services\common\UserWalletService;

abstract class AgentBase
{
    public $mall_id;
    public $user_id;
    public $basic_conf;
    public $agent_list = [];
    public $name = '';//佣金：commission；积分：score
    public $team_prize_agents = [];
    public $self_buy_user_id;

    public $repurchase_reward;

    public $regular_bonus_handle_class = '\addons\RegularBonus\common\services\CommissionService';
    /** @var \addons\RegularBonus\common\services\CommissionService|null $regular_bonus_handle_instance */
    public $regular_bonus_handle_instance;
    public $is_enable_regular_bonus = 0;
    public $regular_bonus_goods_setting = [];

    public $user_level = null;         // 购买者等级

    /**
     * 是否为额外积分
     * @var bool
     */
    public $is_additional_score = false;

    /**
     * 额外积分与积分映射
     * @var string[]
     */
    protected $commission_name_map = [
        'additional_score'  => 'score'
    ];

    public $insert_wallet = [];

    public function __construct($mall_id, $user_id, $basic_conf, $agent_list, $self_buy_user_id, $repurchase_reward = StatusEnum::DISABLED, $name = 'commission')
    {
        $this->mall_id = $mall_id;

        //  如果是额外积分
        if ($name == 'additional_score') {
            $this->is_additional_score = true;
//            $name = 'score';
        }

        $this->name = $name;
        $this->user_id = $user_id;
        $this->basic_conf = $basic_conf;
        $this->agent_list = $agent_list;
        $this->self_buy_user_id = $self_buy_user_id;
        $this->repurchase_reward = $repurchase_reward;
    }

    public function addFrozenCommission()
    {
        // 验证
        $config = $this->getLevelConfig();
        $regular_bonus_setting = $this->regular_bonus_goods_setting;
        if (!isset($this->basic_conf['is_self_buy'])) $this->basic_conf['is_self_buy'] = 0;
//        if (!isset($this->basic_conf['enable_goods_deduct'])) $this->basic_conf['enable_goods_deduct'] = 0;
        if (!isset($this->basic_conf['team_prize_deep'])) $this->basic_conf['team_prize_deep'] = 0;
        if (!isset($this->basic_conf['equal_prize_deep'])) $this->basic_conf['equal_prize_deep'] = 0;
        if (!isset($this->basic_conf['equal_settle_type'])) $this->basic_conf['equal_settle_type'] = 0;
        if (!isset($this->basic_conf['calculation_basis'])) $this->basic_conf['calculation_basis'] = 0;
        if (!isset($this->basic_conf['over_settle_type'])) $this->basic_conf['over_settle_type'] = 0;
        if (!isset($this->basic_conf['over_calculation_basis'])) $this->basic_conf['over_calculation_basis'] = 0;
        if (!isset($this->basic_conf['is_find_equal_parent'])) $this->basic_conf['is_find_equal_parent'] = 0;
       if (!isset($this->basic_conf['enable_goods_deduct'])) $this->basic_conf['enable_goods_deduct'] = 0;
        if (!isset($this->basic_conf['find_a_level'])) $this->basic_conf['find_a_level'] = 0;
        if (!isset($this->basic_conf['alone_equal_settle_type'])) $this->basic_conf['alone_equal_settle_type'] = 0;
        if (!isset($this->basic_conf['is_enable_diff_bonus'])) $this->basic_conf['is_enable_diff_bonus'] = 0;
        if (!isset($this->basic_conf['is_equal_by_upgrade'])) $this->basic_conf['is_equal_by_upgrade'] = 0;
        ['money' => $money, 'multiple' => $multiple, 'extension' => $extension] = $this->getRules();
        // 所有经销商数量
        $all_agent_num = count($this->agent_list);
        $user_id_arr = [];
        // 初始化渠道奖代理
        if (empty($this->team_prize_agents)) {
            $current_agent_level = 0;
            foreach ($this->agent_list as $key => $agent) {
                $user_id_arr[] = $agent->user_id;
                if ($agent->level > $current_agent_level) {
                    $this->team_prize_agents[$key] = $agent;
                    $current_agent_level = $agent->level;
                }
            }
        }

        $parents_list = User::lists(['where' => [['in','id', $user_id_arr]], 'select' => 'id, parent_id', 'index' => 'id']);

        if (!empty($this->basic_conf['is_extra_equal_prize'])) {
            $user_ids = array_column($this->agent_list, 'user_id');
            $user_list = User::lists(['where' => [['id' => $user_ids]], 'select' => 'id,parent_id,second_parent_id', 'index' => 'id']);
        }
        $team_prize_num = 0;
        $team_prize_list = [];
        $log_total_price = 0;

        $regular_team_prize_num = 0;
        $regular_team_prize_list = [];
        $regular_log_total_price = 0;

        $drainage_subsidy_num = 0;
        $drainage_subsidy_prize_list = [];
        $log_total_price_drainage_subsidy = 0;


        $team_subsidy_num = 0;
        $team_subsidy_prize_list = [];
        $log_total_price_team_subsidy = 0;


        $extra_prize_list = [];
        $equal_prize_list = [];
        $over_prize_list = [];

        $regular_bonus_equal_prize_list = [];
        $regular_bonus_over_prize_list = [];

        $deduct_agent_prize_list = [];
        $equal_settle_type = 0;
        $province_id = $this->team_prize_agents[0]['province_id']  ?? 0;
        $recommend_prize = 0;
        $over_temp_money = $money;
        $over_reward_bear_user_id = 0;
        $is_exec_a_find = false;
        $is_level_a_find = false;
        $basic_money = $money;

        $over_temp_regular_bonus_money = $money;

        $has_over = false;              // 是否产生了越级奖
        if (($agentListCount = count($this->agent_list)) >= 2) {
            $temp_team_prize = 0;
            $temp_prize_num = 0;
            $temp_total_price = 0;
            $temp_j = 0;
            foreach ($this->team_prize_agents as $row) {
                if ($temp_prize_num < $this->basic_conf['team_prize_deep']) {
                    //计算渠道奖励
                    if (isset($config[$row->level])) {
                        $temp_team_prize = $this->computing($config[$row->level], $money, 'team');
                    }
                    switch ($this->basic_conf['over_calculation_basis']){
                        case 0:
                            // 是否开启平级奖独立计算方式
                            if (isset($this->basic_conf['is_over_computing_method']) && $this->basic_conf['is_over_computing_method']) {
                                $over_mothod = $this->basic_conf['over_computing_method'];
                                ['money' => $over_money] = $this->getRules($over_mothod);
                                $over_temp_money = $over_money;
                            }
                            break;
                        case 1://上级渠道奖或级差
                            if($temp_j==1) {
                                $over_temp_money = bcsub($temp_team_prize, $temp_total_price, 2);
                                $over_temp_regular_bonus_money = bcsub($temp_team_prize, $temp_total_price, 2);
                            }
                            break;
                        case 2://下级渠道奖或级差
                            if($temp_j==0){
                                $over_temp_money  = $temp_team_prize;
                                $over_temp_regular_bonus_money = $temp_team_prize;
                            }
                            break;
                    }
                    if ($temp_team_prize > 0){
                        $temp_prize_num++;
                        $temp_total_price = bcadd($temp_total_price, $temp_team_prize, 2);
                    }
                }

                switch ($this->basic_conf['over_settle_type']) {
                    case 1:
                        if($temp_j==1) {
                            $over_reward_bear_user_id  = $row->user_id;
                        }
                        break;
                    case 2:
                        if($temp_j==0) {
                            $over_reward_bear_user_id  = $row->user_id;
                        }
                        break;
                }
                $temp_j++;
            }
            //// 推荐人等级小于被推荐人，拿越级奖，只判断第一个拿渠道奖的上级是否会有越级奖
            if ($this->agent_list[0]->level >= $this->agent_list[1]->level) {
                // 循环找出可以拿越级奖的
                for ($agentListI = 1; $agentListI < $agentListCount; $agentListI++) {
                    // 设置了平级奖跳过的等级则跳过平级奖继续做越级奖判断
                    if (
                        !empty($this->basic_conf['is_enable_to_buyer_equal']) &&
                        !empty($this->basic_conf['skip_equal_level']) &&
                        $this->agent_list[$agentListI]->level == $this->basic_conf['skip_equal_level'] &&
                        $this->agent_list[$agentListI]->level == $this->agent_list[0]->level
                    ) continue;

                    if ($this->agent_list[$agentListI]->level >= $this->agent_list[0]->level) break;

                    // 如果开启了越级奖跳过某个等级，并且满足了跳过这个等级的条件
                    if (
                        !empty($this->basic_conf['is_enable_skip_level']) &&
                        isset($this->basic_conf['skip_level']) &&
                        is_numeric($this->basic_conf['skip_level']) &&
                        $this->agent_list[$agentListI]->level == $this->basic_conf['skip_level']
                    ) continue;

                    $over_agent = $this->agent_list[$agentListI]; break;
                }

                if (isset($over_agent)) {
                    $has_over = true;
                    $over_prize = $this->computing($config[$over_agent->level], $over_temp_money, 'over', $multiple);
                    if ($over_prize > 0) {
                        $over_prize_list[$over_agent->user_id] = ['price' => $over_prize, 'agent_id' => $over_agent->id, 'agent_level' => $over_agent->level];
                        if(!empty($over_reward_bear_user_id)){
                            if (!empty($deduct_agent_prize_list[$over_reward_bear_user_id]['deduct_money'])) {
                                $deduct_agent_prize_list[$over_reward_bear_user_id]['deduct_money'] += $over_prize;
                            } else {
                                $deduct_agent_prize_list[$over_reward_bear_user_id]['deduct_money'] = $over_prize;
                            }
                        }
                    }
                }
            }

            $regular_bonus_over_prize = 0;
            if (isset($regular_bonus_setting[$over_agent->level])) {
                $regular_bonus_over_prize = $this->computing($regular_bonus_setting[$over_agent->level], $over_temp_regular_bonus_money, 'over', $multiple);
                if ($regular_bonus_over_prize > 0) {
                    $regular_bonus_over_prize_list[$over_agent->user_id] = ['price' => $regular_bonus_over_prize, 'agent_id' => $over_agent->id, 'agent_level' => $over_agent->level];
                }
            }
        }
        $j = 0;
        foreach ($this->team_prize_agents as $key => $team_agent) {
            $team_prize = 0;
            $extra_prize = 0;
            $drainage_subsidy_prize = 0;
            $team_subsidy_prize = 0;
            $next_team_agent = next($this->team_prize_agents);
            if ($team_prize_num < $this->basic_conf['team_prize_deep']) {
                //计算渠道奖励
                if (isset($config[$team_agent->level])) {
                    $team_prize = $this->computing($config[$team_agent->level], $money, 'team', $multiple);
                }
                if ($team_prize > 0) {
                    $team_prize -= $log_total_price;
                    // 批处理组装数据
                    $team_prize_list[$team_agent->user_id] = ['price' => $team_prize, 'agent_id' => $team_agent->id, 'agent_level' => $team_agent->level];
                    $team_prize_num++;
                    $log_total_price = bcadd($log_total_price, $team_prize, 2);
                }

            }

            // 定期分红业务
            if ($regular_team_prize_num < $this->basic_conf['team_prize_deep']) {
                if (isset($regular_bonus_setting[$team_agent->level])) {
                    $regular_bonus_team_prize = $this->computing($regular_bonus_setting[$team_agent->level], $money, 'team', $multiple);
                }
                if ($regular_bonus_team_prize > 0) {
                    $regular_bonus_team_prize -= $regular_log_total_price;
                    // 批处理组装数据
                    $regular_team_prize_list[$team_agent->user_id] = ['price' => $regular_bonus_team_prize, 'agent_id' => $team_agent->id, 'agent_level' => $team_agent->level];
                    $regular_team_prize_num++;
                    $regular_log_total_price += $regular_bonus_team_prize;
                }
            }

            //计算引流补贴
            if (!empty($this->basic_conf['is_drainage_subsidy'])) {
                if ($drainage_subsidy_num < $this->basic_conf['team_prize_deep']) {
                    if (isset($config[$team_agent->level])) {
                        $drainage_subsidy_prize = $this->computing($config[$team_agent->level], $money, 'drainage_subsidy', $multiple);
                    }

                    if ($drainage_subsidy_prize > 0) {
                        $drainage_subsidy_prize -= $log_total_price_drainage_subsidy;
                        // 批处理组装数据
                        $drainage_subsidy_prize_list[$team_agent->user_id] = ['price' => $drainage_subsidy_prize, 'agent_id' => $team_agent->id, 'agent_level' => $team_agent->level];
                        $drainage_subsidy_num++;
                        $log_total_price_drainage_subsidy += $drainage_subsidy_prize;
                    }
                }
            }
            //计算渠道补贴
            if (!empty($this->basic_conf['is_team_subsidy'])) {
                if ($team_subsidy_num < $this->basic_conf['team_prize_deep']) {
                    if (isset($config[$team_agent->level])) {
                        $team_subsidy_prize = $this->computing($config[$team_agent->level], $money, 'team_subsidy', $multiple);
                    }


                    if ($team_subsidy_prize > 0) {
                        $team_subsidy_prize -= $log_total_price_team_subsidy;
                        // 批处理组装数据
                        $team_subsidy_prize_list[$team_agent->user_id] = ['price' => $team_subsidy_prize, 'agent_id' => $team_agent->id, 'agent_level' => $team_agent->level];
                        $team_subsidy_num++;
                        $log_total_price_team_subsidy += $team_subsidy_prize;
                    }
                }
            }
            //计算额外奖励
            if (isset($config[$team_agent->level])) {
                $extra_prize = $this->computing($config[$team_agent->level], $money, 'extra', $multiple);
            }

            if (!empty($extra_prize) && $extra_prize > 0) {
                // 批处理组装数据
                $extra_prize_list[$team_agent->user_id] = ['price' => $extra_prize, 'agent_id' => $team_agent->id, 'agent_level' => $team_agent->level];
            }

            $wait_deduct_equal_money = 0;
            // 平级奖与越级奖互斥
            $is_open_over_equal = true;
            if (!empty($this->basic_conf['is_enable_me_over_equal']) && $has_over) {
                $is_open_over_equal = false;
            }
            if ($this->basic_conf['is_equal'] && $is_open_over_equal) {
                $current_agent_list = array_slice($this->agent_list, $key + 1, $all_agent_num - $key - 1);
                // 与当前拿级差的人的等级比较，如果等于当前拿级差的人
                $team_agent_level = $team_agent->level;
                $equal_prize_num = 0; // 平级奖已领取层级数量
                $alone_equal_prize = $team_prize;//独立平级奖计算金额
                $alone_equal_user_id = 0;//最近拿平级奖代理
                $is_exec_find = false;

                $regular_bonus_equal_prize_num = 0;

                foreach ($current_agent_list as $k => $equal_agent) {
                    // 找到下一个拿级差的人就不继续往下找
                    if($this->basic_conf['is_find_equal_parent'] == 1 && ($this->basic_conf['find_a_level'] == 1 || $this->basic_conf['find_a_level'] == 2)){
                        if ($equal_agent->level - $team_agent_level > 1) break;
                    }else{
                        if ($equal_agent->level > $team_agent_level) break;
                    }

                    // 平级找直推上级
                    if($this->basic_conf['is_find_equal_parent']){
                        //只找直推上级
                        if($equal_agent->user_id != $parents_list[$team_agent->user_id]['parent_id']) break;
                        if(empty($this->basic_conf['find_a_level'])){
                            if($is_exec_find) break;
                        }elseif($this->basic_conf['find_a_level'] == 1){
                            if($is_exec_a_find) break;
                            $is_exec_a_find = true;
                        }elseif($this->basic_conf['find_a_level'] == 2){
                            if($is_level_a_find) break;
                            if(empty($config[$team_agent->level]['agent_equal_prize']) || $config[$team_agent->level]['agent_equal_prize'] == 0) break;
                            $is_level_a_find = true;
                        }
                        $is_exec_find = true;
                    }

                    // 如果和拿级差的人等级相同则该经销商可以获得平级奖
                    // 判断是否开启“首代平级奖开关”，开启之后，只判断拿第一个极差奖的代理，与他关系链最近的上级是否跟他平级，若平级则拿平级奖，反之不拿。
                    $bool_equal_agent = ($this->basic_conf['is_equal_prize_first'] && $j == 0 && $equal_agent->level == $team_agent_level && $k == 0) || (!$this->basic_conf['is_equal_prize_first'] && $equal_agent->level == $team_agent_level && $equal_prize_num < $this->basic_conf['equal_prize_deep']);
                    // 平级奖仅针对下单的人
                    if (!empty($this->basic_conf['is_enable_to_buyer_equal'])) {
                        // 与下单人等级不一样则跳过
                        !empty($this->user_level) && $equal_agent->level != $this->user_level && $bool_equal_agent = false;
                        // 设置了平级奖跳过的等级与当前等级一样也跳过
                        !empty($this->basic_conf['skip_equal_level']) && $equal_agent->level == $this->basic_conf['skip_equal_level'] && $bool_equal_agent = false;
                    }
                    if ($bool_equal_agent) {
                        $equal_prize = 0;
                        //独立平级奖计算
                        if(!empty($config[$team_agent->level]['is_alone_agent_equal_prize'])){
                            $alone_agent_equal_prize_info = $config[$team_agent->level]['alone_agent_equal_prize_info'];
                            if(!empty($alone_agent_equal_prize_info)){
                                foreach($alone_agent_equal_prize_info as $info){
                                    if($info['deep'] == $equal_prize_num + 1){
                                        if(!empty($config[$team_agent->level]['is_percent_equal'])){
                                            $equal_prize = $info['prize'] * $multiple;
                                        }else{
                                            if (empty($info['prize'])) {
                                                $info['prize'] = 0;
                                            }
                                            $equal_prize =  $alone_equal_prize * $info['prize'] / 100;
                                        }
                                    }
                                }
                            }
                        }else{
                            switch ($this->basic_conf['calculation_basis']) {
                                case ComputingEnum::EQUAL_COMPUTING:
                                    // 平级奖默认计算方式，$money
                                    $equal_money = $money;
                                    // 是否开启平级奖独立计算方式
                                    if ($this->basic_conf['is_equal_computing_method']) {
                                        $equal_mothod = $this->basic_conf['equal_computing_method'];
                                        ['money' => $equal_money] = $this->getRules($equal_mothod);
                                    }
                                    if (isset($config[$equal_agent->level])) {
                                        $equal_prize = $this->computing($config[$equal_agent->level], $equal_money, 'equal', $multiple);
                                    }

                                    break;
                                case ComputingEnum::EQUAL_COMPUTING_PARENT:
                                    // 计算依据，1=从上级极差收益计算可得的平级奖
                                    if ($team_prize_num < $this->basic_conf['team_prize_deep'] && !empty($next_team_agent)) {
                                        if (isset($config[$next_team_agent->level])) {
                                            $parent_team_prize = $this->computing($config[$next_team_agent->level], $money, 'team', $multiple);
                                            $parent_team_prize = bcsub($parent_team_prize, $log_total_price, 2);
                                            $equal_prize = $this->computing($config[$equal_agent->level], $parent_team_prize, 'equal');
                                        }
                                    }
                                    break;
                                case ComputingEnum::EQUAL_COMPUTING_CHILDREN:
                                    if (isset($config[$equal_agent->level])) {
                                        $equal_prize = $this->computing($config[$equal_agent->level], $team_prize, 'equal');
                                    }
                                    break;
                            }
                        }

                        if ($equal_prize > 0) {
                            // 从上/下一个拿级差的经销商手下扣除金额
                            $wait_deduct_equal_money += $equal_prize;
                            $equal_prize_num++;
                            //开启独立平级奖
                            if(!empty($config[$team_agent->level]['is_alone_agent_equal_prize'])){
                                // 首层 扣减 上级拿极差奖代理 非首层扣减上级拿平级奖代理
                                if(empty($this->basic_conf['alone_equal_settle_type'])){
                                    if($equal_prize_num == 1){
                                        if($equal_prize > $team_prize_list[$team_agent->user_id]['price']){
                                            $equal_prize = $team_prize_list[$team_agent->user_id]['price'];
                                            $team_prize_list[$team_agent->user_id]['price'] = 0;
                                        }else{
                                            $team_prize_list[$team_agent->user_id]['price'] -= $equal_prize;
                                        }
                                    }else{
                                        if($equal_prize > $equal_prize_list[$alone_equal_user_id]['price']){
                                            $equal_prize  =  $equal_prize_list[$alone_equal_user_id]['price'];
                                            $equal_prize_list[$alone_equal_user_id]['price'] = 0;
                                        }else{
                                            $equal_prize_list[$alone_equal_user_id]['price'] -= $equal_prize;
                                        }
                                    }
                                }
                                $alone_equal_prize = $equal_prize;
                                $alone_equal_user_id = $equal_agent->user_id;
                            }
                            // 批处理组装数据
                            $equal_prize_list[$equal_agent->user_id] = ['price' => $equal_prize, 'agent_id' => $equal_agent->id, 'agent_level' => $equal_agent->level];
                        }
                    }
                    // 定期分红业务
                    if ($equal_agent->level == $team_agent_level && $regular_bonus_equal_prize_num < $this->basic_conf['equal_prize_deep']) {
                        $regular_bonus_equal_prize = 0;
                        if (isset($regular_bonus_setting[$equal_agent->level])) {
                            $regular_bonus_equal_prize = $this->computing($regular_bonus_setting[$equal_agent->level], $money, 'equal', $multiple);
                        }
                        if ($regular_bonus_equal_prize > 0) {
                            $regular_bonus_equal_prize_num++;
                            // 批处理组装数据
                            $regular_bonus_equal_prize_list[$equal_agent->user_id] = ['price' => $regular_bonus_equal_prize, 'agent_id' => $equal_agent->id, 'agent_level' => $equal_agent->level];
                        }
                    }
                }
                //平级奖励，独立结算
                $agent_level = AgentLevel::findOne(['mall_id' => $this->mall_id, 'level' => $team_agent_level, 'status' => StatusEnum::ENABLED]);
                $equal_settle_type = $this->basic_conf['equal_settle_type'];
                if (!empty($agent_level['is_open_equal_settle_type'])) $equal_settle_type = $agent_level['equal_settle_type'];
            }
            //额外平级奖，平1，2级
            if (!empty($this->basic_conf['is_extra_equal_prize'])) {
                $current_agent_list = array_slice($this->agent_list, $key + 1, $all_agent_num - $key - 1);
                // 与当前拿级差的人的等级比较，如果等于当前拿级差的人
                $team_agent_level = $team_agent->level;
                $parent_id = $second_parent_id = 0;
                if (isset($user_list[$team_agent['user_id']])) {
                    $parent_id = $user_list[$team_agent['user_id']]['parent_id'];
                    $second_parent_id = $user_list[$team_agent['user_id']]['second_parent_id'];
                }
                // 默认平级奖
                if (empty($this->basic_conf['equal_prize_type'])) {
                    for ($i = 0; $i <= 1; $i++) {
                        if (isset($current_agent_list[$i])) {
                            $temp_agent = $current_agent_list[$i];
                            $temp_user_id = 0;
                            if ($team_agent_level == $temp_agent['level']) {
                                switch ($i) {
                                    case 0:
                                        $temp_user_id = $parent_id;
                                        break;
                                    case 1:
                                        $temp_user_id = $second_parent_id;
                                        break;
                                }
                                if ($temp_user_id == $temp_agent['user_id']) {
                                    $temp_key = $i + 1;
                                    $extra_equal_prize_key = 'extra_equal_prize' . $temp_key;
                                    if (!empty($config[$temp_agent['level']][$extra_equal_prize_key])) {
                                        $extra_equal_prize = $config[$temp_agent['level']][$extra_equal_prize_key] * ($this->order_detail['num'] ?? 1);
                                        $over_equal_prize_list[$i][$temp_agent['user_id']] = ['price' => $extra_equal_prize, 'agent_id' => $temp_agent['id'], 'agent_level' => $temp_agent['level']];
                                        $wait_deduct_equal_money += $extra_equal_prize;
                                    }
                                }
                            }
                        }
                    }
                } else { // 给同等级的极差奖
                    $num = 0;
                    foreach ($current_agent_list as $item) {
                        if ($item->level > $team_agent_level) {
                            break;
                        }

                        if ($item->level == $team_agent_level) {
                            $num++;

                            $temp_key = $num;
                            $extra_equal_prize_key = 'extra_equal_prize' . $temp_key;
                            if (!empty($config[$item->level][$extra_equal_prize_key])) {
                                $extra_equal_prize = $config[$item->level][$extra_equal_prize_key] * ($this->order_detail['num'] ?? 1);
                                $over_equal_prize_list[$temp_key - 1][$item->user_id] = ['price' => $extra_equal_prize, 'agent_id' => $item->id, 'agent_level' => $item->level];
                                $wait_deduct_equal_money += $extra_equal_prize;
                            }

                            if ($num >= 2) {
                                break;
                            }
                        }
                    }
                }
            }
            //未开启独立平级奖
            if(empty($config[$team_agent->level]['is_alone_agent_equal_prize'])){
                switch ($equal_settle_type) {
                    case ComputingEnum::EQUAL_SETTLE_PARENT:
                        //上级级拿渠道奖者付平级奖
                        if ($next_team_agent) {
                            if (!empty($deduct_agent_prize_list[$next_team_agent->user_id]['deduct_money'])) {
                                $deduct_agent_prize_list[$next_team_agent->user_id]['deduct_money'] += $wait_deduct_equal_money;
                            } else {
                                $deduct_agent_prize_list[$next_team_agent->user_id]['deduct_money'] = $wait_deduct_equal_money;
                            }
                        }
                        break;
                    case ComputingEnum::EQUAL_SETTLE_CHILDREN:
                        //下级拿渠道奖者付平级奖
                        $prev_team_agent = $team_agent;
                        if (empty($deduct_agent_prize_list[$prev_team_agent->user_id]['deduct_money'])) {
                            $deduct_agent_prize_list[$prev_team_agent->user_id]['deduct_money'] = $wait_deduct_equal_money;
                        } else {
                            $deduct_agent_prize_list[$prev_team_agent->user_id]['deduct_money'] += $wait_deduct_equal_money;
                        }
                        break;
                }
            }
            $j++;
        }

        if($this->basic_conf['is_self_buy'] && $this->basic_conf['is_enable_recommend_award'] && $team_prize_list) {
            $new_team_prize_list = [];
            $last_origin_team_prize = 0;
            $bear_recommend_prize = false;  //上级是否承担了推荐奖

            foreach ($this->agent_list as $one_agent) {

                //推荐奖
                $team_prize = $team_prize_list[$one_agent->user_id]['price'] ?? 0;
                $origin_team_prize = $team_prize;
                //echo 'user_id:'.$one_agent->user_id.',team_prize='.$team_prize.',province_id='.$one_agent->province_id.',level='.$one_agent->level.PHP_EOL;
                if($one_agent->user_id != $this->user_id){
                    if($one_agent->province_id == $province_id){
                        //同省
                        if($team_prize > 0 || $last_origin_team_prize > 0){

                            if(!$bear_recommend_prize && $recommend_prize > 0){
                                $team_prize = $team_prize - $recommend_prize;
                                $bear_recommend_prize = true;
                            }

                            if($last_origin_team_prize > 0 && $recommend_prize > 0){
                                $team_prize = $team_prize + $last_origin_team_prize;
                                //拿走了极差
                                $origin_team_prize = 0;
                            }
                            $new_team_prize_list[$one_agent->user_id] = ['price' => $team_prize, 'agent_id' => $one_agent->id, 'agent_level' => $one_agent->level];

                        }else{
                            $team_prize = 0;
                            if($recommend_prize == 0){
                                //推荐奖
                                $team_prize = $this->computing($config[$one_agent->level], $money, 'recommend', $multiple);
                                $recommend_prize = $team_prize;
                                $new_team_prize_list[$one_agent->user_id] = ['price' => $team_prize, 'agent_id' => $one_agent->id, 'agent_level' => $one_agent->level,'prize_type' => 'recommend'];
                            }

                        }
                    }else{
                        //跨省
                        $team_prize = 0;
                        if($recommend_prize == 0){
                            $team_prize = $this->computing($config[$one_agent->level], $money, 'recommend', $multiple);
                            $recommend_prize = $team_prize;
                            $new_team_prize_list[$one_agent->user_id] = ['price' => $team_prize, 'agent_id' => $one_agent->id, 'agent_level' => $one_agent->level,'prize_type' => ComputingEnum::RECOMMEND_PRIZE];
                        }
                    }

                    if($origin_team_prize != $team_prize && $origin_team_prize > 0 && $origin_team_prize != $team_prize + $recommend_prize){
                        $last_origin_team_prize = $origin_team_prize;
                    }else{
                        $last_origin_team_prize = 0;
                    }
                    //$last_origin_team_prize = $origin_team_prize > 0 ? $origin_team_prize : $last_origin_team_prize;

                }

                //$team_prize_list[$one_agent->user_id] = ['price' => $team_prize, 'agent_id' => $one_agent->id, 'agent_level' => $one_agent->level];
                 //$province_id = $one_agent->province_id;
            }
            $team_prize_list = $new_team_prize_list;
        }
        $insert_wallet = [];
        //极差分红
        if(!empty($this->self_buy_user_id) && !empty($this->basic_conf['is_self_buy']) && !empty($this->basic_conf['enable_goods_deduct']) && !empty($this->basic_conf['is_enable_diff_bonus'])){
            $is_self_buy = false;
            foreach($team_prize_list as $user_id => $team_prize){
                if($user_id == $this->self_buy_user_id){
                    $is_self_buy = true;
                    continue;
                }
                if(!$is_self_buy) continue;
                $diff_reward_money = $team_prize['price'];
                if($diff_reward_money > 0){
                    //上级代理奖励
                    if(!empty($this->basic_conf['parent_diff_bonus'])){
                        $parent_diff_money = $diff_reward_money * $this->basic_conf['parent_diff_bonus'] / 100;
                        if($parent_diff_money > 0){
                            $team_prize_list[$user_id]['price'] = $parent_diff_money;
                        }
                    }
                    //区域分红
                    if(!empty($this->basic_conf['diff_bonus_area'])){
                        $diff_bonus_area = json_decode($this->basic_conf['diff_bonus_area'],true);
                        $diff_bonus_area['compute_type'] = $this->basic_conf['compute_type'];
                        $result = $this->areaData($this->mall_id,$this->user_id,$diff_reward_money,$diff_bonus_area);
                        $insert_wallet = array_merge($insert_wallet, $result);
                    }
                    //指定账户
                    if(!empty($this->basic_conf['diff_bonus_user'])){
                        $diff_bonus_user_prize_list = [];
                        $diff_bonus_user = json_decode($this->basic_conf['diff_bonus_user'],true);
                        foreach($diff_bonus_user as $diff_user){
                            $diff_user_money = $diff_reward_money * $diff_user['prize'] / 100;
                            if($diff_user_money <= 0) continue;
                            $agent = Agent::findOne(['user_id' => $diff_user['id'], 'mall_id' => $this->mall_id, 'status' => StatusEnum::ENABLED]);// 查询用户身份
                            $diff_bonus_user_prize_list[$diff_user['id']] = ['price' => $diff_user_money, 'agent_id' => $agent ? $agent['id'] : 0, 'agent_level' => $agent ? $agent['level'] : 0];
                        }
                        $result = $this->packData(ComputingEnum::DIFF_USER, $this->basic_conf['compute_type'], $diff_bonus_user_prize_list, $extension);
                        $insert_wallet = array_merge($insert_wallet, $result);

                    }
                }
            }

        }
        //代理平级奖励
        if(!empty($this->basic_conf['is_equal_by_upgrade']) && !empty($team_prize_list)){
            $equal_by_upgrade_list = [];
            $equal_by_upgrade_lists = [];
            foreach ($this->team_prize_agents as $key => $team_agent) {
                if(array_key_exists($team_agent->user_id, $team_prize_list)){
                    //是否存在极差平级，存在则均分极差奖励
                    if(!empty($equal_by_upgrade_list)){
                        $num = count($equal_by_upgrade_list) + 1;
                        $equal_by_upgrade_money = $team_prize_list[$team_agent->user_id]['price'] / $num;
                        if($equal_by_upgrade_money > 0){
                            foreach($equal_by_upgrade_list as $user_id => $equal_by_upgrade_agent){
                                $equal_by_upgrade_lists[$user_id] = $equal_by_upgrade_agent;
                                $equal_by_upgrade_lists[$user_id]['price'] = $equal_by_upgrade_money;
                            }
                            $team_prize_list[$team_agent->user_id]['price'] = $equal_by_upgrade_money;
                        }
                        $equal_by_upgrade_list = [];
                    }
                    //当前拿极差代理
                    $current_agent_list = array_slice($this->agent_list, $key + 1, $all_agent_num - $key - 1);
                    foreach ($current_agent_list as $equal_agent) {
                        // 找到下一个拿级差的人就不继续往下找
                        if ($equal_agent->level > $team_agent->level) break;
                        $equal_by_upgrade_list[$equal_agent->user_id] = ['price' => 0, 'agent_id' => $equal_agent->id, 'agent_level' => $equal_agent->level];
                    }

                }
            }
            if(!empty($equal_by_upgrade_lists)){
                $result = $this->packData(ComputingEnum::EQUAL_UPGRADE, $this->basic_conf['compute_type'], $equal_by_upgrade_lists, $extension);
                $insert_wallet = array_merge($insert_wallet, $result);
            }
        }

        $repurchase_subsidy_prize_list1 = [];
        $repurchase_subsidy_prize_list2 = [];
        if(method_exists($this, 'handleRepurchaseSubsidy')){
            $repurchase_subsidy_prize_list = $this->handleRepurchaseSubsidy(
                $this->mall_id,
                $this->user_id,
                $config 
            );
            $repurchase_subsidy_prize_list1 = $repurchase_subsidy_prize_list['repurchase_subsidy_prize_list1']; 
            $repurchase_subsidy_prize_list2 = $repurchase_subsidy_prize_list['repurchase_subsidy_prize_list2']; 
        }

        if(!empty($repurchase_subsidy_prize_list1)){
            $result = $this->packData(ComputingEnum::REPURCHASE_SUBSIDY1, $this->basic_conf['compute_type'], $repurchase_subsidy_prize_list1, $extension);
            $insert_wallet = array_merge($insert_wallet, $result);
        }
        if(!empty($repurchase_subsidy_prize_list2)){
            $result = $this->packData(ComputingEnum::REPURCHASE_SUBSIDY2, $this->basic_conf['compute_type'], $repurchase_subsidy_prize_list2, $extension);
            $insert_wallet = array_merge($insert_wallet, $result);
        }

        $result = $this->getInsertWalletData($team_prize_list, $equal_prize_list, $extra_prize_list, $over_prize_list, $deduct_agent_prize_list);
        $insert_wallet = array_merge($insert_wallet, $result);
        //print_r($insert_wallet);exit;
        //引流补贴
        if (!empty($drainage_subsidy_prize_list)) {
            $result = $this->packData(ComputingEnum::DRAINAGE_SUBSIDY_PRIZE, $this->basic_conf['compute_type'], $drainage_subsidy_prize_list, $extension);
            $insert_wallet = array_merge($insert_wallet, $result);
        }
        //渠道补贴
        if (!empty($team_subsidy_prize_list)) {
            $result = $this->packData(ComputingEnum::TEAM_SUBSIDY_PRIZE, $this->basic_conf['compute_type'], $team_subsidy_prize_list, $extension);
            $insert_wallet = array_merge($insert_wallet, $result);
        }
        //额外平级奖，平1，2级
        if (!empty($over_equal_prize_list)) {
            $capital_type_map = [ComputingEnum::EXTRA_EQUAL_PRIZE_1,ComputingEnum::EXTRA_EQUAL_PRIZE_2];
            for ($i = 0; $i <= 1; $i++) {
                if(isset($over_equal_prize_list[$i])){
                    $extra_equal_reward_arr = $this->packData($capital_type_map[$i], $this->basic_conf['compute_type'], $over_equal_prize_list[$i], $extension);
                    $insert_wallet = array_merge($insert_wallet, $extra_equal_reward_arr);
                }
            }
        }
        //计算管理奖
        $manage_prize_list = [];
        if (!empty($this->basic_conf['is_manage_prize']) && $this->basic_conf['manage_prize_deep'] > 0 && !empty($team_prize_list)) {
            $agent_level_select = json_decode($this->basic_conf['agent_level_select'],true);
            if(!empty($agent_level_select)){
                $agent_level_info = json_decode($this->basic_conf['agent_level_info'],true);
                $manage_agent_num = $this->basic_conf['manage_prize_deep'];
                $manage_user_id = 0;
                $manage_key = 0;
                $manage_agent_level = 0;
                foreach($team_prize_list as $user_id => $team_prize){
                    if(in_array($team_prize['agent_level'],$agent_level_select)){
                        $manage_agent_level = $team_prize['agent_level'];
                        $manage_user_id = $user_id;
                        break;
                    }
                }
                if($manage_user_id && !empty($agent_level_info[$manage_agent_level])){
                    foreach($this->agent_list as $key => $agent){
                        if($agent['user_id'] == $manage_user_id){
                            $manage_key = $key;
                            break;
                        }
                    }
                    $manage_list = array_slice($this->agent_list, $key + 1);
                    $manage_agent_list = [];
                    $manage_agent_select = 0;
                    foreach($manage_list as $manage_item){
                        if(in_array($manage_item['level'],$agent_level_select)){
                            $manage_agent_list[] = $manage_item;
                            $manage_agent_select++;
                        }
                        if($manage_agent_select == $manage_agent_num) break;
                    }
                    if(!empty($manage_agent_list)){
                        $i = 0;
                        foreach($manage_agent_list as $manage_agent){
                            $manage_money = 0;
                            if(!empty($agent_level_info[$manage_agent_level][$i])){
                                $manage_money = $money * $agent_level_info[$manage_agent_level][$i]['prize']  * $multiple / 100;
                            }
                            if($manage_money > 0){
                                $manage_prize_list[$manage_agent['user_id']] = ['price' => $manage_money, 'agent_id' => $manage_agent['id'], 'agent_level' => $manage_agent['level']];
                            }
                            $i++;
                            if($i == $manage_agent_num) break;
                        }
                    }
                }
            }

        }
        if(!empty($manage_prize_list)){
            $result = $this->packData(ComputingEnum::MANAGE_PRIZE, $this->basic_conf['compute_type'], $manage_prize_list, $extension);
            $insert_wallet = array_merge($insert_wallet, $result);
        }

        $regular_bonus_insert_wallet = $this->obtainInsertWalletData($regular_team_prize_list, $regular_bonus_equal_prize_list, $regular_bonus_over_prize_list, []);
        if(!empty($regular_bonus_insert_wallet)){
            $insert_wallet = array_merge($insert_wallet, $regular_bonus_insert_wallet);
        }

        // 批量插入数据
        $money = 0;
        try {
            //投递到资产队列
            if ($insert_wallet) {

                //  如果是额外积分那么插件那边需要记录一下
                if ($this->is_additional_score) {
                    $insert_wallet = (new ScoreLogService())->batchInsert($insert_wallet);
                }

                if (empty($insert_wallet)) return 0;

                if($this->name != 'digital'){
                    $res = UserWalletService::batchHandleByQueue($insert_wallet);
                    if (empty($res)) throw new \Exception(UserWalletService::getStaticError());
                }

                $status = StatusEnum::ENABLED;

                foreach ($insert_wallet as $k => $user) {
                    if($user['wallet_type'] == 'digital'){
                        $res = UserDigital::handleUserDigital($user['mall_id'],$user['user_id'],$user['money'],$user['is_frozen'],$user);
                        if($res === false) continue;
                    }
                    if($user['from_type'] == AddonsEnum::ADDONS_NAME_REGULAR_BONUS. '_'. AgentEnum::ADDONS_NAME) continue;
                    $agent = Agent::findOne(['user_id' => $user['user_id'],'status'=>[StatusEnum::DISABLED,StatusEnum::ENABLED], 'mall_id' => $this->mall_id]);
                    if(empty($agent)) continue;
                    $field = 'total_' . ($this->commission_name_map[$this->name] ?? $this->name);
                    $agent->$field += $user['money'];
                    if (!in_array($user['capital_type'], [ComputingEnum::DRAINAGE_SUBSIDY_PRIZE, ComputingEnum::TEAM_SUBSIDY_PRIZE])) {
                        $money += $user['money'];
                    }
                    $res = $agent->save();
                    if (empty($res)) throw new \Exception(Agent::getStaticError());
                }
                if($this->name=='commission'){
                    $agent = Agent::findOne(['user_id' => $this->user_id, 'mall_id' => $this->mall_id, 'status' => StatusEnum::ENABLED]);// 查询购买者身份
                    $buy_user_level = 0;
                    if(!empty($agent)) $buy_user_level = $agent['level'];
                    $agent_list = [];
                    foreach ($this->agent_list as $agent){
                        $agent_list[$agent['user_id']] = [
                            'level'=>$agent['level']
                        ];
                    }
                    $insert_data = [
                        'insert_wallet'=>$insert_wallet,
                        'order_no'=>$this->order_detail['order_no'],
                        'goods_nums'=>$this->order_detail['num'],
                        'buy_user_id'=>$this->user_id,
                        'buy_level'=>$buy_user_level,
                        'payment_amount'=>$basic_money,
                        'agent_list'=>$agent_list,
                    ];
                    \Yii::$app->services->rabbitMq->push(RabbitMqEnum::EXCHANGE_ORDER, RabbitMqEnum::ORDER_QUEUE, $insert_data, AgentSupplierOrder::class, 'insertData');
                }
                if($this->is_enable_regular_bonus){
                    if(property_exists($this, 'order_detail') && !empty($this->order_detail)){
                        TaskHelper::pushTaskQueue(RabbitMqEnum::EXCHANGE_TASK,RabbitMqEnum::TASK_QUEUE, [
                            'mall_id' => $this->mall_id, 'order_detail_id' => $this->order_detail['id'], 'addons_name' => AgentEnum::ADDONS_NAME, 'status' => (int)$status,
                        ], $this->regular_bonus_handle_class, 'handleAgentOrDistributionWalletData', function(AMQPMessage $message){
                            // 生产错误
                            \Yii::error('发送异步任务失败');
                        });
                    }

                }
            }
            $this->insert_wallet = $insert_wallet;
            $this->addRewardConfigLog();
            return $money;
        } catch (\Exception $e) {
            echo 'AgentBase:addFrozenCommission ' . ($this->order_detail['order_no'] ?? ' 无订单号 ') . FormatHelper::exception($e, __METHOD__);
            return 0;
        }
    }

    //额外平级奖，平1，2级
    public function extraEqual($config)
    {
        $user = User::findOne(['id' => $this->user_id]);
        $parent_id = $user['parent_id'];
        $second_parent_id = $user['second_parent_id'];
        $temp_agent_list = array_column($this->agent_list, null, 'user_id');
        $over_equal_prize_list1 = $over_equal_prize_list2 = [];
        $agent_model = Agent::findOne(['user_id' => $this->user_id, 'status' => StatusEnum::ENABLED]);

        if (!empty($agent_model)) {
            //平一级
            if (!empty($temp_agent_list[$parent_id]) && $temp_agent_list[$parent_id]['level'] == $agent_model['level']) {
                $agent = $temp_agent_list[$parent_id];
                if (!empty($config[$agent['level']]['extra_equal_prize1'])) {
                    $over_equal_prize_list1[$agent['user_id']] = ['price' => $config[$agent['level']]['extra_equal_prize1'], 'agent_id' => $agent['id'], 'agent_level' => $agent['level']];
                }
            }
            //平二级
            if (!empty($temp_agent_list[$second_parent_id]) && $temp_agent_list[$second_parent_id]['level'] == $agent_model['level']) {
                $agent = $temp_agent_list[$second_parent_id];
                if (!empty($config[$agent['level']]['extra_equal_prize2'])) {
                    $over_equal_prize_list2[$agent['user_id']] = ['price' => $config[$agent['level']]['extra_equal_prize2'], 'agent_id' => $agent['id'], 'agent_level' => $agent['level']];
                }
            }
        }
        return [$over_equal_prize_list1, $over_equal_prize_list2];
    }


    /**
     * @desc:计算
     * @Author: hua
     * @Date: 2021/10/27
     * @Time: 18:28
     * @Copyright: copyright (c) 2021 广东七件事集团
     * @param $config
     * @param $money
     * @param $type
     * @param int $multiple
     * @return float|int
     */
    public function computing($config, $money, $type, $multiple = 1)
    {
        $is_percent_key = "is_percent_{$type}";
        $agent_prize_key = "agent_{$type}_prize";
        $num = 0;
        if (isset($config[$is_percent_key]) && isset($config[$agent_prize_key])) {
//            $num = $config[$is_percent_key] == 0 ? $money * $config["agent_{$type}_prize"] / 100 * $multiple : $config[$agent_prize_key] * $multiple;
            // 金额精确到小数点后两位
            $agentPrice = $money * $config["agent_{$type}_prize"] / 100;
            $num = $config[$is_percent_key] == 0 ? bcmul($agentPrice, $multiple, 2) :
                bcmul($config[$agent_prize_key], $multiple , 2);
        }
        return $num;
    }

    abstract public function getLevelConfig();

    abstract public function getRules(int $method = null);

    abstract public function addRewardConfigLog();

    abstract public function getInsertWalletData($team_prize_list, $equal_prize_list, $extra_prize_list, $over_prize_list, $deduct_agent_prize_list);

    public function obtainInsertWalletData($team_prize_list, $equal_prize_list, $over_prize_list, $deduct_agent_prize_list){
        return [];
    }
}