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 } 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};
            });
            await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
            return { code: 201, data: '天梯记录异常' };
        }
        const data = {
            curLv: towerLv,
            usedHeroes: towerRec.heroes,
            progress: towerRec.warStatus
        };
        return {
            code: 200,
            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 {code: 201, data: '只能重置当前层'};
        }
        const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
        if (!record) {
            return { code: 201, data: '重置错误'};
        }
        return { code: 200, data: { record } };
    }

    async checkHangUpRewards(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        const { multi, timeReward } = await calcuHangUpReward(roleId);
        if (multi == 0) {
            return {
                code: 201,
                data: {
                    msg: '尚未到可收取时间',
                }
            }
        }
        const rewards = decodeIdCntArrayStr(timeReward, multi);
        return {
            code: 200,
            data: {
                msg: '成功',
                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 {
                code: 201,
                data: {
                    msg: '尚未到可收取时间',
                }
            }
        }
        const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
        const newRec = await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime);
        return {
            code : 200,
            data: {
                msg: '成功',
                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 {
                code: 201,
                data: {
                    msg: '加速参数错误',
                }
            };
        }
        const curTime = new Date();
        const { multi, timeReward, endLv } = await calcuHangUpReward(roleId, true, msg.speedUpCnt, curTime);
        if (multi <= 0) {
            return {
                code: 201,
                data: {
                    msg: '今日加速次数不足'
                }
            };
        }

        const role = await RoleModel.hangUpSpdUp(roleId, multi, curTime);
        if (!role) {
            return {
                code: 201,
                data: {
                    msg: '不满足加速条件'
                }
            };
        }
        const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, multi, endLv);
        const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
        return {
            code : 200,
            data: {
                msg: '成功',
                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 {
            code: 200,
            data: {
                msg: '成功',
                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 { code: 201, data: {msg: '没有可用派遣任务'}};
        }
        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 { code: 201, data: {msg: '一个任务最多派遣三个武将'}};
            }
            if (usedHeroes.length > 0) {
                let used = false;
                task.heroes.forEach(hid => {
                    if (usedHeroes.indexOf(hid) !== -1) {
                        used = true;
                    }
                })
                if (used) {
                    return { code: 201, data: {msg: '武将已经派遣到其他任务'}};
                }
            }
            if (tasksCode.indexOf(task.taskCode) === -1) {
                return { code: 201, data: {msg: '未找到此任务编号'}};
            }
        }
        const curTime = new Date();
        const recs = await TowerTaskRecModel.sendHeroes(roleId, msg.batchCode, msg.tasks, curTime);
        if (!recs || recs.length === 0) {
            return { code: 201, data: {msg: '任务更新失败，请检查任务编号'}};
        }
        return {
            code: 200,
            data: {
                msg: '派遣成功',
                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 { code: 201, data: {msg: '没有可用派遣任务'}};
        }
        const compTasks = [];
        let goods = [];
        for (let task of curTasks) {
            if (task.batchCode !== msg.batchCode) {
                return { code: 201, data: {msg: '派遣编码错误'}};
            }
            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 {
            code: 200,
            data: {
                msg: '成功',
                compTasks, goods
            }
        }
    }
}