<?php

namespace App\Service;

use App\Enums\BoolEnum;
use App\Enums\LottState;
use App\Enums\LottType;
use App\Enums\OptimizeType;
use App\Enums\OrderType;
use App\Enums\PayState;
use App\Enums\PlayType;
use App\Exceptions\JingCaiException;
use App\Model\Config;
use App\Model\Customer\Customer;
use App\Model\Lottery;
use App\Model\LotteryType;
use App\Model\Order;
use App\Model\OrderJczqResult;
use App\Model\OrderZuhe;
use App\Model\Seller\Seller;
use App\Model\Zq\JczqOdds;
use App\Model\Zq\JczqResult;
use App\Utils\Helps;
use App\Utils\ThrowException;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class JczqService implements IJingcai
{
    use JingCaiTrait;

    /** @var PlayTypeService playTypeService */
    protected $playTypeService;

    public function __construct()
    {
        $this->playTypeService = app(PlayTypeService::class);
    }

    public function playTypeNames()
    {
        return [
            'bf_odds'  => '全场比分',
            'jq_odds'  => '总进球',
            'bqc_odds' => '半全场胜平负',
            'spf_odds' => '胜平负',
            'rq_odds'  => '让球胜平负',
        ];
    }

    public function getPlayTypeName($playType)
    {
        $fieldNames = $this->playTypeNames();
        $result     = $fieldNames[$playType];
        return $result;
    }

    public function resultFieldNames()
    {
        return [
            // 胜平负
            'single'   => '单关',
            'win'      => '胜',
            'draw'     => '平',
            'loss'     => '负',
            'handicap' => '让球数',
            // 比分
            'wh1a0'    => '1:0',
            'wh2a0'    => '2:0',
            'wh2a1'    => '2:1',
            'wh3a0'    => '3:0',
            'wh3a1'    => '3:1',
            'wh3a2'    => '3:2',
            'wh4a0'    => '4:0',
            'wh4a1'    => '4:1',
            'wh4a2'    => '4:2',
            'wh5a0'    => '5:0',
            'wh5a1'    => '5:1',
            'wh5a2'    => '5:2',
            'wx'       => '胜其他',
            'dh0a0'    => '0:0',
            'dh1a1'    => '1:1',
            'dh2a2'    => '2:2',
            'dh3a3'    => '3:3',
            'dx'       => '平其他',
            'lh0a1'    => '0:1',
            'lh0a2'    => '0:2',
            'lh1a2'    => '1:2',
            'lh0a3'    => '0:3',
            'lh1a3'    => '1:3',
            'lh2a3'    => '2:3',
            'lh0a4'    => '0:4',
            'lh1a4'    => '1:4',
            'lh2a4'    => '2:4',
            'lh0a5'    => '0:5',
            'lh1a5'    => '1:5',
            'lh2a5'    => '2:5',
            'lx'       => '负其他',

            // 半全场
            'ww'       => '胜胜',
            'wd'       => '胜平',
            'wl'       => '胜负',
            'dw'       => '平胜',
            'dd'       => '平平',
            'dl'       => '平负',
            'lw'       => '负胜',
            'ld'       => '负平',
            'll'       => '负负',

            // 进球数
            'g0'       => '0',
            'g1'       => '1',
            'g2'       => '2',
            'g3'       => '3',
            'g4'       => '4',
            'g5'       => '5',
            'g6'       => '6',
            'g7m'      => '7',
        ];
    }

    public static function inWinFields($playType, $field)
    {
        $fields = self::winFields($playType);
        return in_array($field, $fields);
    }
    public static function winFields($playType)
    {
        if ($playType == PlayType::RQ || $playType == PlayType::SPF) {
            return ['win'];
        }
        if ($playType == PlayType::BF) {
            return [
                'wh1a0',
                'wh2a0',
                'wh2a1',
                'wh3a0',
                'wh3a1',
                'wh3a2',
                'wh4a0',
                'wh4a1',
                'wh4a2',
                'wh5a0',
                'wh5a1',
                'wh5a2',
                'wx'   ,
            ];
        }
        if ($playType == PlayType::JQ) {
            return [ 'g1' , 'g2' , 'g3' , 'g4' ,'g5' ,'g6' ,'g7m',];
        }
        if ($playType == PlayType::BQC) {
            return ['ww', 'wd', 'wl'];
        }
        return [];
    }

    public static function inDrawFields($playType, $field)
    {
        $fields = self::drawFields($playType);
        return in_array($field, $fields);
    }
    public static function drawFields($playType)
    {
        if ($playType == PlayType::RQ || $playType == PlayType::SPF) {
            return ['draw'];
        }
        if ($playType == PlayType::BF) {
            return [
                'dh0a0',
                'dh1a1',
                'dh2a2',
                'dh3a3',
                'dx',
            ];
        }
        if ($playType == PlayType::JQ) {
            return ['g0' , 'g2', 'g4' ,'g6',];
        }
        if ($playType == PlayType::BQC) {
            return ['dw', 'dd', 'dl'];
        }
        return [];
    }
    public static function inLossFields($playType, $field)
    {
        $fields = self::lossFields($playType);
        return in_array($field, $fields);
    }
    public static function lossFields($playType)
    {
        if ($playType == PlayType::RQ || $playType == PlayType::SPF) {
            return ['loss'];
        }
        if ($playType == PlayType::BF) {
            return [
                'lh0a1',
                'lh0a2',
                'lh1a2',
                'lh0a3',
                'lh1a3',
                'lh2a3',
                'lh0a4',
                'lh1a4',
                'lh2a4',
                'lh0a5',
                'lh1a5',
                'lh2a5',
                'lx',
            ];
        }
        if ($playType == PlayType::JQ) {
            return [ 'g1' , 'g2' , 'g3' , 'g4' ,'g5' ,'g6' ,'g7m',];
        }
        if ($playType == PlayType::BQC) {
            return ['lw', 'ld', 'll'];
        }
        return [];
    }


    public function maxPrizeSpliceWdlOdds($matchOdds, $rqHandicap = null)
    {
        $winArray = [];
        $drawArray = [];
        $lossArray = [];

        foreach ($matchOdds as $playType => $playData) {

            foreach ($playData as $field => $odds) {

                if ($playType == PlayType::RQ) {
                    $rqNum = $rqHandicap;
                    if ($rqHandicap === null) {
                        continue;
                    }
                    if ($rqNum == 1) {
                        if ( $field == 'win') {
                            $winArray[PlayType::RQ][$field] = $odds;
                            $drawArray[PlayType::RQ][$field] = $odds;
                        }
                        if ( $field == 'draw') {
                            $lossArray[PlayType::RQ][$field] = $odds;
                        }
                        if ($field == 'loss') {
                            $lossArray[PlayType::RQ][$field] = $odds;
                        }
                    } else if($rqNum >= 2) {
                        if ($field == 'win') {
                            $winArray['rq_odds'][$field] = $odds;
                            $drawArray['rq_odds'][$field] = $odds;
                            $lossArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'draw') {
                            $lossArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'loss') {
                            $lossArray['rq_odds'][$field] = $odds;
                        }
                    } else if($rqNum == -1) {
                        if ($field == 'win') {
                            $winArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'draw') {
                            $winArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'loss') {
                            $drawArray['rq_odds'][$field] = $odds;

                            $lossArray['rq_odds'][$field] = $odds;
                        }
                    } else if($rqNum <= -2) {
                        if ($field == 'win') {
                            $winArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'draw') {
                            $winArray['rq_odds'][$field] = $odds;
                        }
                        if ( $field == 'loss') {
                            $winArray['rq_odds'][$field] = $odds;
                            $drawArray['rq_odds'][$field] = $odds;
                            $lossArray['rq_odds'][$field] = $odds;
                        }
                    }
                } else {
                    if (JczqService::inWinFields($playType, $field)) {
                        $winArray[$playType][$field] = $odds;
                    }
                    if (JczqService::inLossFields($playType, $field)) {
                        $lossArray[$playType][$field] = $odds;
                    }
                    if (JczqService::inDrawFields($playType, $field)) {
                        $drawArray[$playType][$field] = $odds;
                    }
                }
            }
        }
        foreach ($winArray as $playType => $playData) {
            $winArray[$playType] = $this->maxPrizeSearchMaxOdd($playData);
        }
        foreach ($drawArray as $playType => $playData) {
            $drawArray[$playType] = $this->maxPrizeSearchMaxOdd($playData);
        }
        foreach ($lossArray as $playType => $playData) {
            $lossArray[$playType] = $this->maxPrizeSearchMaxOdd($playData);
        }


        $winOdds = $this->maxPrizeSumPlayOdd($winArray);
        $maxOdds = $winOdds;
        $result = $winArray;
        $drawOdds = $this->maxPrizeSumPlayOdd($drawArray);

        if ($drawOdds > $maxOdds) {
            $maxOdds = $drawOdds;
            $result = $drawArray;
        }
        $lossOdds = $this->maxPrizeSumPlayOdd($lossArray);
        if ($lossOdds > $maxOdds) {
            $result = $lossArray;
        }
        return $result;
    }

    /**
     * @param $oddsData {id => {rf_odds:{win:1.1}}}
     * @param $handicapList {id => 11}
     * @return array
     */
    public function maxPrizeZuheList($oddsData, $passModes, $handicapList)
    {
        foreach ($oddsData as $id => $matchOddsData) {
            $handicap = Arr::get($handicapList, $id);
            $searchResult = $this->maxPrizeSpliceWdlOdds($matchOddsData, $handicap);
            $result[$id] = $searchResult;
        }
        $zuhes = $this->generateBetsInfo($result,$passModes, 1);
        return $zuhes;
    }

    /**
     * @param $oddsData {id => {rf_odds:{win:1.1}}}
     * @param $handicapList {id => 11}
     * @return array
     */
    public function maxPrizeCompute($oddsData,$passModes,  $handicapList)
    {
        $zuhes = $this->maxPrizeZuheList($oddsData,$passModes, $handicapList);
        $prize = 0;
        foreach ($zuhes as $zuhe) {
            $prize += $zuhe['all_odds'] * 2;
        }
        return $prize;
    }

    public function getResultFieldName($playType, $field)
    {
        $fieldNames = $this->resultFieldNames();
        $result     = $fieldNames[$field];
        if (!in_array($field, ['win', 'loss', 'draw']) || $playType != 'rq_odds') {
            return $result;
        }
        return '让' . $result;
    }
    public static function generateZqPassModeInfo($oddsData, $playType)
    {
        $matchNum = count($oddsData);
        if ($matchNum == 1) {
            $oddsId = array_key_first($oddsData);
            $jczqOdds = JczqOdds::find($oddsId);
            $oddInfo = $oddsData[$oddsId];
            foreach ($oddInfo as $play =>$v) {
                $info = $jczqOdds->{$play};
                ThrowException::isTrue(!$info, '无此玩法:'.$play);
                ThrowException::isTrue($info['single'] != 1, '该玩法不支持单关'.$play);
            }
            return [
                'multi' => [['key' => '1.1', 'title' => '单关']],
                'single' => []
            ];
        }

        /** @var JczqService $service */
        $service = app(JczqService::class);
        $hasSingle = $service->getSingleOdds($oddsData);


        $maxChuan = 8; // 最高8场比赛
        foreach ($oddsData as $item) {
            if (Arr::get($item, PlayType::BF) || Arr::get($item, PlayType::BQC)) {
                if ($maxChuan > 4) {
                    $maxChuan = 4;
                }
            }
            if (Arr::get($item, PlayType::JQ)) {
                if ($maxChuan > 6) {
                    $maxChuan = 6;
                }
            }
        }

        $rules = self::passModes();
        $multi = []; // 多选（自由过关）
        $one = []; // 单选（M串N）
        foreach ($rules as $chang => $zhuData) {
            if ($chang == 1) {
                if ($hasSingle) {
                    $multi[] = [
                        'key' => sprintf('%d.%d', $chang, 1),
                        'title' => '单关',
                    ];
                }
                continue;
            }
            if ($chang > $maxChuan) {
                continue;
            }
            if ($chang > $matchNum) {
                continue;
            }
            foreach ($zhuData as $k => $zhu) {
                $item = [
                    'key' => sprintf('%d.%d', $chang, $k),
                    'title' => sprintf('%d串%d', $chang, $k),
                ];

                if ($chang <= $matchNum && $k == 1) {
                    $multi[] = $item;
                }
                if ($chang == $matchNum && $k >= $matchNum && !isset($zhu[1])) {
                    $one[] = $item;
                }
            }
        }
        sort($one);
        return [
            'multi' => $multi,
            'single' => $one
        ];
    }
    public function getSingleOdds($oddData) {
        $oddsIds = array_keys($oddData);
        if (!$oddsIds) {
            return [];
        }
        $jclqOdds = JczqOdds::whereIn('id', $oddsIds)->get();
        $result = [];

        foreach ($jclqOdds as $odd) {
            $oddDataItem = Arr::get($oddData, $odd->id);
            ThrowException::isTrue(!$oddDataItem, '单关比赛不存在');
            foreach ($oddDataItem as $playType => $playData) {
                foreach ($playData as $key => $val) {
                    if ($odd->{$playType} === null) {
                        Log::error('jczqService:getSingleOdds not found playType', [
                            'oddsData' => $oddData,
                            'oddDataItem' => $oddDataItem,
                            'playType' => $playType,
                            'odd' => $odd->toArray(),
                        ]);
                        ThrowException::run('单关数据有误');
                    }
                    if (Arr::get($odd->{$playType}, 'single') != 1) {
                        return [];
                    }
                    $result[] = [ $this->generateJczqCombinationItem($odd->id, $playType, $key) ];
                }
            }
        }
        return $result;
    }

    public function saleLotteries(Customer $customer, $lotteryTypeId)
    {
        $lotteryType = LotteryType::where('type', LottType::JCZQ)
            ->where('status', BoolEnum::YES)
            ->find($lotteryTypeId);
        ThrowException::isTrue(!$lotteryType, '不支持此彩种');

        /** @var Lottery $lottery */
        $lottery = Lottery::active()
            ->shopAndType($customer->shop_id, $lotteryTypeId)
            ->first();
        ThrowException::isTrue(!$lotteryType, '店铺不支持此彩种');

        $odds = JczqOdds::selling()
            ->where('real_close_time', '>', date('Y-m-d H:i:s', time() + $lottery->earlySecond()))
            ->orderBy('issue_num', 'asc')
            ->get();

        $result = [
            'play_types' => PlayType::asJczqSelectArray(),
        ];

        $competitions = [];
        /** @var JczqOdds $odd */
        foreach ($odds as $odd) {

            if (!in_array($odd->jc_competition_name, $competitions)) {
                $competitions[] = $odd->jc_competition_name;
            }
            $odd->jc_competition_name = preg_replace('/[0-9]/', '', $odd->jc_competition_name);
            $realCloseTime            = strtotime($odd->real_close_time) - $lottery->earlySecond();
            $odd->real_close_time     = date('Y-m-d H:i:s', $realCloseTime);
            $odd->real_close_str      = date('H:i', $realCloseTime) . '截止';
            $odd->spf_odds            = Helps::compareOdds($odd->spf_odds, $odd->spf_odds_last);
            $odd->rq_odds             = Helps::compareOdds($odd->rq_odds, $odd->rq_odds_last);
            $odd->bf_odds             = Helps::compareOdds($odd->bf_odds, $odd->bf_odds_last);
            $odd->jq_odds             = Helps::compareOdds($odd->jq_odds, $odd->jq_odds_last);
            $odd->bqc_odds            = Helps::compareOdds($odd->bqc_odds, $odd->bqc_odds_last);

            JczqOdds::unsetLastSuffixField($odd);
        }
        if ($competitions) {
            array_unshift($competitions, '全部');
        }

        $result['competitions'] = $competitions;
        $result['odds']         = $odds;

        return $result;
    }


    public function refreshOdds($data)
    {
        $ids = array_keys($data);
        throw_if(!$ids, JingCaiException::create('请选择比赛进行投注'));

        $odds   = JczqOdds::whereIn('id', $ids)->get();
        $odds   = collect($odds);
        ThrowException::isTrue($odds->count() != count($ids), '比赛数据错误，请重新选择');

        $result = [];
        foreach ($data as $id => $val) {
            $item = [];
            foreach ($val as $playType => $playData) {
                $oddItem = $odds->where('id', $id)->first();
                foreach ($playData as $k => $v) {
                    $odd = Arr::get($oddItem, $playType . '.' . $k);
                    if (!$odd) {
                        Log::error('JczqService->refreshOdds数据错误', [
                            'data' => $data,
                            'key'  => $playType . '.' . $k,
                            'val'  => $odd,
                            'id'   => $id,
                        ]);
                    }

                    throw_if($odd === null, JingCaiException::create('数据错误，请重新选择'));

                    $item[$playType][$k] = Arr::get($oddItem, $playType . '.' . $k);
                }
            }
            $result[$id] = $item;
        }
        return $result;
    }

    public function computePrizeInfo($data, $betsNum = 1, $passModeKeys = [])
    {
        return $this->computePrizeInfoV3($data, $betsNum, $passModeKeys);
        sort($passModeKeys);
        $zhuTotal       = 0;
        $min = 0;
        $max = 0;
        foreach ($passModeKeys as $key) {
            $passModes = self::getPassMode($key);
            foreach ($passModes as $chang => $changeGe) {
                $prizeInfo = $this->generatePrizeOdds($data, $chang);
                $zhuTotal += $prizeInfo['zhu_num'];
                if (!$min) {
                    $min = $prizeInfo['min'];
                }
                if ($prizeInfo['min'] < $min) {
                    $min = $prizeInfo['min'];
                }
                $max += $prizeInfo['max'];
            }
        }
        return [
            'zhu_num'   => $zhuTotal,
            'expect_bets'   => $max,
            'money'     => Helps::floatFormat($zhuTotal * $betsNum * Config::lotteryUnitPrice()),
            'prize_min' => Helps::floatFormat($min * $betsNum * Config::lotteryUnitPrice()),
            'prize_max' => Helps::floatFormat($max * $betsNum * Config::lotteryUnitPrice()),
        ];
    }

    public function computePrizeInfoV2($data, $betsNum = 1, $passModeKeys = [])
    {
        sort($passModeKeys);
        $lastKey = array_pop($passModeKeys);
        // 最大的串法
        $betsList = $this->generateBetsInfo($data, [$lastKey], $betsNum);

        $maxBetsOdd = 0;
        $maxUnique = '';
        foreach ($betsList as $item) {
            if ($item['all_odds'] > $maxBetsOdd) {
                $maxBetsOdd = $item['all_odds'];
                $maxUnique = $item['unique'];
            }
        }
        $allBetsResultUnique = [];
        $allBetsResult = $betsList;

        $allPrizes = [];

        $maxUniqueArray = [];
        // 其余串法
        foreach ($betsList as $item) {
            $betItemPrize = $this->getBetsInfoPrize($item);

            if ($item['unique'] == $maxUnique) {
                $maxUniqueArray[] = $item['unique'];
            }
            @$allBetsResultUnique[$item['unique']] += 1;
            $keyOddsData = $this->betsInfoToOdds($item);

            foreach ($passModeKeys as $key) {
                $keyBetsData = $this->generateBetsInfo($keyOddsData, [$key], $betsNum);

                foreach ($keyBetsData as $kitem) {
                    @$allBetsResultUnique[$kitem['unique']] += 1;
                    $betKItemPrize = $this->getBetsInfoPrize($kitem);
                    @$allPrizes[$kitem['unique']] += $betKItemPrize;

                    if ($item['unique'] == $maxUnique) {
                        $maxUniqueArray[] = $kitem['unique'];
                    }
                }
                $allBetsResult = array_merge($allBetsResult, $keyBetsData);
            }
            $allPrizes[$item['unique']] = $betItemPrize;
        }
        $maxPrize = 0;
        foreach ($allPrizes as $unique => $prize) {
            if (in_array($unique, $maxUniqueArray)) {
                $maxPrize += $prize;
            }
        }
        sort($allPrizes);
        $minPrize = $allPrizes[0];

        $zhuTotal = count($allBetsResult);
        return [
            'zhu_num'   => $zhuTotal,
            'expect_bets'   => $maxPrize / $betsNum / Config::lotteryUnitPrice(),
            'money'     => Helps::floatFormat($zhuTotal * $betsNum * Config::lotteryUnitPrice()),
            'prize_min' => Helps::floatFormat($minPrize),
            'prize_max' => Helps::floatFormat($maxPrize),
        ];
    }

    public function computePrizeInfoV3($data, $betsNum = 1, $passModeKeys = [])
    {
        $piaos = $this->createPiaoV3($data, $passModeKeys, $betsNum);
        $maxPrize = 0;
        $minPrize = null;
        $maxPrizeIndex = null;
        $allBetsResultUnique = [];
        $zhuTotal = 0;
        foreach ($piaos as $idx => $piao) {
            if ($piao['prize'] > $maxPrize) {
                $maxPrize = $piao['prize'];
                $maxPrizeIndex = $idx;
            }
            foreach ($piao['bets'] as $betsInfo) {
                $zhuTotal += 1;
                @$allBetsResultUnique[$betsInfo['unique']] += 1;
                $betItemPrize = $this->getBetsInfoPrize($betsInfo);
                if (isset($minPrize)) {
                    $minPrize = $minPrize < $betItemPrize ? $minPrize : $betItemPrize;
                } else {
                    $minPrize = $betItemPrize;
                }
            }
        }


        $jclqOdds = JczqOdds::whereIn('id', array_keys($data))->pluck('rq_odds', 'id')->toArray();
        $handicapList = [];
        foreach ($jclqOdds as $id => $item) {
            if ($item) {
                $handicapList[$id] = $item['handicap'];
            }
        }
        $maxZuheList = $this->maxPrizeZuheList($data, $passModeKeys, $handicapList);
        $maxPrize = 0;
        foreach ($maxZuheList as $zuhe) {
            $repeatNum = $allBetsResultUnique[$zuhe['unique']];
            $maxPrize += $repeatNum * $this->getBetsInfoPrize($zuhe);
        }

        $maxPrize *= $betsNum;

        return [
            'zhu_num'   => $zhuTotal,
            'expect_bets'  => Helps::floatFormat( $maxPrize / $betsNum / Config::lotteryUnitPrice()),
            'money'     => Helps::floatFormat($zhuTotal * $betsNum * Config::lotteryUnitPrice()),
            'prize_min' => Helps::floatFormat($minPrize),
            'prize_max' => Helps::floatFormat($maxPrize),
        ];
    }


    public function generatePrizeOdds($data, $len)
    {
        // 说明是单关
        if ($len == 1) {
            $combinationData = $this->getSingleOdds($data);
        } else {
            $errRes = [
                'zhu_num' => 0,
                'min'     => 0,
                'max'     => 0,
            ];
            $fdata  = $this->generateCombinationInput($data);
            if (!$fdata) {
                Log::error('generatePrize格式化数据失败', [
                    'data' => $data,
                    'len'  => $len
                ]);
                return $errRes;
            }
            $combinationData = Helps::getCombinationData($fdata, $len);
            if (!$combinationData) {
                Log::error('generatePrize生成组合数据失败', [
                    'fdata' => $fdata,
                    'len'   => $len
                ]);
                return $errRes;
            }
        }

        $prizes   = [];
        $zhuTotal = count($combinationData);
        foreach ($combinationData as $keyArr) {
            $keyOdds = 1;
            foreach ($keyArr as $key) {
                $keyInfo     = $this->parseJczqCombinationItem($key);
                $baseItemArr = Arr::get($data, $keyInfo['id']);
                $odds        = Arr::get($baseItemArr, $keyInfo['play'] . '.' . $keyInfo['result'], null);
                $keyOdds     *= $odds;
            }
            $prizes[] = $keyOdds;

        }
        sort($prizes, SORT_ASC);
        return [
            'zhu_num' => $zhuTotal,
            'min'     => $prizes[0],
            'max'     => $prizes[count($prizes) - 1],
        ];
    }

    public function generateJczqCombinationItem($id, $playType, $result)
    {
        return sprintf('%d-%s-%s', $id, $playType, $result);
    }

    public function parseJczqCombinationItem($key)
    {
        $info = explode('-', $key);
        return [
            'id'     => $info[0],
            'play'   => $info[1],
            'result' => $info[2],
        ];
    }

    public function generateCombinationInput($data, $hasOdds = false)
    {
        $result = [];
        foreach ($data as $id => $item) {
            $resItem = [];
            foreach ($item as $k => $itemData) {
                foreach ($itemData as $kk => $kkv) {
                    $resKey           = $this->generateJczqCombinationItem($id, $k, $kk);
                    if ($hasOdds) {
                        $resItem[$resKey] = $kkv;
                    } else {
                        $resItem[$resKey] = $resKey;
                    }
                }
            }
            $result[] = $resItem;
        }
        return $result;
    }

    public function getBetsInfoFromCombinationData($data, $betsNum = 1, $dataOdd)
    {
        $result = [];
        foreach ($data as $zuheInfo) {
            $resultItem = [];
            $allOdds = 1;
            foreach ($zuheInfo as $key) {
                $keyInfo                            = $this->parseJczqCombinationItem($key);
                $keyInfo['odd']                     = $this->getBetsOddFromCombinationData($key, $dataOdd);
                $allOdds *= $keyInfo['odd'];
                $resultItem['ids'][]                = intval($keyInfo['id']);
                $resultItem['keys'][]               = $key;
                $resultItem['info'][$keyInfo['id']] = $keyInfo;
                $resultItem['bets_num']             = $betsNum;
            }

            $tempKeys = $resultItem['keys'];
            sort($tempKeys);
            $resultItem['unique'] = implode(';', $tempKeys);
            $resultItem['all_odds'] = $allOdds;
            $resultItem['chuan_num'] = count($resultItem['ids']);

            $result[] = $resultItem;
        }
        return $result;
    }

    public function piaoMatchSame50($piao, $betsInfo)
    {

        $samePlay = false;
        foreach ($piao['bets'] as $item) {
            if ($item['bets_num'] != Config::piaoMaxBetsNum()) {
                continue;
            }
            $intersectIds = array_intersect($item['ids'], $betsInfo['ids']);


            if (count($intersectIds) == count($betsInfo['ids']) &&
                count($intersectIds) == count($item['ids'])) {

                $samePlay = true;
                foreach ($intersectIds as $id) {

                    if ($item['info'][$id]['play'] == $betsInfo['info'][$id]['play'] &&
                        $item['info'][$id]['result'] == $betsInfo['info'][$id]['result']) {
                    } else {
                        $samePlay = false;
                    }
                }
            }
            if ($samePlay) {
                return $samePlay;
            }
        }
        return false;
    }
    public function piaoMatchCanAddPlay($piao, $betsInfo)
    {
        foreach ($piao['bets'] as $item) {
            $intersectIds = array_intersect($item['ids'], $betsInfo['ids']);
            if ($intersectIds) {
                foreach ($intersectIds as $id) {
                    if ($item['info'][$id]['play'] != $betsInfo['info'][$id]['play']) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public function piaoAddBets(&$piaos, $betsInfo)
    {
        if (count($piaos) == 0) {
            $betsNumAll = $betsInfo['bets_num'];
            // 超出限制，添加一部分，返回剩余的
            if ($betsNumAll > Config::piaoMaxBetsNum()) {
                $addNum = Config::piaoMaxBetsNum();
                $tempBetsInfo             = $betsInfo;
                $betsInfo['bets_num']     = $addNum;
                $piaos[0]['bets'][]       = $betsInfo;
                $piaos[0]['bets_num']     = $addNum;
                $tempBetsInfo['bets_num'] -= $addNum;
                return $this->piaoAddBets($piaos, $tempBetsInfo);
            }

            $piaos[0] = [
                'bets'     => [$betsInfo],
                'bets_num' => $betsInfo['bets_num']
            ];
            $addPiao = true;
            return $addPiao;
        }
        foreach ($piaos as $pk => $piao) {
            // 同一场只能出现一个玩法
            $addPiaoIndex = $pk;
            $tempPiaoIndex = $pk;
            while (true) {
                if ($tempPiaoIndex >= count($piaos)) {
                    $addPiaoIndex = count($piaos);
                    break;
                }
                $tempPiao = $piaos[$tempPiaoIndex];
                $can = $this->piaoMatchCanAddPlay($tempPiao, $betsInfo);
                if (!$can) {
                    $tempPiaoIndex += 1;
                } else {
                    if ($this->piaoMatchSame50($tempPiao, $betsInfo)) {
                        $tempPiaoIndex += 1;
                    } else {
                        $addPiaoIndex = $tempPiaoIndex;
                        break;
                    }
                }
            }
//
//            if (!$can) {
//                $nextPk = count($piaos);
//
//                $betsNumAll = $betsInfo['bets_num'];
//                // 超出限制，添加一部分，返回剩余的
//                if ($betsNumAll > Config::piaoMaxBetsNum()) {
//                    $addNum       = Config::piaoMaxBetsNum();
//                    $tempBetsInfo = $betsInfo;
//
//                    $betsInfo['bets_num'] = $addNum;
//
//                    $piaos[$nextPk]['bets'][]   = $betsInfo;
//                    $piaos[$nextPk]['bets_num'] = $addNum;
//
//                    $tempBetsInfo['bets_num'] -= $addNum;
//                    return $this->piaoAddBets($piaos, $tempBetsInfo);
//                }
//
//                $piaos[$nextPk] = [
//                    'bets'     => [$betsInfo],
//                    'bets_num' => $betsInfo['bets_num']
//                ];
//                return true;
//            }


            $betsNumAll = $betsInfo['bets_num'];
            // 超出限制，添加一部分，返回剩余的
            if ($betsNumAll > Config::piaoMaxBetsNum()) {
                $addNum = Config::piaoMaxBetsNum();


                $tempBetsInfo             = $betsInfo;
                $betsInfo['bets_num']     = $addNum;
                $piaos[$addPiaoIndex]['bets'][]       = $betsInfo;
                @$piaos[$addPiaoIndex]['bets_num']     += $addNum;
                $tempBetsInfo['bets_num'] -= $addNum;
                return $this->piaoAddBets($piaos, $tempBetsInfo);
            }

            $piaos[$addPiaoIndex]['bets'][]   = $betsInfo;
            @$piaos[$addPiaoIndex]['bets_num'] += $betsInfo['bets_num'];
            return true;
        }
    }

    public function createPiaos($betsInfos)
    {
        $piaoArr = [];
        foreach ($betsInfos as $item) {
            $keyCount = count($item['ids']);
            $piaoArr[$keyCount][] = $item;
        }

        $piaoResult = [];
        foreach ($piaoArr as $piaoItem) {
            $piaos = [];
            foreach ($piaoItem as $betsInfo) {
                $this->piaoAddBets($piaos, $betsInfo);
            }
            $piaoResult = array_merge($piaoResult, $piaos);

        }
        return $piaoResult;
    }

    public function valid(Lottery $lottery, $playType, $data)
    {
        throw_if(count($data) > 8, JingCaiException::create('最多只能选择八场比赛'));

        $this->playTypeService->validPlayType($playType, $data);

        if ($lottery->plan_multi == BoolEnum::YES) {
            $allowPlanNum = $lottery->plan_num;
            $this->validZuHe($allowPlanNum, $data);
        }


        $odds        = [];
        $oneMutilNum = 0;
        foreach ($data as $id => $item) {
            $odds = array_merge($odds, array_keys($item));
            if (count($item) > 1) {
                $oneMutilNum += 1;
            }
        }
        if ($lottery->one_multi == BoolEnum::YES && $oneMutilNum > 1) {
            JingCaiException::throwJingcai("只能选择其中一场比赛进行玩法多选");
        }
    }

    /**
     * 校验组合方案
     */
    public function validZuHe($allowPlanNum, $data, $combinationLen=2)
    {
        $oddsMatch = $this->generateCombinationInput($data);
        $zuhes = Helps::getCombinationData($oddsMatch, $combinationLen);
        if (count($zuhes) > $allowPlanNum) {
            JingCaiException::throwJingcai("允许的方案组合不超过{$allowPlanNum}个");
        }
    }


    /**
     * 根据用户的下注数据，生成购物车中的比赛下注信息
     * @param Array $matchs
     * @return array
     */
    public function getJczqOddsFromData(Lottery $lottery, $oddsData)
    {
        $jczqCount = JczqOdds::selling()->whereIn('id', array_keys($oddsData))->count();
        throw_if($jczqCount != count($oddsData), JingCaiException::create('比赛信息有误'));
        $odds = JczqOdds::selling()
            ->whereIn('id', array_keys($oddsData))
            ->orderBy('real_close_time', 'asc')
            ->orderBy('play_num', 'asc')
            ->get();

        $result = [];
        foreach ($odds as $odd) {

            $odd->jc_competition_name = preg_replace('/[0-9]/', '', $odd->jc_competition_name);

            $realCloseTime        = strtotime($odd->real_close_time) - $lottery->earlySecond();
            $odd->real_close_time = date('Y-m-d H:i:s', $realCloseTime);
            $odd->real_close_str  = date('H:i', $realCloseTime) . '截止';

            unset($odd->spf_odds_last);
            unset($odd->rq_odds_last);
            unset($odd->bf_odds_last);
            unset($odd->jq_odds_last);
            unset($odd->bqc_odds_last);


            if (@$oddsData[$odd->id]['spf_odds']) {
                $odd->spf_odds = Helps::copyProperty($odd->spf_odds, $oddsData[$odd->id]['spf_odds']);
            } else {
                unset($odd->spf_odds);
            }
            if (@$oddsData[$odd->id]['rq_odds']) {
                $odd->rq_odds = Helps::copyProperty($odd->rq_odds, $oddsData[$odd->id]['rq_odds']);
            } else {
                unset($odd->rq_odds);
            }
            if (@$oddsData[$odd->id]['bf_odds']) {
                $odd->bf_odds = Helps::copyProperty($odd->bf_odds, $oddsData[$odd->id]['bf_odds']);
            } else {
                unset($odd->bf_odds);
            }
            if (@$oddsData[$odd->id]['jq_odds']) {
                $odd->jq_odds = Helps::copyProperty($odd->jq_odds, $oddsData[$odd->id]['jq_odds']);
            } else {
                unset($odd->jq_odds);
            }
            if (@$oddsData[$odd->id]['bqc_odds']) {
                $odd->bqc_odds = Helps::copyProperty($odd->bqc_odds, $oddsData[$odd->id]['bqc_odds']);
            } else {
                unset($odd->bqc_odds);
            }
            $result[] = $odd;
        }
        return $result;
    }

    public function generateBetsInfo($odds, $passModeKeys, $betsNum)
    {
        $data   = $this->generateCombinationInput($odds);
        $result = [];
        foreach ($passModeKeys as $key) {
            $passModes = self::getPassMode($key);
            foreach ($passModes as $chang => $changeGe) {
                if ($chang == 1) {
                    $combinationData = $this->getSingleOdds($odds);
                } else {
                    $combinationData = Helps::getCombinationData($data, $chang);
                }
                $result          = array_merge($result, $combinationData);
            }
        }
        $dataOdd   = $this->generateCombinationInput($odds, true);
        return $this->getBetsInfoFromCombinationData($result, $betsNum, $dataOdd);
    }

    public function createOrder(Customer $customer, $data)
    {
        $optimizeZuhe     = Arr::get($data, 'optimize_zuhe');
        $optimizeType     = Arr::get($data, 'optimize_type');
        $totalMonay       = Arr::get($data, 'money');
        $lotteryTypeId     = Arr::get($data, 'lottery_type_id');
        $playType          = Arr::get($data, 'play_type');
        $type              = Arr::get($data, 'type', OrderType::NORMAL);
        $fadanSecret       = Arr::get($data, 'type_mode', 1);
        $fadanDesc         = Arr::get($data, 'type_desc', '');
        $betsNum           = Arr::get($data, 'bets_num');
        $passModeKeys      = Arr::get($data, 'pass_mode_keys');
        $odds              = Arr::get($data, 'odds'); // 购买的场次或投注信息
        $union_piece_total = intval(Arr::get($data, 'union_piece_total', 0));
        $union_piece_buy   = intval(Arr::get($data, 'union_piece_buy', 0));
        $union_piece_keep  = intval(Arr::get($data, 'union_piece_keep', 0));
        $union_keep        = Arr::get($data, 'union_keep', BoolEnum::NO);
        $union_brokerage   = intval(Arr::get($data, 'union_brokerage', 0));
        $fadan_order_no    = Arr::get($data, 'fadan_order_no', '');

        if ($optimizeZuhe) {
            $optimizeBetsNumArray = array_column($optimizeZuhe, 'bets_num');
            $allMoney = array_sum($optimizeBetsNumArray) * 2;
            if (Helps::floatFormat($allMoney) != Helps::floatFormat($totalMonay)) {
                ThrowException::run('投注数据有误，请重试！');
            }
        }

        throw_if(!PlayType::hasValue($playType), JingCaiException::create('无效的玩法!'));

        /** @var Lottery $lott */
        $lott = LotteryService::getLottery($customer->shop->id, $lotteryTypeId);
        throw_if(!$lott, JingCaiException::create('店铺未开通该彩种!'));

        $this->valid($lott, $playType, $odds);

        $odds = $this->refreshOdds($odds);

        $computeInfo = $this->computePrizeInfo($odds, $betsNum, $passModeKeys);

        if (!OptimizeType::hasValue($optimizeType)) {
            $optimizeType = 0;
        } else {

            $computeInfo['prize_max'] = 0;
            $computeInfo['money'] = $totalMonay;
        }

        $lott->validMixMoney($computeInfo['money']);

        if ($type == OrderType::FADAN) {
            throw_if(!$fadanDesc, JingCaiException::create('请填写发单宣言!'));
            $this->canCreateFanDanOrder($customer->id);
            ThrowException::isTrue($this->fadanValid($computeInfo['money'], $computeInfo['prize_min']), '最低奖金大于等于投注金额的1.6倍');
        }

        if ($type == OrderType::UNION) {
            $lott->validEnableHemai();
            throw_if(!$fadanDesc, JingCaiException::create('请填写合买宣言!'));
            ThrowException::isTrue($union_piece_total <= 0, '总份数不能小于0');
            $piecePrice = $computeInfo['money'] / $union_piece_total;
            ThrowException::isTrue($piecePrice <= 1, '每份金额必须大于1');

            ThrowException::isTrue($union_piece_buy > $union_piece_total, '超过方案总金额');
            if ($union_keep == BoolEnum::YES) {
                $union_piece_keep = $union_piece_total - $union_piece_buy;
            }

            $this->canCreateUnionOrder($customer->id);
        }

        $pid = 0;
        if ($type == OrderType::GENDAN) {
            $fadanOrder = Order::sn($fadan_order_no)->first();
            ThrowException::isTrue(!$fadanOrder, '所跟订单不存在');

            ThrowException::isTrue($fadanOrder->lottery_state != LottState::WAIT, '订单状态有误');
            ThrowException::isTrue(date('Y-m-d H:i:s') > $fadanOrder->odds_early_close_time, '所跟订单已结束投注');
            $pid = $fadanOrder->id;
            $fadanSecret = $fadanOrder->type_mode;
        }

        DB::beginTransaction();
        try {

            $jczqOdds   = JczqOdds::whereIn('id', array_keys($odds))->get();
            $closeTimes = [];
            $oddsCloseTimes = [];
            foreach ($jczqOdds as $match) {
                $realCloseTime   = strtotime($match->real_close_time) - $lott->earlySecond();
                $real_close_time = date('Y-m-d H:i:s', $realCloseTime);
                $closeTimes[]    = $real_close_time;
                $oddsCloseTimes[] = $match->real_close_time;
            }
            sort($closeTimes);
            sort($oddsCloseTimes);
            $earlyTime = $closeTimes[0];
            $oddsCloseTime = $oddsCloseTimes[0];
            $lateTime  = $closeTimes[count($closeTimes) - 1];

            $this->checkCloseTimeOver($earlyTime);

//            $betsInfos = $this->generateBetsInfo($odds, $passModeKeys, $betsNum);
//            $piaos     = $this->createPiaos($betsInfos);
            $piaos     = $this->createPiaosV2($odds, $passModeKeys, $betsNum, $optimizeZuhe);
            $piaoZhang = array_sum(array_column($piaos, 'zhang'));
            $order                        = new Order();
            $order->pid                   = $pid;
            $order->customer_id           = $customer->id;
            $order->lottery_id            = $lott->id;
            $order->shop_id               = $customer->shop_id;
            $order->lottery_type_id       = $lott->lottery_type_id;
            $order->order_sn              = Order::makeOrderSn();
            $order->play_type             = $playType;
            $order->bets_num              = $betsNum;
            $order->bets_expect_num       = $computeInfo['expect_bets'];
            $order->zhu_num               = $computeInfo['zhu_num'];
            $order->piao_num              = $piaoZhang;
            $order->money                 = $computeInfo['money'];
            $order->prize_min             = $computeInfo['prize_min'];
            $order->prize_max             = $computeInfo['prize_max'];
            $order->pay_state             = PayState::UNPAID;
            $order->pass_mode             = $passModeKeys;
            $order->odds_close_time       = $oddsCloseTime;
            $order->odds_early_close_time = $earlyTime;
            $order->odds_late_close_time  = $lateTime;
            $order->type                  = $type;
            $order->type_mode             = $fadanSecret;
            $order->type_desc             = $fadanDesc;
            $order->odds                  = $odds;
            $order->optimize_type         = $optimizeType;
            if ($type == OrderType::UNION) {
                $pieceMoney               = $order->money / $union_piece_total;
                $order->union_piece_total = $union_piece_total;
                $order->union_piece_buy   = $union_piece_buy;
                $order->union_piece_self  = $union_piece_buy;
                $order->union_piece_keep  = $union_piece_keep;
                $order->union_keep        = $union_keep;
                $order->union_brokerage   = $union_brokerage;
                $order->union_piece_money = $pieceMoney;
                $order->union_money       = $pieceMoney * ($union_piece_buy + $union_piece_keep);
            }
            $order->created_date = date('Ymd');
            // 设置合作相关的数据
            $order->setCooperateInfo($lott);
            $order->save();

            // 如果是合买,更新自己的pid
            if ($order->type == OrderType::UNION) {
                $order->pid = $order->id;
                $order->save();
            }

            // 创建组合数据
            $betsInfos = $this->getZuheListFromPiaos($piaos);
            $this->createZuhe($betsInfos, $order->id, $optimizeZuhe);

            $orderOdds = [];
            foreach ($jczqOdds as $match) {

                $oldData     = $odds[$match->id];
                $orderOdds[] = [
                    'order_id'     => $order->id,
                    'jczq_odds_id' => $match->id,
                    'odds_id'      => $match->odds_id,
                    'match_id'     => $match->match_id,
                    'created_at' => date('Y-m-d H:i:s'),
                    'updated_at' => date('Y-m-d H:i:s'),
                ];
            }
            OrderJczqResult::insert($orderOdds);

            DB::commit();
            return $order;
        } catch (JingCaiException $e) {
            DB::rollBack();
            Log::error('jczq::order::create ValidateException: ' . $e);
            throw $e;
        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('jczq::order::create Exception: ' . $e);
            throw $e;
        }
    }

    private function createZuhe($betsInfo, $orderId, $optimizeZuhe = [])
    {
        if ($optimizeZuhe) {
            foreach ($optimizeZuhe as $item) {
                $orderZuhe                = new OrderZuhe();
                $orderZuhe->order_id      = $orderId;
                $orderZuhe->jczq_odds_ids = $item['ids'];
                $orderZuhe->info          = $item['info'];
                $orderZuhe->bets_num      = $item['bets_num'];
                $orderZuhe->repeat_num      = Arr::get($item, 'repeat_num', 1);
                $orderZuhe->save();
            }
            return;
        }

        foreach ($betsInfo as $item) {
            $orderZuhe                = new OrderZuhe();
            $orderZuhe->order_id      = $orderId;
            $orderZuhe->jczq_odds_ids = $item['ids'];
            $orderZuhe->info          = $item['info'];
            $orderZuhe->bets_num      = $item['bets_num'];
            $orderZuhe->repeat_num    = Arr::get($item, 'repeat_num', 1);
            $orderZuhe->save();
        }
    }

    /**
     * 跟单
     * @param $data
     * @param Customer $customer
     * @return Order
     * @throws \Throwable
     */
    public function copyOrder(Customer $customer, Order $od, $data)
    {
        $betsNum = Arr::get($data, 'bets_num');

        /** @var Lottery $lott */
        $lott = LotteryService::getLottery($customer->shop->id, $od->lottery_type_id);
        throw_if(!$lott || !$lott->isActive(), JingCaiException::create('该彩种暂不支持下单!'));

        $jingcaiService = LotteryService::getJingcaiService($lott->lotteryType->type);
        $odds         = $jingcaiService->refreshOdds($od->odds);
        $jczqOdds   = JczqOdds::whereIn('id', array_keys($odds))->get();
        $closeTimes = [];
        foreach ($jczqOdds as $match) {
            $realCloseTime   = strtotime($match->real_close_time) - $lott->earlySecond();
            $real_close_time = date('Y-m-d H:i:s', $realCloseTime);
            $closeTimes[]    = $real_close_time;
        }
        sort($closeTimes);
        $earlyTime = $closeTimes[0];
        $lateTime  = $closeTimes[count($closeTimes) - 1];
        $this->checkCloseTimeOver($earlyTime);
        DB::beginTransaction();
        try {
            $passModeKeys = $od->pass_mode;
            $computeInfo  = $jingcaiService->computePrizeInfo($odds, $betsNum, $passModeKeys);

            throw_if(!bc_gte($computeInfo['money'], $lott->min_money), JingCaiException::create('最低投注' . Helps::floatFormat($lott->min_money) . '元'));

//            $betsInfos = $this->generateBetsInfo($odds,$passModeKeys, $betsNum);

//            $piaos = $this->createPiaos($betsInfos);
            $piaos = $this->createPiaosV2($odds, $passModeKeys, $betsNum);
            $piaoZhang = array_sum(array_column($piaos, 'zhang'));

            $order                        = new Order();
            $order->type                  = OrderType::GENDAN;
            $order->pid                   = $od->id;
            $order->type_mode             = $od->type_mode;
            $order->customer_id           = $customer->id;
            $order->shop_id               = $customer->shop_id;
            $order->lottery_id            = $lott->id;
            $order->lottery_type_id       = $lott->lottery_type_id;
            $order->order_sn              = Order::makeOrderSn();
            $order->play_type             = $od->play_type;
            $order->odds_close_time       = $od->odds_close_time;
            $order->odds_early_close_time = $earlyTime;
            $order->odds_late_close_time  = $lateTime;
            $order->bets_num              = $betsNum;
            $order->piao_num              = $piaoZhang;
            $order->bets_expect_num       = $computeInfo['expect_bets'];
            $order->zhu_num               = $computeInfo['zhu_num'];
            $order->money                 = $computeInfo['money'];
            $order->prize_min             = $computeInfo['prize_min'];
            $order->prize_max             = $computeInfo['prize_max'];
            $order->pay_state             = PayState::UNPAID;
            $order->pass_mode             = $od->pass_mode;
            $order->odds                  = $odds;
            $order->created_date = date('Ymd');
            // 设置合作相关的数据
            $order->setCooperateInfo($lott);
            $order->save();

            // 创建组合数据
            $betsInfos = $this->getZuheListFromPiaos($piaos);
            $this->createZuhe($betsInfos, $order->id);

            $orderOddsData = [];
            $jczqOdds      = JczqOdds::whereIn('id', array_keys($odds))->get();
            foreach ($jczqOdds as $match) {

                $orderOddsData[] = [
                    'order_id'     => $order->id,
                    'jczq_odds_id' => $match->id,
                    'odds_id'      => $match->odds_id,
                    'match_id'     => $match->match_id,
                    'created_at' => date('Y-m-d H:i:s'),
                    'updated_at' => date('Y-m-d H:i:s'),
                ];
            }
            OrderJczqResult::insert($orderOddsData);
            DB::commit();
            return $order;
        } catch (JingCaiException $e) {
            DB::rollBack();
            Log::error('jczq::order::copy ValidateException: ' . $e);
            throw $e;
        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('jczq::order::copy Exception: ' . $e);
            throw $e;
        }
    }

    public function showOrder(Customer $customer, Order $order)
    {
        $order->sellings = [];

        // 截止后公开
        if ($order->type_mode == 1 && ($order->type == OrderType::GENDAN || $order->type == OrderType::FADAN || $order->type == OrderType::UNION)) {
            $isTypeModel1 = true;

            // 合买，是自己时，全部可见
            if ($order->type == OrderType::UNION) {
                if ($order->customer_id == $customer->id) {
                    $isTypeModel1 = false;
                }
            }

            // 跟单：如果是自己跟自己，全部可见
            if ($order->type == OrderType::GENDAN) {
                if ($order->customer_id == $customer->id && $order->p_order->customer_id == $customer->id) {
                    $isTypeModel1 = false;
                }
            }

            // 发单：如果是自己跟自己，全部可见
            if ($order->type == OrderType::FADAN) {
                if ($order->customer_id == $customer->id) {
                    $isTypeModel1 = false;
                }
            }
            $order->sellings = $this->getOrderOdds($order, $isTypeModel1);
        } else {
            // 其他公开方式
            if ($order->customerCanSeeSellings($customer)) {
                $order->sellings = $this->getOrderOdds($order);
            }
        }

        if (!$order->sellings) {
            $odds        = $order->odds;
            $jczqOddsIds = array_keys($odds);
            $jczqOdds = JczqOdds::whereIn('id', $jczqOddsIds)
                ->where('real_close_time', '>', date('Y-m-d H:i:s'))
                ->first();
            if (!$jczqOdds) {
                $order->sellings = $this->getOrderOdds($order);
            }
        }

        $order->chang_num = count($order->sellings);
        $names            = [];
        foreach ($order->pass_mode as $val) {
            $names[] = str_replace('.', '串', $val);
        }
        $order->pass_mode_names = $names;

        $order->play_name = $order->lottery->name;

        unset($order->lottery);

        return $order;
    }

    public function getOrderOdds(Order $order, $isTypeModel1 = false)
    {
        /** @var Lottery $lottery */
        $lottery = $order->lottery;
        $earlyTime = $lottery->earlySecond();

        $odds        = $order->odds;
        $jczqOddsIds = array_keys($odds);

        $jczqOdds = JczqOdds::leftJoin('zq_match', 'zq_match.match_id', 'jczq_odds.match_id')
            ->select([
            'jczq_odds.id',
            'jczq_odds.issue_num',
            'jczq_odds.play_num',
            'jczq_odds.jc_competition_name',
            'jczq_odds.jc_competition_name_full',
            'jczq_odds.jc_home_team_name',
            'jczq_odds.jc_home_team_name_full',
            'jczq_odds.jc_away_team_name',
            'jczq_odds.jc_away_team_name_full',
            'jczq_odds.real_close_time',
            'jczq_odds.is_reverse',
            'zq_match.start_time',
        ])
            ->whereIn('jczq_odds.id', $jczqOddsIds)
            ->orderBy('jczq_odds.real_close_time', 'asc')
            ->orderBy('jczq_odds.play_num', 'asc')
            ->get();

        $currentDate = date('Y-m-d H:i:s');
        $result = [];
        foreach ($jczqOdds as $item) {
            $jczqResult    = null;
            if (in_array($order->lottery_state, Order::kaiJiangHouStates())) {
                $jczqResult = JczqResult::where('jczq_odds_id', $item->id)->first();
            }
            $item->issue_num_week = JczqOdds::getIssueNumWeek($item->issue_num);
            $item->issue_num_day  = JczqOdds::getIssueNumDay($item->issue_num);
            $item->vs_b           = $item->jc_home_team_name;
            $item->vs_m           = 'vs';
            $item->vs_a           = $item->jc_away_team_name;
            $item->play_items     = $this->getOrderPlayItems($order, $item, $jczqResult);
            $item->half_time_score = '';
            $item->full_time_score = '';
            if ($jczqResult) {
                $item->half_time_score = $jczqResult->half_time_score;
                $item->full_time_score = $jczqResult->full_time_score;
            }
            $item->lottery_close_time = date('Y-m-d H:i:s', strtotime($item->real_close_time) - $earlyTime);

            $matchStartTime = $item->start_time;
            if (!$matchStartTime) {
                $matchStartTime = $item->lottery_close_time;
            }

            if ($isTypeModel1) {
                if ($matchStartTime > $currentDate) {
                    $result[] = new \stdClass();
                } else {
                    $result[] = $item;
                }
            } else {
                $result[] = $item;
            }
        }
        return $result;
    }

    private function getOrderPlayItems(Order $order, $jczqOddsItem, $jczqResult)
    {
        $odds          = $order->odds;
        $buyOddsItem   = Arr::get($odds, $jczqOddsItem->id);
        $playTypeNames = $this->playTypeNames();
        $result        = [];

        foreach ($playTypeNames as $playType => $name) {
            $buyPlayData = Arr::get($buyOddsItem, $playType);
            if (!$buyPlayData) {
                continue;
            }
            $resultPlayTypeItem = [];
            foreach ($buyPlayData as $resultField => $odds) {

                $wined = false;

                $buyField = str_replace('_odds', '_field', $playType);
                if ($jczqResult && $jczqResult->{$buyField} == $resultField) {
                    $wined = true;
                }

                $resultPlayTypeItem[] = [
                    'odds_value' => $odds,
                    'odds_name' => $resultField,
                    'name'  => sprintf('%s(%s)', $this->getResultFieldName($playType, $resultField), $odds),
                    'wined' => $wined
                ];
            }
            $winResult = '';
            $resultField = str_replace('_odds', '_name', $playType);
            if ($jczqResult && $jczqResult->{$resultField}) {
                $winResult = $jczqResult->{$resultField};
	    }
	    //dump($resultField,$playType,$playTypeNames,$jczqResult->toArray());

            $result[] = [
                'win_result' => $winResult,
                'play_type' => $playType,
                'play_name'  => $this->getPlayTypeName($playType),
                'play_items' => $resultPlayTypeItem,
            ];
	}
//	dd($result);
        return $result;
    }


    public function sellerShowOrder(Seller $seller, Order $order)
    {
        $order->sellings = [];
        if ($order->sellerCanSeeSellings($seller)) {
            $order->sellings = $this->getOrderOdds($order);
        }
        $order->chang_num = count($order->sellings);
        $names            = [];
        foreach ($order->pass_mode as $val) {
            $names[] = str_replace('.', '串', $val);
        }
        $order->pass_mode_names = $names;

        $order->play_name = $order->lottery->name;

        unset($order->lottery);

        return $order;
    }

    public function chaiPiao(Order $order)
    {
        $optimizeZuheList = $order->zuheToOptimizeZuheList();

        $piaos = $this->createPiaosV2($order->odds, $order->pass_mode, $order->bets_num, $optimizeZuheList);


        $piaos = $this->chaiPiaoGenV3($piaos);

        $jclqOdds = JczqOdds::whereIn('id', array_keys($order->odds))->pluck('rq_odds', 'id')->toArray();
        $handicapList = [];
        foreach ($jclqOdds as $id => $item) {
            if ($item) {
                $handicapList[$id] = $item['handicap'];
            }
        }
        foreach ($piaos as $ind => $piao) {
            $piaoOddsData = [];
            $allBetsResultUnique=[];
            foreach ($piao['bets'] as $piaoBet) {
                foreach ($piaoBet['info'] as $id => $idInfo) {
                    $piaoOddsData[$id][$idInfo['play']][$idInfo['result']] = $idInfo['odd'];
                }
                @$allBetsResultUnique[$piaoBet['unique']] += $piaoBet['bets_num'];
            }
            $maxZuheList = $this->maxPrizeZuheList($piaoOddsData, $piao['pass_mode'], $handicapList);

            $maxPrize = 0;
            foreach ($maxZuheList as $zuhe) {
                $repeatNum = $allBetsResultUnique[$zuhe['unique']];
                $maxPrize += $repeatNum * $this->getBetsInfoPrize($zuhe);
            }
            $piaos[$ind]['prize_max'] = $maxPrize;
        }
        $header = [
            [
                'prop' => 'index',
                'title' => '序号',
            ],
            [
                'prop' => 'type',
                'title' => '过关',
            ],
            [
                'prop' => 'play_name',
                'title' => $order->play_type_name,
            ],
            [
                'prop' => 'nums',
                'title' => '倍数/票数',
            ],
        ];
        $piaoList = [];

        foreach ($piaos as $k => $piao) {

            $buyOdds = [
            ];
            foreach ($piao['bets'] as $betInfo) {
                $piaoInfo = $betInfo['info'];

                foreach ($piaoInfo as $id => $info) {
                    $buyField = $this->getResultFieldName($info['play'], $info['result']);
                    if (!isset($buyOdds[$id])) {
                        $buyOdds[$id] = [$buyField];
                        continue;
                    }
                    if (!in_array($buyField,$buyOdds[$id])) {
                        $buyOdds[$id][] = $buyField;
                    }
                }
            }
            $jczqOdds = JczqOdds::whereIn('id',array_keys($buyOdds))
                ->orderBy('play_num', 'desc')
                ->get()
                ->keyBy('id');

            $plays = [];
            foreach ($buyOdds as $id => $fields) {
                /** @var JczqOdds $oddItem */
                $oddItem = Arr::get($jczqOdds, $id);
                $weekPlay = $oddItem->weekPlayFormat();
                $plays[] = $weekPlay . ' (' . implode(' ', $fields) .')';
            }
            if ($piao['zhang'] > 1) {
                $piaoMoney = $piao['zhu_money'] * 50;
                $beishu = 50;
            } else {
                $piaoMoney = $piao['zhu_money'] * $piao['bets_num'];
                $beishu = $piao['bets_num'];
            }
            $piaoList[] = [
                'header' => $header,
                'data' => [
                    'index' => $k +1 ,
                    'type' => $order->getPassModelNameByKeys($piao['pass_mode']),
                    'play_name' => $plays,
                    'nums' => sprintf('%d倍/%d张', $beishu, $piao['zhang'])
                ],
                'summary' => '',
                'zhang' => $piao['zhang'],
                'zhu_money' => $piao['zhu_money'],
                'piao_money' => $piaoMoney,
//                'prize_max' => Helps::floatFormat($piao['prize']/$piao['zhang']),
                'prize_max' => Helps::floatFormat($piao['prize_max']),
            ];
        }
        return $piaoList;
    }
}