<?php


namespace services;
require_once('mt/HashRate.php');
require_once('mt/Parameter.php');
require_once('mt/HashRateTask.php');
require_once('mt/Rank.php');
require_once('mt/RankSeason.php');
require_once('models/Bag.php');
require_once('models/CrystalRecord.php');
require_once('models/Staking.php');
require_once('models/HashRateTask.php');
require_once('models/HashRateBattleData.php');

use models\Bag;
use models\CrystalRecord;
use models\HashRateBattleData;
use models\Staking;
use models\HashRateTask;
use mt\AchievementsPower;
use mt\HashRate;
use mt\Parameter;
use mt\Rank;
use mt\RankSeason;

class HashRateService extends BaseService
{
    const FINISHED_STATE = 1;
    const NOT_FINISHED_STATE = 0;

    private $hisBattleData = array();
    private $hashRateData = array();
    private $mobaBattleData = array();
    private $pvpBattleData = array();

    public function init()
    {

        $this->hisBattleData = HashRateBattleData::getMyBattleData();
        $this->hashRateData = getXVal($this->hisBattleData, 'data', array());
//        $currentPeriod= \mt\AchievementsCycle::getCurrentPeriod();
//        if (myself()->_getDaySeconds(getXVal($this->hashRateData, 'modifytime', 0)) <
//            myself()->_getDaySeconds($currentPeriod['obtain_end_time'])) {
//            $this->hashRateData = array(
//                'pvpData' => array(),
//                'mobaData' => array(),
//                'createtime' => myself()->_getNowTime(),
//                'modifytime' => myself()->_getNowTime(),
//            );
//        }
        if (!$this->hashRateData){
            $this->hashRateData = array(
                'pvpData' => array(),
                'mobaData' => array(),
                'createtime' => myself()->_getNowTime(),
                'modifytime' => myself()->_getNowTime(),
            );
        }
        $this->pvpBattleData = $this->hashRateData['pvpData'];
        $this->mobaBattleData = $this->hashRateData['mobaData'];
    }

    public function hashRateTaskDto($taskMate){
        $taskDto = array(
            'task_id' => $taskMate['id'],
            'current' => 0,
            'target' => getXVal($taskMate, 'Completed_quantity', 1),
            'state' => self::NOT_FINISHED_STATE,
        );

        switch ($taskMate['Completion_type']){
            //吃鸡或4v4获得胜利
            case AchievementsPower::TOTAL_WINS_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_win_times');
            }
            break;
            //击杀人数
            case AchievementsPower::TOTAL_KILL_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_kills_times');
            }
            break;
            //使用X道具
            case AchievementsPower::USE_ITEM_TIMES : {
                $taskDto['current'] = $this->getWeaponsSlotData($taskMate);
            }
            break;
            //X分钟内结束比赛
            case AchievementsPower::NOMINAL_TIME_BATTLE_END : {
                //....
            }
            break;
            //在局内升级最快次数
            case AchievementsPower::IN_BATTLE_UP_LV : {
                //.....
            }
            break;
            //游戏场次
            case AchievementsPower::TOTAL_BATTLE_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_battle_times');
            }
            break;
            //最后一名次数
            case AchievementsPower::TOTAL_LAST_RUNNER : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_last_runner_times');
            }
            break;
            //救援队友数
            case AchievementsPower::RESCUE_TEAMMATE_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_rescue_times');
            }
            break;
            //累计行走距离(米)
            case AchievementsPower::WALKING_DISTANCE : {
                //.../
            }
            break;
            //指定英雄升阶数
            case AchievementsPower::HERO_UP_QUALITY : {
                //..../
            }
            break;
            //拥有英雄nft数
            case AchievementsPower::OWN_HERO_NFT_NUM : {
                //...../
            }
            break;
            //拥有芯片nft数
            case AchievementsPower::OWN_CHIP_NFT_NUM : {
                //....../
            }
            break;
            //拥有金币数
            case AchievementsPower::OWN_GOLD_NUM : {
                //......./
            }
            break;
        }
        if ($taskDto['current'] >= $taskDto['target']) {
            $taskDto['current'] = $taskDto['target'];
        }
        return $taskDto;
    }

    private function getBattleData($taskMate, $key)
    {
        $val = 0;
        $battleData = $this->internalGetBattleData($taskMate);
        $val = getXVal($battleData, $key, 0);
        return $val;
    }

    private function internalGetBattleData($taskMate)
    {
        $battleData = null;
        if ($taskMate['scene'] == AchievementsPower::PVP_SCENE) {
            $battleData = $this->pvpBattleData;
        } else if ($taskMate['scene'] == AchievementsPower::MOBA_SCENE){
            $battleData = $this->mobaBattleData;
        }
        return $battleData ? $battleData : array();
    }

    private function getWeaponsSlotData($taskMate){
        $val = 0;
        $battleData = $this->internalGetBattleData($taskMate);
        $slotData = $battleData['weapons_slot_data'] ? $battleData['weapons_slot_data'] : array();
        if (array_key_exists($taskMate['condition'],$slotData)){
            $val = $slotData[$taskMate['condition']];
        }
        return $val;
    }

