import TaskState from "../object/TaskState";
import GameUtil from "./GameUtil";
import TaskConfigMgr from "../task/TaskConfigMgr";
import TeamMgr from "./TeamMgr";
import NpcMgr from "./NpcMgr";
import SKDataUtil from "../gear/SKDataUtil";
import Player from '../object/Player';
import SKLogger from '../gear/SKLogger';
import { EEventType, ETaskKind, ETaskState } from "../role/EEnum";
import Task from "../task/Task";
import EventStateBase from "../event/EventStateBase";
import BangMgr from "../bang/BangMgr";
import DB from "../utils/DB";

export default class RoleTaskMgr {
    player: Player;
    recordList: number[];
    mapTaskState: { [key: number]: TaskState };
    nTimeCnt: any;
    schedule: any;
    mapDailyCnt: { [key: number]: number };
    mapDailyStart: any;
    mapFuBenCnt: any;
    mapActiveScore: any;
    szBeenTake: any;
    szActivePrize: any;
    bCanAutoFight: any;

    constructor(player: Player) {
        this.player = player;
        this.recordList = [];
        this.mapTaskState = {};
        this.nTimeCnt = 0;
        this.mapDailyCnt = {};
        this.mapDailyStart = {};
        this.mapFuBenCnt = {};
        this.mapActiveScore = {};
        this.szBeenTake = [0, 0, 0, 0, 0, 0];
        this.szActivePrize = ['10301,1', '10406,10', '10204,10', '10404,30', '90004,50000', '70004,1'];//活跃度
        this.bCanAutoFight = 0;
    }

    reset() {
        this.mapTaskState = {};
    }

    OnTimer(nIndex?: any) { //一秒一次
        this.nTimeCnt += 1;
        if (this.nTimeCnt % 2 == 0) {
            this.onGameEvent(EEventType.PLAYER_ARRIVE_AREA, {
                mapid: this.player.mapid,
                x: this.player.x,
                y: this.player.y
            });
        }
        if (this.nTimeCnt % 5 == 0)
            this.OnFailEvent(EEventType.TIMEOUT, GameUtil.getTime());
    }

