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 { getTaskIdByQuality, getTowerDataByLv } from '../../../util/gamedata';
import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm } from '../../../util/util';
import { calcuHangUpReward } 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 getTask(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let curTask = await TowerTaskRecModel.getCurTask(roleId);
        if (!curTask) {
            let taskIds = [];
            TOWER_TASK_CONST.RAND_CNT.forEach(qualityId => {
                const ids = getTaskIdByQuality(qualityId);
                taskIds.concat(getRandEelm(ids, 1));
            })
            curTask = await TowerTaskRecModel.createTask(roleId, roleName, taskIds);
        }
        return {
            code: 200,
            data: {
                msg: '成功',
                curTask
            }
        }
    }
}