//-----------------------以下弃用---------------------------
    const NONE_STATE = 0;
    const RECEIVED_STATE = 1;
    const EXCHANGE_RATE  = 10;
    //弃用
    public function getCrystalDto($crystalMeta,&$crystalDto){
        $crystalDto = array(
            'item_id' => $crystalMeta['id'],
            'pending' => 0,
            'total' => array(),
            'claimed' => 0,
            'state' => self::NONE_STATE,
        );
        $hashRateMeta = HashRate::findHash($crystalMeta['id']);
        $ownedNum = CrystalRecord::getCrystalNum($crystalMeta['id']);
        $crystalDto['claimed'] = intval($ownedNum);
        switch ($crystalMeta['sub_type']){
            case 1 : {
                $param = explode('|',$hashRateMeta['parameter']);
                $killsNum = myself()->_getV(TN_TOTAL_KILLS_NUM,0);
                $killsNumEd = myself()->_getV(TN_TOTAL_KILLS_NUM,-1);
                $starNum = myself()->_getV(TN_TOTAL_STAR_NUM,0);
                $starNumEd = myself()->_getV(TN_TOTAL_STAR_NUM,-1);
                $killsNumEx = $killsNum - $killsNumEd;
                $starNumEx = $starNum - $starNumEd ;
                $crystalDto['total'] = array(
                    'param1' => floatval($killsNumEx),
                    'param2' => floatval($starNumEx),
                );
                $paramKill = explode(':',$param[0]);
                $paramStar = explode(':',$param[1]);
                $totalNum = max(0,floor($killsNumEx / $paramKill[0]) * $paramKill[1] +
                floor($starNumEx / $paramStar[0]) * $paramStar[1] );
                $crystalDto['pending'] = intval($totalNum);
                $crystalDto['state'] = $crystalDto['pending'] > 0 ? self::RECEIVED_STATE : self::NONE_STATE;
            }
                break;
            case 2 : {
                //  游戏内消费总价值
                $param = explode(':',$hashRateMeta['parameter']);
                $consumeCost = myself()->_getV(TN_TOTAL_DIAMOND_CONSUME,0);
                $consumeCostEd = myself()->_getV(TN_TOTAL_DIAMOND_CONSUME,-1);
                $consumeCostEx = $consumeCost - $consumeCostEd ;
                $crystalDto['total'] = array(
                    'param1' => floatval($consumeCostEx / self::EXCHANGE_RATE),
                );
                $totalNum = max(0,floor($consumeCostEx / self::EXCHANGE_RATE / $param[0]) * $param[1]);
                $crystalDto['pending'] = intval($totalNum);
                $crystalDto['state'] = $crystalDto['pending'] > 0 ? self::RECEIVED_STATE : self::NONE_STATE;
            }
                break;
            case 3 : {
                //  Market交易总价值
                $param = explode(':',$hashRateMeta['parameter']);
                $consumeCost = myself()->_getV(TN_TOTAL_CEG_CONSUME,0);
                $consumeCostEd = myself()->_getV(TN_TOTAL_CEG_CONSUME,-1);
                $consumeCostEx = $consumeCost - $consumeCostEd ;
                $crystalDto['total'] = array(
                    'param1' => floatval($consumeCostEx / self::EXCHANGE_RATE),
                );
                $totalNum = max(0,floor($consumeCostEx / self::EXCHANGE_RATE / $param[0]) * $param[1]);
                $crystalDto['pending'] = intval($totalNum);
                $crystalDto['state'] = $crystalDto['pending'] > 0 ? self::RECEIVED_STATE : self::NONE_STATE;
            }
                break;
            case 4 : {
                //  质压总价值
                $param = explode(':',$hashRateMeta['parameter']);
//                $rate = Parameter::getVal('cec_exchange_rate',10);
                $cecVal = Staking::getStakingTotalValue();
                $crystalDto['total'] = array(
                    'param1' => floatval($cecVal ),
                );
                $recordDb = CrystalRecord::getNewestRecordOne($crystalMeta['id']);
                if ($recordDb && myself()->_getNowDaySeconds() == myself()->_getDaySeconds($recordDb['createtime'])){
                    $crystalDto['pending'] = 0;
                }else{
                    $totalNum = max(0,floor($cecVal  / $param[0]) * $param[1]);
                    $crystalDto['pending'] = intval($totalNum);
                }
                $crystalDto['state'] = $crystalDto['pending'] > 0 ? self::RECEIVED_STATE : self::NONE_STATE;
            }
                break;
            }
    }

    //弃用
    public function getCrystalValue(){
        $chaimNum = 0;
        $playing = array();
        $staking = array();
        $trading = array();
        $consuming = array();
        $nft = array();
//        $hashRateMt = \mt\HashRateTask::getListByType(\mt\HashRateTask::PLAYING);
//        foreach ($hashRateMt as $meta){
//            $finalVal = 0;
//            $uplimit = $meta['upperlimit'] ;
//            if ($meta['id'] == HashRateTask::RANK_TYPE){
//                $seasonMeta = RankSeason::getCurrentSeason();
//                if (!$seasonMeta){
//                    $seasonMeta = RankSeason::getLastSeason();
//                }
//                $hashRateDb = HashRateTask::findByTaskIdOrSeason($meta['id'],$seasonMeta['id']);
//                $userDb = myself()->_safeGetOrmUserInfo();
//                $rankMeta = Rank::getRankById($userDb['rank']);
//                if ($rankMeta['rank_order2'] > $hashRateDb['record_total']){
//                    $finalVal =  ($rankMeta['rank_order2'] - $hashRateDb['claim_total']) * $meta['reward'];
//                }
//            } else {
//                $hashRateDb = HashRateTask::findByTaskId($meta['id']);
//                $targetVal = 0;
//                if ($hashRateDb){
//                    $total = $hashRateDb['record_total'] - $hashRateDb['claim_total'];
//                    if ($hashRateDb['task_id'] == HashRateTask::BATTLE_TIME_TYPE){
//                        $targetVal = max(0,floor($total / 1000 / $meta['target'])) * $meta['reward'];
//                    }else{
//                        $targetVal = max(0,floor($total / $meta['target'])) * $meta['reward'];
//                    }
//                }
//
//
//                $claim_day = HashRateTask::getDailyReward($meta['id']);
//                $uplimit = $meta['upperlimit'] - $claim_day;
//                $finalVal = min($targetVal , $uplimit);
//            }
//            $chaimNum += $finalVal;
//            array_push($detail,array(
//                'task_id' => $meta['id'],
//                'uplimit' => $uplimit,
//                'chaim_num' => $finalVal
//            ));
//        }
        $hashRateTask = \mt\HashRateTask::getMetaList();
        foreach ($hashRateTask as $metaTask){
            $finalVal = 0;
            $uplimit = $metaTask['upperlimit'] ;
            switch ($metaTask['type']){
                case \mt\HashRateTask::PLAYING :{
                    if ($metaTask['id'] == HashRateTask::RANK_TYPE){
                        $seasonMeta = RankSeason::getCurrentSeason();
                        if (!$seasonMeta){
                            $seasonMeta = RankSeason::getLastSeason();
                        }
                        $hashRateDb = HashRateTask::findByTaskIdOrSeason($metaTask['id'],$seasonMeta['id']);
                        $userDb = myself()->_safeGetOrmUserInfo();
                        $rankMeta = Rank::getRankById($userDb['rank']);
//
                        if ($hashRateDb && $rankMeta['rank_order2'] > $hashRateDb['record_total']){
                            $finalVal =  ($rankMeta['rank_order2'] - $hashRateDb['claim_total']) * $metaTask['reward'];

                        }
                    } else {
                        $hashRateDb = HashRateTask::findByTaskId($metaTask['id']);
                        $targetVal = 0;
                        if ($hashRateDb){
                            $total = $hashRateDb['record_total'] - $hashRateDb['claim_total'];
                            if ($hashRateDb['task_id'] == HashRateTask::BATTLE_TIME_TYPE){
                                $targetVal = max(0,floor($total / 1000 / $metaTask['target'])) * $metaTask['reward'];
                            }else{
                                $targetVal = max(0,floor($total / $metaTask['target'])) * $metaTask['reward'];
                            }
                        }


                        $claim_day = HashRateTask::getDailyReward($metaTask['id']);
                        $uplimit = $metaTask['upperlimit'] - $claim_day;
                        $finalVal = min($targetVal , $uplimit);
                    }
                    $chaimNum += $finalVal;
                    array_push($playing,array(
                        'task_id' => $metaTask['id'],
                        'uplimit' => $uplimit,
                        'chaim_num' => $finalVal
                    ));
                }
                break;
                case \mt\HashRateTask::STAKING :{
                    //质押价值
                    $stakingVal = Staking::getStakingTotalValue();
                    $targetVal = max(0,floor($stakingVal  / $metaTask['target']) * $metaTask['reward']);
                    $claim_day = HashRateTask::getDailyReward($metaTask['id']);
                    if ($claim_day){
                        $finalVal = 0;
                    }else{
                        $finalVal = $targetVal;
                    }
                    $chaimNum += $finalVal;
                    array_push($staking,array(
                        'task_id' => $metaTask['id'],
                        'uplimit' => $uplimit,
                        'chaim_num' => $finalVal
                    ));
                }
                break;
//                case \mt\HashRateTask::TRADING : {
//                    $consumeCost = myself()->_getV(TN_TOTAL_CEG_CONSUME,0);
//                    $consumeCostEd = myself()->_getV(TN_TOTAL_CEG_CONSUME,-1);
//                    $total = $consumeCost - $consumeCostEd ;
//                    $finalVal = max(0,floor($total / self::EXCHANGE_RATE / $metaTask['target']) * $metaTask['reward']);
//                    $chaimNum += $finalVal;
//                    array_push($trading,array(
//                        'task_id' => $metaTask['id'],
//                        'uplimit' => $uplimit,
//                        'chaim_num' => $finalVal
//                    ));
//                }
//                break;
                case  \mt\HashRateTask::CONSUMING : {
                    $consumeCost = myself()->_getV(TN_TOTAL_DIAMOND_CONSUME,0);
                    $consumeCostEd = myself()->_getV(TN_TOTAL_DIAMOND_CONSUME,-1);
                    $total = $consumeCost - $consumeCostEd;
                    $finalVal = max(0,floor($total / self::EXCHANGE_RATE / $metaTask['target']) * $metaTask['reward']);
                    $chaimNum += $finalVal;
                    array_push($consuming,array(
                        'task_id' => $metaTask['id'],
                        'uplimit' => $uplimit,
                        'chaim_num' => $finalVal
                    ));
                }
            }
        }
        return array(
            'totalNum' => $chaimNum,
            'playing'=>$playing,
            'staking'=>$staking,
            'consuming'=>$consuming,
            'nft'=>$nft,
        );
    }


}