<?php


namespace services;
require_once('mt/AchievementsCycle.php');
require_once('mt/AchievementsPower.php');
require_once('mt/ServerTask.php');
require_once('mt/ServerTaskTime.php');

require_once('models/BigData.php');
require_once('models/Hero.php');
require_once('models/HashRate.php');
require_once('models/HashRateBattleData.php');
require_once('models/GlobalData.php');

use models\GlobalData;
use models\HashRateBattleData;
use models\HashRate;
use models\Hero;
use models\BigData;
use mt\AchievementsPower;

class HashRateService extends BaseService
{
    const FINISHED_STATE = 1;
    const NOT_FINISHED_STATE = 0;
    const RECEIVED_STATE = 2;

    private $hisBattleData = array();
    private $hashRateData = array();
    private $mobaBattleData = array();
    private $pvpBattleData = array();
    private $serverTaskData = array();
    private $battleDataServerTask = array();
    private $pvpBattleDataServerTask = array();
    private $hashRateTask = array();

    public function init()
    {
        //------------------------算力系统------------------------
        $this->hisBattleData = HashRateBattleData::getMyBattleData();
        $this->hashRateData = getXVal($this->hisBattleData, 'hash_rate_data', array());
        if (!$this->hashRateData){
            $this->hashRateData = array(
                'pvpData' => array(),
                'mobaData' => array(),
                'createtime' => myself()->_getNowTime(),
                'modifytime' => myself()->_getNowTime(),
            );
        }
        $currentPeriod= \mt\AchievementsCycle::getCurrentPeriod();
        if ($currentPeriod && myself()->_getDaySeconds(getXVal($this->hashRateData, 'modifytime', 0)) <
            myself()->_getDaySeconds(strtotime($currentPeriod['obtain_start_time']))) {
            $this->hashRateData = array(
                'pvpData' => array(),
                'mobaData' => array(),
                'modifytime' => myself()->_getNowTime(),
            );
        }
        $this->pvpBattleData = $this->hashRateData['pvpData'];
        $this->mobaBattleData = $this->hashRateData['mobaData'];
        $this->hashRateTask = BigData::getData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE);
        if (!$this->hashRateTask) {
            $this->hashRateTask = array(
                'task'.AchievementsPower::TYPE1 => array(),
                'task'.AchievementsPower::TYPE2 => array(),
                'task'.AchievementsPower::TYPE3 => array(),
                'task'.AchievementsPower::TYPE4 => array(),
                'currentPeriod' => 0,
                'initTime' => 0
            );
        }
        if ($currentPeriod && $currentPeriod['id'] != $this->hashRateTask['currentPeriod']){
            $this->initHashRateTask($currentPeriod['id']);
        }