    OnNewDay() {
        this.mapDailyStart = {};
        let vecTask = [];
        for (var it in this.mapTaskState) {
            if (this.mapTaskState[it].nKind == ETaskKind.DAILY || this.mapTaskState[it].nKind == ETaskKind.FUBEN) {
                if (this.mapTaskState[it].nTaskGrop == 22){
                    if (new Date().getDay() == 1){
                        vecTask.push(this.mapTaskState[it].nTaskID);
                    }
                }else {
                    vecTask.push(this.mapTaskState[it].nTaskID);
                }

            }
        }
        for (var it in vecTask) {
            this.abortTask(vecTask[it]);
        }
        let data: any = this.mapDailyCnt[22];
        this.mapDailyCnt = {}; //放弃任务会增加计数，所以放到放弃后面
        this.mapFuBenCnt = {};
        this.mapActiveScore = {};
        if (new Date().getDay() != 1){
            if (data != undefined){
                this.mapDailyCnt[22] = data;
            }
        }

        this.szBeenTake = [0, 0, 0, 0, 0, 0];
        this.player.unget_doublecnt += 60;
        this.updateTaskStateToClient();
    }
    // 获得任务步骤状态
    getTaskStepState(taskId: number, step: number): EventStateBase {
        if (this.mapTaskState.hasOwnProperty(taskId) == false) {
            return null;
        }
        if (step < 0 || step >= this.mapTaskState[taskId].vecEventState.length) {
            return null;
        }
        let result = this.mapTaskState[taskId].vecEventState[step];
        return result;
    }
    // 初始化
    init(taskList: any[], recordList: number[], mapDailyCnt: any, mapFuBenCnt: any, mapDailyStart: any, mapActiveScore: any, szBeenTake: number[]) {
        this.recordList = recordList.slice(0);
        this.mapTaskState = {};
        this.mapDailyCnt = mapDailyCnt;
        this.mapFuBenCnt = mapFuBenCnt;
        this.mapDailyStart = mapDailyStart;
        this.mapActiveScore = mapActiveScore;
        this.szBeenTake = szBeenTake;
        if (SKDataUtil.isEmptyArray(taskList)) {
            SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]无任务数据!`);
        }
        for (let item of taskList) {
            let isFinish = this.isAlreadyDoneThisTask(item.nTaskID);
            if (!isFinish) {
                this.addTaskState(parseInt(item.nTaskID), parseInt(item.nCurStep));
            }
        }
        this.checkAndDeleteFinishedTask();
    }
    // 是否完成此任务
    isAlreadyDoneThisTask(taskId: number): boolean {
        for (let item of this.recordList) {
            if (item == taskId) {
                return true;
            }
        }
        return false;
    }

    isMatchLimit(stTask: any): boolean {
        for (var itLimit in stTask.vecLimit) {
            if (stTask.vecLimit[itLimit].nKey == 'nPreTask') //前置任务
            {
                let nPreTask = parseInt(stTask.vecLimit[itLimit].nValue);
                if (this.isAlreadyDoneThisTask(nPreTask) == false)
                    return false;
            }
            if (stTask.vecLimit[itLimit].nKey == 'nBang') {
                if (this.player.bangid == 0)
                    return false;
            }
            if (stTask.vecLimit[itLimit].nKey == 'nRace') {
                let nNeedRace = parseInt(stTask.vecLimit[itLimit].nValue);
                if (this.player.race != nNeedRace)
                    return false;
            }
        }
        return true;
    }
    // 加入任务状态
    addTaskState(taskId: number, step: number) {
        let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
        if (task == null) {
            SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]找不到任务配置[${taskId}]!`);
            return;
        }
        // 组队任务,玩家未组队
        if (TaskConfigMgr.shared.isTeamTask(taskId) && this.player.teamid == 0) {
            // SKLogger.warn(`玩家[${this.player.roleid}:${this.player.name}]组队任务未组队跳过!`);
            return;
        }
        let taskState = new TaskState();
        taskState.player = this.player;
        taskState.initState(task, step);
        this.mapTaskState[taskState.nTaskID] = taskState;
    }

    isAlreadyHasThisKindDailyTask(groupId: number): boolean {
        for (let key in this.mapTaskState) {
            let taskId: number = SKDataUtil.numberBy(key);
            let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
            if (task == null) {
                continue;
            }
            if (task.nTaskGrop == groupId) {
                return true;
            }
        }
        return false;
    }
    // 获得任务次数
    getKindTaskCnt(taskGroup: number): number {
        let result = this.mapDailyCnt[taskGroup];
        if (result == null) {
            return 0;
        }
        return result;
    }
    // 获得活动组任务
    getDailyGroupTask(): { [key: number]: Task[] } {
        let dailyTasks: Task[] = TaskConfigMgr.shared.mapConfigTask[ETaskKind.DAILY];
        if (dailyTasks == null) {
            SKLogger.warn(`角色任务管理器:玩家[${this.player.roleid}:${this.player.name}]活动组任务没有配置!`);
            return {};
        }
        let result: any = {};
        for (let task of dailyTasks) {
            let group = task.nTaskGrop;
            if (result[group] == null) {
                result[group] = [];
            }
            result[group].push(task);
        }
        return result;
    }
    // 取得开启的活动任务
    getEnableDailyTask(mapDailyTask: any, group: any): Task[] {
        let dailyGroup: Task[] = mapDailyTask[group];
        let result: Task[] = [];
        for (let key in dailyGroup) {
            let task: Task = dailyGroup[key];
            if (this.isMatchLimit(task) == false) {
                continue;
            }
            result.push(task);
        }
        return result;
    }
    // 检查并接受任务
    checkAndInceptTask() {
        let taskList: Task[] = GameUtil.getDefault(TaskConfigMgr.shared.mapConfigTask[ETaskKind.STORY], []);
        for (let key in taskList) {
            let task: Task = taskList[key];
            if (this.isAlreadyDoneThisTask(task.nTaskID)) {
                continue;
            }
            if (this.mapTaskState.hasOwnProperty(task.nTaskID)) {
                continue;
            }
            if (this.isMatchLimit(task) == false) {
                continue;
            }
            this.addTaskState(task.nTaskID, 0);
            break;
        }
        let dailyTasks = this.getDailyGroupTask();
        for (let key in dailyTasks) {
            if (this.mapDailyStart.hasOwnProperty(key) == false) {
                continue;
            }
            let groupId: number = SKDataUtil.numberBy(key);
            // 活动任务是组队,玩家不是队长则跳过
            if (TaskConfigMgr.shared.IsTeamDaily(groupId) && this.player.isleader == false) {
                continue;
            }
            if (this.isAlreadyHasThisKindDailyTask(groupId)) {
                continue;
            }
            let groupTask: Task[] = this.getEnableDailyTask(dailyTasks, key);
            if (SKDataUtil.isEmptyArray(groupTask)) {
                SKLogger.debug(`玩家[${this.player.roleid}:${this.player.name}]组任务[${key}]为空`);
                return;
            }
            let task: Task = SKDataUtil.randomList(groupTask);
            // let task: Task = groupTask[3];
            if (task != null) {
                if (this.getKindTaskCnt(groupId) >= task.nDailyCnt) //这个类型的每日任务做完了
                    continue;
                if (this.isMatchLimit(task) == false)
                    continue;
                this.addTaskState(task.nTaskID, 0);
            }
        }
    }
    // 开始组任务
    startGroupTask(taskGroup: number): string {
        let current: number = this.getKindTaskCnt(taskGroup);
        let max = TaskConfigMgr.shared.getDailyMaxCount(taskGroup);
        if (current >= max) {
            return "次数已满";
        }
        if (TaskConfigMgr.shared.IsTeamDaily(taskGroup) && this.player.teamid == 0 && this.player.isleader == false) {
            return '只有队长才能接这个任务';
        }
        if (this.mapDailyStart.hasOwnProperty(taskGroup)) {
            return '你已经领过这个任务了';
        }
        this.mapDailyStart[taskGroup] = true;
        this.checkAndInceptTask();
        this.updateTaskStateToClient();
        return "";
    }

    CheckAndInceptFuBenTask(nTaskID: any) {
        let pTaskConfig = TaskConfigMgr.shared.getTaskConf(nTaskID);
        if (null == pTaskConfig || pTaskConfig.nKind != ETaskKind.FUBEN)
            return 'syserr';

         if (this.GetFuBenCnt(nTaskID) >= 1 && pTaskConfig.nTaskGrop != 14)
             return '次数已满';

        if (this.player.teamid == 0 || this.player.isleader == false)
            return '只有队长才能接这个任务';

        if (this.mapTaskState.hasOwnProperty(pTaskConfig.nTaskID))
            return '你已经领取过这个任务';

        if (this.isMatchLimit(pTaskConfig) == false)
            return '不满足条件';

        this.addTaskState(pTaskConfig.nTaskID, 0);
        this.updateTaskStateToClient();
        return '';
    }
    // 游戏事件
    onGameEvent(nEventType: EEventType, data: any) {
        if (this.player.teamid > 0 && this.player.isleader == false) {
            SKLogger.debug(`游戏事件:玩家[${this.player.roleid}:${this.player.name}]是队员跳过!`);
            return;
        }

        let onchange = false
        for (let key in this.mapTaskState) {
            if(this.mapTaskState[key].taskOnGameEvent(nEventType, data) == true){
                onchange = true
            }
        }

        if(onchange){
            this.checkAndDeleteFinishedTask();
            this.updateTaskStateToClient();
        }
    }

    OnTeamTaskState(mapLeaderTaskState: any) {
        for (let key in mapLeaderTaskState) {
            if (TaskConfigMgr.shared.isTeamTask(key) == false) {
                continue;
            }
            let groupId: number = SKDataUtil.numberBy(key);
            if (this.mapTaskState.hasOwnProperty(groupId)) {
                delete this.mapTaskState[groupId];
            }
            let pInfo = mapLeaderTaskState[key];
            let taskState = new TaskState();
            taskState.nTaskID = pInfo.nTaskID;
            taskState.nKind = pInfo.nKind;
            taskState.nTaskGrop = pInfo.nTaskGrop;
            taskState.nTaskFinish = pInfo.nTaskFinish;
            taskState.vecEventState = pInfo.vecEventState.slice(0);
            taskState.vecFailEvent = pInfo.vecFailEvent.slice(0);
            taskState.player = this.player;
            this.mapTaskState[groupId] = taskState
        }
        this.updateTaskStateToClient();
    }
    // 放弃任务
    abortTask(taskId: number) {
        let taskState = this.mapTaskState[taskId];
        if (taskState == null) {
            SKLogger.debug(`放弃任务:找不到任务[${taskId}]状态!`);
            return;
        }
        let task: Task = TaskConfigMgr.shared.getTaskConf(taskId);
        if (task == null) {
            SKLogger.warn(`放弃任务:找不到任务[${taskId}]信息!`);
            return;
        }
        if (task.nKind == ETaskKind.STORY) {
            this.player.send('s2c_notice', {
                strRichText: '剧情任务无法取消'
            });
            SKLogger.debug(`放弃任务:剧情任务[${task.nTaskID}:${task.strTaskName}]不能取消!`);
            return;
        }
        taskState.nTaskFinish = ETaskState.FALIED;
        this.checkAndDeleteFinishedTask();
        this.updateTaskStateToClient();
        SKLogger.debug(`玩家[${this.player.roleid}:${this.player.name}]取消任务[${task.nTaskID}:${task.strTaskName}]`);
    }
    // 玩家离队
    leaveTeam() {
        // 找到所有的组队任务
        let list = [];
        for (let key in this.mapTaskState) {
            if (TaskConfigMgr.shared.isTeamTask(key) == false) {
                continue;
            }
            list.push(SKDataUtil.numberBy(key));
        }
        //放弃任务 
        for (let key in list) {
            this.abortTask(list[key]);
        }
    }
    // 任务失败
    OnFailEvent(nEventType: any, stData: any) {
        let bChange = false;
        for (let it in this.mapTaskState) {
            if (this.mapTaskState[it].TaskOnFialEvent(nEventType, stData) == true)
                bChange = true;
        }
        if (bChange) {
            this.checkAndDeleteFinishedTask();
            this.updateTaskStateToClient();
        }
    }
    // 检查所有完成或失败的任务
    checkAndDeleteFinishedTask() {
        for (let key in this.mapTaskState) {
            let taskState: TaskState = this.mapTaskState[key];
            if (taskState.nTaskFinish == ETaskState.DONE) {
                this.onTaskFinish(taskState, true);
                delete this.mapTaskState[key];
                continue;
            }
            if (taskState.nTaskFinish == ETaskState.FALIED) {
                this.onTaskFinish(taskState, false);
                delete this.mapTaskState[key];
                continue;
            }
        }
        this.checkAndInceptTask();
    }
    // 任务完成
    onTaskFinish(taskState: TaskState, isFinish: boolean) {
        let playerList: Player[];
        let leaderStep = 0;
        if (this.player.teamid == 0) {
            playerList = [this.player];
        }
        if (this.player.teamid > 0) {
            playerList = TeamMgr.shared.getTeamPlayer(this.player.teamid);
        }
        let taskInfo = TaskConfigMgr.shared.getTaskConf(taskState.nTaskID);
        if (taskInfo == null) {
            console.warn(`玩家[${this.player.roleid}:${this.player.name}]任务[${taskState.nTaskID}]找不到!`);
            return;
        }
        for (let member of playerList) {
            if (member == null) {
                continue;
            }
            if (isFinish && taskInfo.nKind == ETaskKind.STORY) {
                member.getTaskMgr().recordList.push(taskState.nTaskID);
            }
            if(isFinish){
                if(taskInfo.nTaskGrop == 2){
                    let bang = BangMgr.shared.getBang(member.bangid);
                    if(bang){
                        for (const roleInfo of bang.rolelist) {
                            if(roleInfo.roleid == member.roleid){
                                roleInfo.daytask++;
                                bang.bangexp += 75;
                                DB.updateBangMember(roleInfo,1);
                                DB.bangUpdate({bangid: member.bangid, banglevel: bang.banglevel, bangexp: bang.bangexp});
                                break;
                            }
                        }
                    }
                }
                if(member.doublecnt > 0 && taskInfo.nTaskGrop == 6){
                    member.doublecnt --;
                    DB.updateDoublePoint({doublecnt: member.doublecnt,unget_doublecnt: member.unget_doublecnt,roleid: member.roleid})
                }
                if(member.doublecnt > 0 && taskInfo.nTaskGrop == 7){
                    member.doublecnt -= 4;
                    DB.updateDoublePoint({doublecnt: member.doublecnt,unget_doublecnt: member.unget_doublecnt,roleid: member.roleid})
                }
                member.getTaskMgr().onDeleteTask(taskState,leaderStep, true);
                if(member.isleader){
                    leaderStep = GameUtil.getDefault(this.mapFuBenCnt[taskState.nTaskID], 0);
                }
            }else{
                member.getTaskMgr().onDeleteTask(taskState,leaderStep, false);
            }
            member.send('s2c_notice', {
                strRichText: isFinish ? `任务[${taskInfo.strTaskName}]完成!` : `任务[${taskInfo.strTaskName}]失败!`
            });
        }
    }
    // 删除任务
    onDeleteTask(taskState: TaskState,leaderStep: number, isSuccess: boolean) {
        let max = TaskConfigMgr.shared.getDailyMaxCount(taskState.nTaskGrop);
        let nextStep: number = taskState.vecEventState.length;
        for (let key in taskState.vecEventState) {
            let stepState = taskState.vecEventState[key];
            if (stepState.nState == ETaskState.DOING) {
                continue;
            }
            nextStep = SKDataUtil.numberBy(key);
            if (typeof (stepState.vecRemainNpc) == "undefined") {
                continue;
            }
            for (let npc in stepState.vecRemainNpc) {
                NpcMgr.shared.CheckAndDeleteNpc(stepState.vecRemainNpc[npc].nOnlyID, this.player);
            }
        }
        if (isSuccess) {//任务次数加1
            //判断是不是组队任务
            let flag = TaskConfigMgr.shared.isTeamTask(taskState.nTaskID);
            if(flag == false){//如果不是组队任务，队员不加次数
                if(this.player.teamid > 0 && this.player.isleader == false){
                    return;
                }
            }
            if (taskState.nKind == ETaskKind.DAILY ) {
                let num = this.mapDailyCnt[taskState.nTaskGrop];
                if(num == undefined){
                    this.mapDailyCnt[taskState.nTaskGrop] = GameUtil.getDefault(this.mapDailyCnt[taskState.nTaskGrop], 0) + 1;
                }else {
                    if(num < max){
                        this.mapDailyCnt[taskState.nTaskGrop] = GameUtil.getDefault(this.mapDailyCnt[taskState.nTaskGrop], 0) + 1;
                    }
                }
            }
            if (taskState.nKind == ETaskKind.FUBEN) {
                let nCurStep = GameUtil.getDefault(this.mapFuBenCnt[taskState.nTaskID], 0);
                if(this.player.isleader == false && taskState.nTaskID == 1004){
                    nCurStep = leaderStep;
                }
                this.mapFuBenCnt[taskState.nTaskID] = Math.max(nCurStep, nextStep);
            }
        }
    }
    // 更新任务状态给客户端
    updateTaskStateToClient() {
        let vecData = [];
        for (let it in this.mapTaskState) {
            let stTask = this.mapTaskState[it];
            let vecJson = [];
            for (let itStep in stTask.vecEventState) {
                let strJson = SKDataUtil.toJson(stTask.vecEventState[itStep], "{}");
                vecJson.push(strJson);
            }
            vecData.push({
                nTaskID: stTask.nTaskID,
                vecStep: vecJson
            });
        }
        this.player.send('s2c_role_task_list', {
            vecTask: vecData,
            strJsonDaily: SKDataUtil.toJson(this.mapDailyCnt, "{}")
        });
        if (this.player.teamid > 0 && this.player.isleader == true) {
            this.SynchroTaskToTeam();
        }
    }

    SynchroTaskToTeam() {
        let pTeamInfo = TeamMgr.shared.teamList[this.player.teamid];
        if (null == pTeamInfo) {
            return;
        }

        for (let index = 1; index < pTeamInfo.playerlist.length; index++) {
            let pMember: Player = pTeamInfo.playerlist[index];
            if (null == pMember || pMember.roleid == this.player.roleid || pMember.isleader) {
                continue;
            }
            if (pMember.getTaskMgr() == null) {
                continue;
            }
            pMember.getTaskMgr().OnTeamTaskState(this.mapTaskState);
        }

    }

    AddActive(nKind: any, nNum: any) {
        if (this.mapActiveScore.hasOwnProperty(nKind) == false)
            this.mapActiveScore[nKind] = 0;

        this.mapActiveScore[nKind] = Math.min(this.mapActiveScore[nKind] + nNum, 140);
        this.SendDailyActive();
    }

    SendDailyActive() {
        let tmpData: any = {};
        tmpData.mapActiveScore = this.mapActiveScore;
        tmpData.szBeenTake = this.szBeenTake;
        tmpData.szActivePrize = this.szActivePrize;
        // 已接的每日任务
        tmpData.mapDailyStart = this.mapDailyStart;
        // 每日任务次数
        tmpData.mapDailyCnt = this.mapDailyCnt;
        // 副本任务次数
        tmpData.mapFuBenCnt = this.mapFuBenCnt;
        // 双倍点数
        tmpData.doublecnt = this.player.doublecnt;
        // 可领取点数
        tmpData.canget = this.player.unget_doublecnt == null ? 0 : this.player.unget_doublecnt;
        this.player.send('s2c_daily_info', {
            strJson: SKDataUtil.toJson(tmpData, "{}")
        });
    }

    GetFuBenCnt(nTaskID: any) {
        if (this.mapFuBenCnt.hasOwnProperty(nTaskID) == false)
            return 0;

        return this.mapFuBenCnt[nTaskID];
    }

    //获取任务信息
    getTaskStateByNpcOnlyid(npcOnlyid: any): { taskID: any, step: any } {
        for (let it in this.mapTaskState) {
            let step = this.mapTaskState[it].getTaskStepByNpcOnlyid(npcOnlyid);
            if (step)
                return { taskID: this.mapTaskState[it].nTaskID, step: step };
        }
        return null;
    }
}