import { Application, BackendSession } from 'pinus';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { BattleSweepRecordModel } from '../../../db/BattleSweepRecord';
import { getWarById,  } from '../../../pubUtils/gamedata';
import { genCode } from '../../../pubUtils/util';
import { WAR_TYPE, EVENT_START_BATTLE } from '../../../consts/consts';
import { checkDaily, checkDailyAndIncrease } from '../../../services/dailyBattleService';
import { checkTowerWar, towerBattleEnd } from '../../../services/battleService';
import { WarReward } from '../../../services/warRewardService';
import { getAp, setAp } from '../../../services/actionPointService';
import { setBattleStatus, startEvent } from '../../../services/eventSercive';

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

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

    // 获取关卡列表
    async checkBattle(msg: {battleId: number, heroes: Array<any> }, session: BackendSession) {
        const { battleId, heroes } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);
        if(!warInfo) {
            return { code: 202, data: "缺少关卡信息" }
        }
        if(!warInfo.hasOwnProperty('cost')) {
            warInfo['cost'] = 0;
        }

        let apJson = await getAp(Date.now(), roleId);
        let {ap} = apJson;
        if(ap < warInfo.cost) {
            return { code: 202, data: "体力不足" }
        }

        // 前置关卡是否挑战过
        let previousGk = warInfo.previousGk;
        if(previousGk) {
            let preBattle = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, previousGk, 1);
            if(!preBattle) return {code: 202, data: '需要完成上一关才可以挑战'};
        }

        let dailyNum = {};
        let towerData = {};
        if(warInfo.warType == WAR_TYPE.DAILY) {
            let checkResult = await checkDaily(roleId, battleId, 1);
            if(checkResult.status == -1) {
                return {code: 202, data: checkResult.msg}
            }
            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
        } else if (warInfo.warType == WAR_TYPE.TOWER) {
            let checkResult = await checkTowerWar(roleId, battleId, heroes);
            if(checkResult.status) {
                return {code: 202, data: checkResult.msg}
            }
            towerData = Object.assign(towerData, checkResult.data);
        }
        const battleCode = genCode(8);
        const BattleRecord = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: {
                roleId, roleName, battleId,
                status: 0,
                warName: warInfo.gk_name,
                warType: warInfo.warType,
                record: { heroes }
            }
        }, true);

        let {status} = BattleRecord;


        return {
            code: 200,
            data: {
                battleId, battleCode, status, apJson, dailyNum, towerData
            }
        }
    }

    // 关卡列表
    async getBattleList(msg: {type: number }, session: BackendSession) {
        const { type } = msg;
        let roleId = session.get('roleId');

        const BattleRecord = await BattleRecordModel.getBattleList(roleId, type);
        let result = []; // 去重
        for(let br of BattleRecord) {
            let index = result.findIndex(cur => cur.battleId == br.battleId);
            if(index == -1) {
                result.push(br);
            }
        }

        return { code: 200, data: result }
    }

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

        const { battleCode, battleId, isSuccess, heroes, star } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let sid = session.get('sid');
        let warInfo = getWarById(battleId);
        if(!warInfo) {
            return { code: 202, data: "缺少关卡信息" }
        }
        if(!warInfo.hasOwnProperty('cost')) {
            warInfo['cost'] = 0;
        }

        const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
        if(!BattleRecord || BattleRecord.status != 0) {
            return { code: 202, data: '关卡状态错误' }
        }

        let flag = 1; // 对比hero信息
        let { record: { heroes: dbHeroes } } = BattleRecord;
        for(let hid of heroes) {
            if(dbHeroes.indexOf(hid) == -1) flag = 0;
        }
        if(!flag) {
            return { code: 202, data: '关卡信息不同' }
        }

        const now = Date.now(); // 当前时间戳
        let apJson = await setAp(now, roleId, -1 * warInfo.cost); // 扣除体力
        if(!apJson) {
            return { code: 202, data: '体力不足' }
        }

        let channelService = this.app.get('channelService');

        let dailyNum = {};
        let towerRec = null;
        let towerBonus = null;
        let towerStatus = null;
        let towerReward = null;
        if(warInfo.warType == WAR_TYPE.DAILY) {
            let checkResult = await checkDailyAndIncrease(roleId, battleId, 1, false);
            if(checkResult.status == -1) {
                return {code: 202, data: checkResult.msg}
            }
            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
        } else if (warInfo.warType == WAR_TYPE.EVENT) { 
            // 记录事件状态
            await setBattleStatus(this.app, session, roleId, battleId, isSuccess, battleCode);
        } else if (warInfo.warType == WAR_TYPE.TOWER) {
            let towerEndResult = await towerBattleEnd(channelService, sid, roleId, battleCode, battleId, isSuccess, heroes);
            if(towerEndResult.status == -1) {
                return {code: 202, data: towerEndResult.msg};
            }
            towerRec = towerEndResult.data.newRec;
            towerBonus = towerEndResult.data.bonusReward;
            towerStatus = towerEndResult.data.towerStatus;
            towerReward = towerEndResult.data.towerReward;
        }

        let warReward = new WarReward(roleId, roleName, battleId, isSuccess);

        if(isSuccess) { // 挑战胜利
            // 是否首通
            let condition1 = await BattleRecordModel.getBattleRecordByIdAndStatus(roleId, battleId, 1);
            if(!condition1) warReward.setCondition(0, true);
            // 是否首次3星
            if(star == 3) {
                let condition2 = await BattleRecordModel.getBattleRecordByIdAndStar(roleId, battleId, 3);
                if(!condition2) warReward.setCondition(1, true);
            }
        }

        let reward = await warReward.saveReward(1);

        const updateResult = await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: { status: isSuccess?1:2, star, record: { heroes } }
        }, true);
        let { status } = updateResult;

        // 主线关卡某个关卡触发事件开启
        let eventStatus = session.get('eventStatus')||0;
        if(battleId == EVENT_START_BATTLE && eventStatus == 0) {
            // console.log('*******startEvent')
            await startEvent(this.app, session);
        }
        // 返回值：
        // towerStatus: false-本层未通过, true-本层已通过
        // towerBonus: 天梯每隔几层的额外宝箱
        return {
            code: 200,
            data: {
                battleCode, battleId, status, towerStatus,
                goods: reward, towerBonus, towerReward,
                apJson,
                dailyNum
            }
        }
    }

    async battleSweep(msg: {battleId: number, count: number }, session: BackendSession) {
        
        const { battleId, count } = msg;
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let warInfo = getWarById(battleId);
        if(!warInfo) {
            return { code: 202, data: "缺少关卡信息" }
        }
        // 校验是否三星通关过
        let condition1 = await BattleRecordModel.getBattleRecordByIdAndStar(roleId, battleId, 3);
        if(!condition1) {
            return { code: 202, data: "需要3星通过关卡才可以扫荡" }
        }

        // 扣体力
        if(!warInfo.hasOwnProperty('cost')) {
            warInfo['cost'] = 0;
        }
        const now = Date.now(); // 当前时间戳
        let apJson = await setAp(now, roleId, -1 * warInfo.cost * count); // 扣除体力
        if(!apJson) {
            return { code: 202, data: '体力不足' }
        }

        // 扫荡次数
        let dailyNum = {};
        if(warInfo.warType == WAR_TYPE.DAILY) {
            let checkResult = await checkDailyAndIncrease(roleId, battleId, count, true);
            if(checkResult.status == -1) {
                return {code: 202, data: checkResult.msg}
            }
            dailyNum = { type: checkResult.type, count: checkResult.count, sum: checkResult.sum };
        }

        // 发奖励
        let warReward = new WarReward(roleId, roleName, battleId, true);
        let result = await warReward.saveReward(count);

        // 扫荡记录
        await BattleSweepRecordModel.saveBattleSweepRecordById(roleId, battleId, {
            $set: {
                roleName, 
                warName: warInfo.gk_name,
                warType: warInfo.warType
            },
            $inc: { count }
        });

        return {
            code: 200,
            data: {
                battleId, count,
                goods: result,
                apJson,
                dailyNum
            }
        }
    }

}