// import { HANG_UP_CONSTS } from './../../../consts/consts';
import { HangUpRecordModel } from './../../../db/HangUpRecord';
import { RoleModel } from './../../../db/Role';
import { TowerRecordModel } from './../../../db/TowerRecord';
import { Application, BackendSession } from 'pinus';
import { getTowerDataByLv } from '../../../util/gamedata';
import { decodeArrayStr, decodeIdCntArrayStr } 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);
        console.log(roleId, towerLv, towerRec);
        if (!towerRec) {
            // await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: []});
            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: {speedUp: boolean, speedUpCnt: number}, 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
            }
        }
    }
}