import { Application, BackendSession } from 'pinus';
import { BattleRecordModel } from '../../../../../shared/db/BattleRecord';
import { getWarById, getGoodById } from '../../../util/gamedata';
import { CounterModel } from '../../../../../shared/db/Counter';
import { HeroModel } from '../../../../../shared/db/Hero';
import { EquipModel } from '../../../../../shared/db/Equip';

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

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

    // 进入关卡前，设置status=0
    async checkBattle(msg: {battleId: number}, session: BackendSession) {
        const { battleId } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);
        if(!warInfo) {
            return {
                code: 202,
                data: "缺少关卡信息"
            }
        }

        const BattleRecord = await BattleRecordModel.updateBattleRecordByRole(roleId, battleId, {
            $set: {
                roleName,
                status: 0,
                warName: warInfo.gk_name,
                warType: warInfo.war_type
            },
            $inc: {
                count: 1
            }
        });

        let { count, status} = BattleRecord;
        return {
            code: 200,
            data: {
                battleId, count, status
            }
        }
    }

    // 关卡结算，记录使用的武将，获得奖励
    async battleEnd(msg: {battleId: number, isSuccess: boolean, heroes: Array<any>, }, session: BackendSession) {

        const { battleId, isSuccess, heroes } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);

        const BattleRecord = await BattleRecordModel.getBattleRecordByRole(roleId, battleId);
        if(!BattleRecord || BattleRecord.status != 0) {
            return {
                code: 202,
                data: '关卡状态错误，未开启挑战'
            }
        }

        let params = {}, reward: Array<any>;
        if(isSuccess) { // 挑战胜利
            params = {
                $set: {
                    status: 1,
                    record: { heroes }
                },
                $inc: {
                    successCount: 1
                }
            }
            reward = await this.handleReward(roleId, roleName, warInfo.reward);
        } else { // 挑战失败
            params = {
                $set: {
                    status: 2,
                    record: { heroes }
                },
                $inc: {
                    failCount: 1
                }
            }
            reward = [];
        }

        const result = await BattleRecordModel.updateBattleRecordByRole(roleId, battleId, params);
        let {count, status} = result;

        return {
            code: 200,
            data: {
                battleId, count, status,
                goods: reward
            }
        }
    }

    private async handleReward(roleId: string, roleName: string, rewardStr:string) {
        let {weapons, armors, items, souls} = this.decodeReward(rewardStr);
        let addWeapons = await this.rewardWeapons(roleId, roleName, weapons);
        // 暂时只处理装备
        // let addArmors = await this.rewardArmors(roleId, roleName, armors);
        // let addItems = await this.rewardItems(roleId, roleName, items);
        // let addSouls = await this.rewardSouls(roleId, roleName, souls);

        let result = [].concat(addWeapons);
        return result;
    }

    private async rewardWeapons (roleId: string, roleName:string,  weapons: Array<{id:number,cnt:number, type: number}>) {

        let weaponsData = [];
        for (let weapon of weapons) {
            let cnt = weapon.cnt;
            let g = getGoodById(weapon.id);
            while (cnt > 0) {
                const seqId = await CounterModel.getNewCounter('eid');
                const equipInfo = {
                    roleId,
                    roleName,
                    eid: weapon.id,
                    eName: g.name,
                    seqId,
                    type: weapon.type,
                    lv: g.lv
                }
                const equip = await EquipModel.createEquip(equipInfo);
                cnt -= 1;
                weaponsData.push(equip);
            }
        }
        return weaponsData;
    }

    private decodeReward(rewardStr: string, multiple=1) {
        let weapons = [];
        let armors = [];
        let items = [];
        let souls = [];
        rewardStr.split('|').forEach((rStr) => {
            // r[0]: type, r[1]: id, r[2]: count
            let r = rStr.split('&');
            let type = parseInt(r[0] || '')||0;
            let id = parseInt(r[1] || '') || 0;
            let cnt = (parseInt(r[2] || '') || 0) * multiple;
            if (id !== 0 && cnt !== 0) {
                switch (r[0]) {
                case '0':
                    items.push({id, cnt, type});
                    break;
                case '1':
                    weapons.push({id, cnt, type});
                    break;
                case '2':
                    armors.push({id, cnt, type});
                    break;
                case '3':
                    souls.push({id, cnt, type});
                    break;
                default:
                    break;
                }
            }
        });
        return {weapons, armors, items, souls};
    }
}