        //------------------------服务器大事件------------------------
       $serverDataDb = GlobalData::getServerTaskData();
        $this->serverTaskData = getXVal($serverDataDb, 'data', array());
        if (!$this->serverTaskData){
            $this->serverTaskData = array(
                'createtime' => myself()->_getNowTime(),
                'modifytime' => myself()->_getNowTime(),
            );
        }
        $currentServerTask = \mt\ServerTaskTime::getCurrentTime();
        if ($currentServerTask && myself()->_getDaySeconds(getXVal($this->serverTaskData, 'modifytime', 0)) <
            myself()->_getDaySeconds(strtotime($currentServerTask['obtain_start_time']))) {
            $this->serverTaskData = array(
                'modifytime' => myself()->_getNowTime(),
            );
            GlobalData::addServerTaskStatus(\mt\ServerTask::NOT_ACCOMPLISH_STATE);
        }
        $this->battleDataServerTask = $this->serverTaskData;
    }



    public function hashRateTaskDto($taskMate, $taskDb){
        $taskDto = array(
            'task_id' => $taskMate['id'],
            'current' => 0,
            'target' => getXVal($taskMate, 'Completed_quantity', 1),
            'state' => self::NOT_FINISHED_STATE,
        );

        if ($taskDb){
            if ($taskMate['scene'] > 0){
                if (myself()->_getDaySeconds($taskDb['modifytime']) == myself()->_getNowDaySeconds()) {
                    $taskDto['current'] = $taskDto['target'];
                    $taskDto['state'] = self::RECEIVED_STATE;
                    return $taskDto;
                }
            }else{
                $taskDto['current'] = $taskDto['target'];
                $taskDto['state'] = self::RECEIVED_STATE;
                return $taskDto;
            }
        }

        switch ($taskMate['Completion_type']){
            //吃鸡或4v4获得胜利
            case \mt\AchievementsPower::TOTAL_WINS_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_win_times');
            }
            break;
            //击杀人数
            case \mt\AchievementsPower::TOTAL_KILL_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_kills_times');
            }
            break;
            //使用X道具
            case \mt\AchievementsPower::USE_ITEM_TIMES : {
                $taskDto['current'] = $this->getWeaponsSlotData($taskMate);
            }
            break;
            //X分钟内结束比赛
            case \mt\AchievementsPower::NOMINAL_TIME_BATTLE_END : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_fiveMin_times');
            }
            break;
            //在局内升级最快次数
            case \mt\AchievementsPower::IN_BATTLE_UP_LV : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_first_Lv_up');
            }
            break;
            //游戏场次
            case \mt\AchievementsPower::TOTAL_BATTLE_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_battle_times');
            }
            break;
            //最后一名次数
            case \mt\AchievementsPower::TOTAL_LAST_RUNNER : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_last_runner_times');
            }
            break;
            //救援队友数
            case \mt\AchievementsPower::RESCUE_TEAMMATE_TIMES : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_rescue_times');
            }
            break;
            //累计行走距离(米)
            case \mt\AchievementsPower::WALKING_DISTANCE : {
                $taskDto['current'] = $this->getBattleData($taskMate,
                    'total_walking_distance');
            }
            break;
            //指定英雄升阶数
            case \mt\AchievementsPower::HERO_UP_QUALITY : {
                $state = false;
                Hero::getHeroList(function ($row) use ($taskMate,&$state) {
                    if ($row['hero_id'] == $taskMate['condition'] && $row['quality'] >= $taskMate['Completed_quantity']){
                        $state = true;
                    }
                });
                if ($state){
                    $taskDto['current'] = $taskMate['Completed_quantity'];
                }
            }
            break;
            //拥有英雄nft数
            case \mt\AchievementsPower::OWN_HERO_NFT_NUM : {
                $heroNftCount = 0;
                Hero::getHeroList(function ($row) use (&$heroNftCount){
                    if ($row['token_id']){
                        $heroNftCount += 1;
                    }
                });
                $taskDto['current'] = $heroNftCount;
            }
            break;
            //拥有芯片nft数
            case \mt\AchievementsPower::OWN_CHIP_NFT_NUM : {
                //....../
            }
            break;
            //拥有金币数
            case \mt\AchievementsPower::OWN_GOLD_NUM : {
                $user = myself()->_getOrmUserInfo();
                $taskDto['current'] = $user['gold'];
            }
            break;
            //充值钻石数
            case \mt\AchievementsPower::TOP_UP_DIAMOND : {
                //.../
            }
            break;
            //花费钻石数
            case \mt\AchievementsPower::SPEND_DIAMOND : {
                //..
            }
            break;
            //消耗金币
            case \mt\AchievementsPower::SPEND_GOLD : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_GOLD_CONSUME, 0);
            }
            break;
            //合成英雄
            case \mt\AchievementsPower::SYN_HERO : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_SYN_HERO_TIMES, 0);
            }
            break;
            //合成芯片
            case \mt\AchievementsPower::SYN_CHIP : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_SYN_CHIP_TIMES, 0);
            }
            break;
            //合成皮肤
            case \mt\AchievementsPower::SYN_SKIN : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_SYN_SKIN_TIMES, 0);
            }
            break;
            //升阶英雄
            case \mt\AchievementsPower::UP_HERO : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_UP_HERO_TIMES, 0);
            }
            break;
            //升阶芯片
            case \mt\AchievementsPower::UP_CHIP : {
                $taskDto['current'] = myself()->_getPeriodV(TN_HASH_RATE_UP_CHIP_TIMES, 0);
            }
            break;
            //合成金币卡
            case \mt\AchievementsPower::SYN_GOLD_CARD : {
                //.........
            }
            break;
            //累计完成任务数
            case \mt\AchievementsPower::TOTAL_COMPLETE_NUM : {
                //..........
            }
            break;
        }
        if ($taskDto['current'] >= $taskDto['target']) {
            $taskDto['current'] = $taskDto['target'];
            $taskDto['state'] = self::FINISHED_STATE;
//            if ($currentPeriod){
//                $hashRateDb = HashRate::find($taskMate['id'],$currentPeriod['id']);
//                if (!$hashRateDb){
//                    $fieldKv = array(
//                        'account_id' => myself()->_getAccountId(),
//                        'task_id' => $taskMate['id'],
//                        'period' => $currentPeriod['id'],
//                        'reward' => $taskMate['Reward_quantity'],
//                        'createtime' => myself()->_getNowTime(),
//                        'modifytime' => myself()->_getNowTime()
//                    );
//                    HashRate::add($fieldKv);
//                }
//            }
        }
        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'] == \mt\AchievementsPower::PVP_SCENE) {
            $battleData = $this->pvpBattleData;
        } else if ($taskMate['scene'] == \mt\AchievementsPower::MOBA_SCENE){
            $battleData = $this->mobaBattleData;
        }
        return $battleData ? $battleData : array();
    }

    private function getWeaponsSlotData($taskMate){
        $val = 0;
        $battleData = $this->internalGetBattleData($taskMate);
        $slotData = isset($battleData['weapons_slot_data']) ? $battleData['weapons_slot_data'] : array();
        if (array_key_exists($taskMate['condition'],$slotData)){
            $val = $slotData[$taskMate['condition']];
        }
        return $val;
    }

    public function getHashRateTasks($type){
        return $this->hashRateTask['task'.$type];
    }

    public function initHashRateTask($currentId){
        $this->randHashRateTaskList(AchievementsPower::TYPE1);
        $this->randHashRateTaskList(AchievementsPower::TYPE2);
        $this->randHashRateTaskList(AchievementsPower::TYPE3);
        $this->randHashRateTaskList(AchievementsPower::TYPE4);
        $this->hashRateTask['initTime'] = myself()->_getNowDaySeconds();
        $this->hashRateTask['currentPeriod'] = $currentId;
        $this->saveHashRateTask();
    }

    private function randHashRateTaskList($type){
        $metas = AchievementsPower::getListByType($type);
        $this->hashRateTask['task'.$type] = array();
        foreach (array_rand($metas, 4) as $key) {
            $meta = $metas[$key];
            if (count($this->hashRateTask['task'.$type]) >=
                4) {
                break;
            }
            array_push($this->hashRateTask['task'.$type],
                array(
                    'task_id' => $meta['id'],
                    'createtime' => myself()->_getNowTime(),
                    'modifytime' => myself()->_getNowTime(),
                ));
        }
    }

    private function saveHashRateTask()
    {
        BigData::setData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE,
            json_encode($this->hashRateTask));
    }

    public function refreshHashRateTask($taskMate,$period){
        $taskList = $this->getHashRateTasks($taskMate['task_type']);
        $metas = AchievementsPower::getAvailableTasks($taskMate['task_type'],$taskList);
        if (count($metas)<1) {
            return;
        }
       $randMetas = array();
        foreach ($metas as $meta){
            $taskDb = HashRate::find($meta['id'],$period);
            if (!$taskDb || myself()->_getDaySeconds($taskDb['modifytime']) < myself()->_getNowDaySeconds()){
                array_push($randMetas,$meta);
            }
        }
        if (count($randMetas)<1) {
            return;
        }
        $key = array_rand($randMetas,1);
        foreach ($taskList as $k=>$task){
            if ($task['task_id'] == $taskMate['id']){
                $taskList[$k] = array(
                    'task_id' => $metas[$key]['id'],
                    'createtime' => myself()->_getNowTime(),
                    'modifytime' => myself()->_getNowTime(),
                );
            }
        }
        $this->hashRateTask['task'.$taskMate['task_type']] = $taskList;
        $this->saveHashRateTask();
        myself()->_incDailyV(TN_HASH_DAILY_REFRESH_TIMES,0,1);
    }

    public function _isHaveRedTag($period){
        foreach ($this->hashRateTask as $item){
            if (is_array($item)){
                foreach ($item as $task){
                    $taskMeta = AchievementsPower::find($task['task_id']);
                    $taskDb = HashRate::find($task['task_id'],$period);
                    $taskDto = $this->hashRateTaskDto($taskMeta,$taskDb);
                    if ($taskDto['state'] == self::FINISHED_STATE){
                        return true;
                    }
                }
            }
        }
        return false;
    }



    public function serverTaskDto($taskMate){
        $taskDto = array(
            'task_id' => $taskMate['id'],
            'current' => 0,
            'target' => getXVal($taskMate, 'target', 1),
            'state' => self::NOT_FINISHED_STATE,
        );
        switch ($taskMate['condition']){
            case \mt\ServerTask::TOTAL_BATTLE_TIMES_COND : {
                $taskDto['current'] = $this->getServerTaskBattleData($taskMate,"total_battle_times");
            }
            break;
            case \mt\ServerTask::TOTAL_KILL_NUM_COND :{
                $taskDto['current'] = $this->getServerTaskBattleData($taskMate,"total_kills_times");
            }
            break;
            case \mt\ServerTask::TOTAL_DAMGE_OUT_COND :{
                $taskDto['current'] = $this->getServerTaskBattleData($taskMate,"total_damage_out");
            }
            break;
            case \mt\ServerTask::TOTAL_USE_SKILL_TIMES_COND :{
                $taskDto['current'] = $this->getServerTaskBattleData($taskMate,"use_skill_times");
            }
        }
        if ($taskDto['current'] >= $taskDto['target']) {
            $taskDto['current'] = $taskDto['target'];
            $taskDto['state'] = self::FINISHED_STATE;
        }
        return $taskDto;
    }

    private function getServerTaskBattleData($taskMate, $key)
    {
        $val = 0;
        $battleData = $this->internalGetServerTaskBattleData($taskMate);
        $val = getXVal($battleData, $key, 0);
        return $val;
    }

    private function internalGetServerTaskBattleData($taskMate)
    {
        $battleData = $this->battleDataServerTask;
        return $battleData ? $battleData : array();
    }

    public function getServerASKBoxMode(){
        $currentServerTask = \mt\ServerTaskTime::getCurrentTime();
        if (myself()->_getNowTime() < strtotime($currentServerTask['income_start_time'])){
            return  \mt\ServerTask::NOT_DROP_STATE;
        }
        $taskList1 = array();
        $taskList2 = array();
        $taskListMeta = \mt\ServerTask::getMetaList();
        foreach ($taskListMeta as $taskMeta){
            if ($taskMeta['type'] == \mt\ServerTask::MOBA_TYPE){
                $taskDto = $this->serverTaskDto($taskMeta);
                array_push($taskList1,$taskDto);
            }
            if ($taskMeta['type'] == \mt\ServerTask::PVP_TYPE){
                $taskDto = $this->serverTaskDto($taskMeta);
                array_push($taskList2,$taskDto);
            }
        }
        $mobaCount = 0;
        $pvpCount = 0;
        foreach ($taskList1 as $taskDto){
            if ($taskDto['state'] == self::FINISHED_STATE){
                $mobaCount += 1;
            }
        }
        foreach ($taskList2 as $taskDto){
            if ($taskDto['state'] == self::FINISHED_STATE){
                $pvpCount += 1;
            }
        }
        if ($mobaCount == count($taskList1)){
            return \mt\ServerTask::MOBA_DROP_STATE;
        }elseif ($pvpCount == count($taskList2)){
            return \mt\ServerTask::PVP_DROP_STATE;
        }else{
            if ($mobaCount > $pvpCount){
                return \mt\ServerTask::MOBA_DROP_STATE;
            }elseif ($mobaCount < $pvpCount){
                return \mt\ServerTask::PVP_DROP_STATE;
            }else{
                if (getXVal($this->mobaBattleDataServerTask,"modifytime", 0) < getXVal($this->pvpBattleDataServerTask,"modifytime", 0)){
                    return \mt\ServerTask::MOBA_DROP_STATE;
                }else{
                    return \mt\ServerTask::PVP_DROP_STATE;
                }
            }
        }

    }

}