import { STATUS } from './../../../consts/statusCode';
import { TOWER_TASK_CONST } from './../../../consts/consts';
import { TowerTaskRecModel } from './../../../db/TowerTaskRec';
import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
import { HangUpRecordModel } from './../../../db/HangUpRecord';
import { RoleModel } from './../../../db/Role';
import { TowerRecordModel } from './../../../db/TowerRecord';
import { Application, BackendSession } from 'pinus';
import { getTaskById, getTaskIdByQuality, getTowerDataByLv } from '../../../pubUtils/gamedata';
import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm, resResult } from '../../../pubUtils/util';
import { calcuHangUpReward, checkTaskConditions } from '../../../services/battleService';
import { handleFixedReward } from '../../../services/rewardService';

export default function(app: Application) {
    return new TowerBattleHandler(app);
}

export class TowerBattleHandler {
    constructor(private app: Application) {
    }

    /**
     * 获取天梯当前挑战状态
     * @param session 
     */
    async getStatus(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        let { towerLv } = await RoleModel.findByRoleId(roleId);
        if (!towerLv) {
            towerLv = 1;
            await RoleModel.towerLvUp(roleId);
        }
        let towerRec = await TowerRecordModel.getRecordByLv(roleId, towerLv);
        if (!towerRec) {
            const towerInfo = getTowerDataByLv(towerLv);
            const { warIds } = towerInfo;
            const sts = decodeArrayStr(warIds).map(id => {
                return {warId: parseInt(id), status: false};
            });
            towerRec = await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
            // return { code: 201, data: '天梯记录异常' };
        }
        const data = {
            curLv: towerLv,
            usedHeroes: towerRec.heroes,
            progress: towerRec.warStatus
        };
        return resResult(STATUS.SUCCESS, data);
    }

    /**
     * 重置天梯当前层的挑战记录
     * @param towerLv 要重置的天梯层数
     * @param session 
     */
    async resetLv(msg: {towerLv: number}, session: BackendSession) {
        let roleId = session.get('roleId');
        let { towerLv } = await RoleModel.findByRoleId(roleId);
        if (msg.towerLv !== towerLv) {
            return resResult(STATUS.TOWER_RESET_ERR);
        }
        const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
        if (!record) {
            return resResult(STATUS.TOWER_NOT_FOUND);
        }
        return resResult(STATUS.SUCCESS, record);
    }

    async checkHangUpRewards(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        const { multi, timeReward, startTime } = await calcuHangUpReward(roleId);
        if (multi == 0) {
            return resResult(STATUS.TOWER_HANG_UP_NOT_VALID);
        }
        const rewards = decodeIdCntArrayStr(timeReward, multi);
        return resResult(STATUS.SUCCESS, {startTime, rewards: Array.from(rewards, item => ({[item[0]]: item[1]}))});
    }

    async recHangUpRewards(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        const { multi, timeReward, endLv, endTime } = await calcuHangUpReward(roleId);
        if (multi == 0) {
            return resResult(STATUS.TOWER_HANG_UP_NOT_VALID);
        }
        const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
        const newRec = await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime);
        return resResult(STATUS.SUCCESS, { endTime, goods, hangUpRec: newRec });
    }

    async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        if (msg.speedUpCnt <= 0) {
            return resResult(STATUS.WRONG_PARMS);
        }
        const curTime = new Date();
        const { multi, timeReward, endLv } = await calcuHangUpReward(roleId, true, msg.speedUpCnt, curTime);
        if (multi <= 0) {
            resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME);
        }

        const role = await RoleModel.hangUpSpdUp(roleId, multi, curTime);
        if (!role) {
            return resResult(STATUS.TOWER_HANG_UP_FAILED);
        }
        const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, multi, endLv);
        const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
        return resResult(STATUS.SUCCESS, { goods, rewardLv: endLv, spdUpRec });
    }

    async getTasks(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let curTasks = await TowerTaskRecModel.getCurTasks(roleId);
        if (!curTasks || curTasks.length == 0) {
            let taskIds = [];
            TOWER_TASK_CONST.RAND_CNT.forEach((cnt, idx) => {
                const ids = getTaskIdByQuality(idx + 1);
                const tmp = getRandEelm(ids, cnt);
                taskIds = taskIds.concat(getRandEelm(ids, cnt));
            })
            curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, taskIds);
        }
        return resResult(STATUS.SUCCESS, { curTasks });
    }

    async sendTaskHero(msg: {batchCode: string, tasks: Array<{taskCode: string, heroes: Array<number>}>}, session: BackendSession) {
        let roleId = session.get('roleId');
        const curTasks = await TowerTaskRecModel.getCurTasks(roleId);
        if (!curTasks || curTasks.length == 0) {
            return resResult(STATUS.TOWER_TASK_NOT_FOUND);
        }
        let usedHeroes = [];
        const tasksCode = [];
        curTasks.forEach(task => {
            usedHeroes = usedHeroes.concat(task.heroes);
            tasksCode.push(task.taskCode);
        });
        for (let task of msg.tasks) {
            if (task.heroes.length > TOWER_TASK_CONST.MAX_HEROES_NUM) {
                return resResult(STATUS.TOWER_TASK_MAX_HERO);
            }
            if (usedHeroes.length > 0) {
                let used = false;
                task.heroes.forEach(hid => {
                    if (usedHeroes.indexOf(hid) !== -1) {
                        used = true;
                    }
                })
                if (used) {
                    return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
                }
            }
            if (tasksCode.indexOf(task.taskCode) === -1) {
                return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
            }
        }
        const curTime = new Date();
        const recs = await TowerTaskRecModel.sendHeroes(roleId, msg.batchCode, msg.tasks, curTime);
        if (!recs || recs.length === 0) {
            return resResult(STATUS.TOWER_TASK_SEND_ERR);
        }
        return resResult(STATUS.SUCCESS, { tasks: recs });
    }

    async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');

        let allFlag = !msg.taskCode;

        const curTime = new Date();
        const curTasks = await TowerTaskRecModel.getCurTasks(roleId);
        if (!curTasks || curTasks.length == 0) {
            return resResult(STATUS.TOWER_TASK_NOT_FOUND);
        }
        const compTasks = [];
        let goods = [];
        for (let task of curTasks) {
            if (task.batchCode !== msg.batchCode) {
                return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
            }
            if ((allFlag || task.taskCode === msg.taskCode) && task.status === 1) {
                let {completeTime, reward, bonusCondition, bonus} = getTaskById(task.taskId);
                if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
                    compTasks.push(task.taskCode);
                    const rewardGoods = await handleFixedReward(roleId, roleName, reward, 1);
                    goods = goods.concat(rewardGoods);
                    if(bonusCondition) {
                        const res = checkTaskConditions(roleId, task.heroes, bonusCondition);
                        const bonusGoods = await handleFixedReward(roleId, roleName, bonus, 1);
                        goods = goods.concat(bonusGoods);
                    }
                }
            }
        }
        await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
        return resResult(STATUS.SUCCESS, { compTasks, goods });
    }
}