<?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('mt/Equip.php');

require_once('models/BigData.php');
require_once('models/Hero.php');
require_once('models/Chip.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\Chip;
use models\BigData;
use mt\AchievementsCycle;
use mt\AchievementsPower;
use mt\Equip;

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,
                'modifytime' => 0
            );
        }
        $currentPeriod= \mt\AchievementsCycle::getCurrentPeriod();
//        if ($currentPeriod &&  myself()->_getDaySeconds($this->hashRateTask['modifytime']) < myself()->_getNowDaySeconds()){
        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($task, $taskDb,$period){
        $taskMate = AchievementsPower::find($task['task_id']);
        if (!$taskMate){
            return ;
        }
        $taskDto = array(
            'task_id' => $taskMate['id'],
            'current' => $task['current'],
            'target' => getXVal($taskMate, 'Completed_quantity', 1),
            'state' => self::NOT_FINISHED_STATE,
        );

        if ($taskDb){
            if ($taskMate['scene'] > 0){
//                if (myself()->_getDaySeconds($taskDb['modifytime']) == myself()->_getNowDaySeconds()) {
                if($task['createtime'] < $taskDb['createtime']){
                    $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 : {
                $chipNftCount = 0;
                Chip::getChipList(function ($row) use (&$chipNftCount){
                    if ($row['token_id']){
                        $chipNftCount += 1;
                    }
                });
                $taskDto['current'] = $chipNftCount;
            }
            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 : {
                $row = myself()->_getSelfMysql()->execQueryOne(
                    'SELECT SUM(amount) FROM t_diamond_consume_product WHERE (account_id=:account OR passport_address=:address)  AND type=:type AND createtime > :star_time',
                    array(
                        ':account' => myself()->_getAccountId(),
                        ':address' => myself()->_getAddress(),
                        ':type' => 0,
                        ':star_time' => $task['createtime'],
                    )
                );
                $taskDto['current'] = $row[0];
            }
//            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 : {
                $row = myself()->_getSelfMysql()->execQueryOne(
                    'SELECT COUNT(*) FROM t_gold_bullion WHERE src_account_id=:account AND activated=:activated AND activate_time > :star_time ',
                    array(
                        ':account' => myself()->_getAccountId(),
                        ':activated' => 1,
                        ':star_time' =>  $task['createtime'],
                    )
                );
                $taskDto['current'] = $row[0];
            }
            break;
            //累计完成任务数
            case \mt\AchievementsPower::TOTAL_COMPLETE_NUM : {
                $taskDto['current'] = HashRate::getCount($period);
            }
            break;
        }
        if ($taskDto['current'] >= $taskDto['target']) {
            $taskDto['current'] = $taskDto['target'];
            $taskDto['state'] = self::FINISHED_STATE;
        }
        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['modifytime'] = myself()->_getNowTime();
        $this->hashRateTask['currentPeriod'] = $currentId;
        $this->saveHashRateTask();
    }

    private function randHashRateTaskList($type){
        $metas = AchievementsPower::getListByType($type);
        $this->hashRateTask['task'.$type] = array();
        $count = count($metas) >= 4 ? 4 : count($metas) ;
        foreach (array_rand($metas, $count) as $key) {
            $meta = $metas[$key];
            if (count($this->hashRateTask['task'.$type]) >=
                4) {
                break;
            }
            array_push($this->hashRateTask['task'.$type],
                array(
                    'task_id' => $meta['id'],
                    'current' => 0,
                    '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' => $randMetas[$key]['id'],
                    'current' => 0,
                    '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 resetCurrentGoal($taskMate){
        if ($taskMate['task_type'] == AchievementsPower::TYPE5){
            return;
        }
        $taskList = $this->getHashRateTasks($taskMate['task_type']);
        foreach ($taskList as &$task){
            if ($task['task_id'] == $taskMate['id']){
                $task['current'] = 0;
                $task['modifytime'] = myself()->_getNowTime();
            }
        }
        $this->hashRateTask['task'.$taskMate['task_type']] = $taskList;
        $this->saveHashRateTask();
    }

    public function _isHaveRedTag($period){
        foreach ($this->hashRateTask as $item){
            if (is_array($item)){
                foreach ($item as $task){
                    $taskDb = HashRate::find($task['task_id'],$period);
                    $taskDto = $this->hashRateTaskDto($task,$taskDb,$period);
                    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 static function onBattleSettele($battleData)
    {
        //遍历已刷出的任务列表，更新战斗像相关进度
        $tasks = BigData::getData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE);
        if (!$tasks){
            return;
        }
        self::_computeTaskProgress($tasks['task1'],$battleData);
        self::_computeTaskProgress($tasks['task2'],$battleData);
        BigData::setData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE,
            json_encode($tasks));
    }

    private static function _computeTaskProgress(&$tasks,$battleData){
        $room_mode = getXVal($battleData,'room_mode', 0);
        foreach ($tasks as &$task){
            $taskMeta = AchievementsPower::find($task['task_id']);

            switch ($taskMeta['scene']){
                case  AchievementsPower::MOBA_SCENE :{
                    if ($room_mode == TameBattleDataService::ROOM_MODE_MOBA){
                        self::_getXVal($taskMeta,$battleData,$task);
                    }
                }
                break;
                case  AchievementsPower::PVP_SCENE :{
                    if ($room_mode == TameBattleDataService::MATCH_MODE_PVP){
                        self::_getXVal($taskMeta,$battleData,$task);
                    }
                }
                break;
                case  AchievementsPower::All_SCENE :{
                    self::_getXVal($taskMeta,$battleData,$task);
                }
            }
        }
    }

    private static function _getXVal($taskMeta,$battleData,&$task){
        switch ($taskMeta['Completion_type']){
            case AchievementsPower::TOTAL_WINS_TIMES : {
                if (getXVal($battleData,'victory', 0)){
                    $task['current'] += 1;
                }
            }
                break;
            case AchievementsPower::TOTAL_KILL_TIMES : {
                $task['current'] += getXVal($battleData,'kills', 0);
            }
                break;
            case AchievementsPower::USE_ITEM_TIMES : {
                $task['current'] += self::_procWeaponsSlot($battleData,$taskMeta['condition']);
            }
                break;
            case AchievementsPower::NOMINAL_TIME_BATTLE_END : {
                $duration = getXVal($battleData,'game_duration', 0);
                if ($duration && floor($duration / 60) < $taskMeta['condition']){
                    $task['current'] += 1;
                }
            }
                break;
            case AchievementsPower::IN_BATTLE_UP_LV : {
                $fullLv = getXVal($battleData,'full_level_idx', 0);
                if ($fullLv == 1){
                    $task['current'] += 1;
                }
            }
                break;
            case AchievementsPower::TOTAL_BATTLE_TIMES : {
                if (! getXVal($battleData,'is_run_away', 0)){
                    $task['current'] += 1;
                }
            }
                break;
            case AchievementsPower::TOTAL_LAST_RUNNER : {
                $ranked = getXVal($battleData,'pvp_personal_rank', 0);
                if ($ranked == 20){
                    $task['current'] += 1;
                }
            }
                break;
            case AchievementsPower::RESCUE_TEAMMATE_TIMES : {
                $task['current'] += getXVal($battleData,'rescue_teammate_times', 0);
            }
                break;
            case AchievementsPower::WALKING_DISTANCE : {
                $task['current'] += getXVal($battleData,'move_distance', 0);
            }
                break;
            case AchievementsPower::TOTAL_HERO_BATTLE_TIMES : {
                if (getXVal($battleData,'hero_id', 0) == $taskMeta['condition']){
                    $task['current'] += 1;
                }
            }
                break;
        }
    }

    private static function _procWeaponsSlot($battleData,$condition)
    {
        $useCount = 0;
        $tmpStrs1 = explode('|', getXVal($battleData,'weapons_slot', ''));
        foreach ($tmpStrs1 as $str) {
            $tmpStrs2 = explode(':', $str);
            if (count($tmpStrs2) >= 2) {
                list($weaponId, $use_times) = $tmpStrs2;
                $weaponMeta = Equip::get($weaponId);
                if ($weaponMeta && $weaponMeta['inventory_slot'] > 0) {
                    if ( $weaponId == $condition ){
                        $useCount = $use_times;
                    }
                }
            }
        }
        return $useCount;
    }

    private static $ignoreCa = array(
        'BlockChain@mintGoldBullion'=>1,
        'InGameMall@sellS'=>2,
    );

    public static function onSpendGold($goldNum){
        $ca = getReqVal('c', '') . '@' . getReqVal('a','');
        if (array_key_exists($ca, self::$ignoreCa)) {
            return;
        }
        self::_updateTaskSchedule(AchievementsPower::SPEND_GOLD,$goldNum);
    }

    public static function onSynHero($number){
        self::_updateTaskSchedule(AchievementsPower::SYN_HERO,$number);
    }

    public static function onSynChip($number){
        self::_updateTaskSchedule(AchievementsPower::SYN_CHIP,$number);
    }
    public static function onSynSkin($number){
        self::_updateTaskSchedule(AchievementsPower::SYN_SKIN,$number);
    }

    public static function onUpLvHero(){
        self::_updateTaskSchedule(AchievementsPower::UP_HERO,1);
    }

    public static function onUpLvChip(){
        self::_updateTaskSchedule(AchievementsPower::UP_CHIP,1);
    }



    private static function _updateTaskSchedule($completionType,$number){
        $tasks = BigData::getData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE);
        foreach ($tasks['task3'] as &$task){
            $meta =  AchievementsPower::find($task['task_id']);
            if ($meta['Completion_type'] == $completionType){
                $task['current'] += $number;
            }
        }
        foreach ($tasks['task4'] as &$task){
            $meta =  AchievementsPower::find($task['task_id']);
            if ($meta['Completion_type'] == $completionType){
                $task['current'] += $number;
            }
        }
        BigData::setData(BigData::OFFER_INTEGRAL_HASHRATE_TYPE,
            json_encode($tasks));
    }

}