import { Application, BackendSession, pinus } from 'pinus';
import { resResult, genCode } from '../../../pubUtils/util';
import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB } from '../../../consts';
import { GuildTrainModel } from '../../../db/GuildTrain';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { nowSeconds, getTodayZeroPoint } from '../../../pubUtils/timeUtil';
import { getUserGuild, getGuildTrainInfo } from '../../../services/guildTrainService';
import { findIndex, findWhere, indexBy } from 'underscore'
import { lockData } from '../../../services/redlockService'; 
import { GUILD_DATA_NAME } from '../../../consts/constModules/guildConst';
import { UserGuildModel } from '../../../db/UserGuild'; 
export default function (app: Application) {
    return new GuildTrainHandler(app);
}

export class GuildTrainHandler {
    constructor(private app: Application) {

    }

    async getTrainScript(msg: { code: string }, session: BackendSession) {
        const { code } = msg;
        const roleId = session.get('roleId');
        let guildTrains = await GuildTrainModel.findGuildTrain(code);
        let userGuild = await getUserGuild(roleId, code);
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS);
        if (!guildTrains) 
            guildTrains = []; 
        let { trainCount, trainRewards } = userGuild;
        let result = getGuildTrainInfo(guildTrains, roleId, trainCount, trainRewards);
        return resResult(STATUS.SUCCESS, result);
    }

    async trainScriptStart(msg: { code: string, trainId: number, hid: number }, session: BackendSession) {
        const { code, trainId, hid } = msg;
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        let userGuild = await getUserGuild(roleId, code);
        if (!userGuild)
            return resResult(STATUS.WRONG_PARMS);
        if (userGuild.trainCount > 2) //TODO检查次数
            return resResult(STATUS.GUILD_TRAIN_BATTLE_COUNT_NOT_ENOUGH);
        let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
        if (!guildTrain) 
            return resResult(STATUS.GUILD_TRAIN_SCRIPT_NOT_OPENED);
        let trainScript = findWhere(guildTrain.trainScripts, { hid });
        if (!trainScript) 
            return resResult(STATUS.WRONG_PARMS); 
        //TODO 判断是否压制成功
        if (trainScript.progress >= 1000) {
            return resResult(STATUS.GUILD_TRAIN_IS_COMPLETE); 
        } 
        const battleCode = genCode(8); // 关卡唯一值
        //TODO查看地图字典
        let warInfo;
        let warId;
        await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: {
                roleId, roleName, battleId: warId,
                status: 0,
                warName: warInfo.gk_name,
                warType: warInfo.warType,
                record: { heroes:[], trainId, hid},
            }
        }, true);      
        return resResult(STATUS.SUCCESS, { battleCode });
    }

    async trainScriptEnd(msg: { code: string, battleCode: string, isSuccess: boolean}, session: BackendSession) {
        const { code, battleCode, isSuccess} = msg;
        const roleId = session.get('roleId');
        const serverId = session.get('serverId');
        const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
        if(!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {
            return resResult(STATUS.WRONG_PARMS);
        } 
        let userGuild = await getUserGuild(roleId, code);
        if (!userGuild) 
            return resResult(STATUS.WRONG_PARMS);
        let time = battleRecord.createdAt.getTime()/1000;
        if (time > getTodayZeroPoint()) {
            if (userGuild.trainTime > getTodayZeroPoint()) {
                userGuild = await UserGuildModel.updateInfo(roleId, {trainCount: userGuild.trainCount + 1});
            } else {
                userGuild = await UserGuildModel.updateInfo(roleId, {trainCount: 1, trainTime: nowSeconds()});
            } 
        }
        await BattleRecordModel.updateBattleRecordByCode(battleCode, {
            $set: { status: isSuccess?1:2 }
        }, true);
       
        let trainId = battleRecord.record.trainId;
        let hid = battleRecord.record.hid;
        let res:any = await lockData(serverId, GUILD_DATA_NAME.TRAIN, code + '_' + trainId);//加锁
        if (!!res.err) 
            return true;
        let guildTrain = await GuildTrainModel.findTrainByTrainIdNotLock(code, trainId);
        if (!guildTrain) {
            res.releaseCallback();//解锁
            return resResult(STATUS.GUILD_TRAIN_SCRIPT_NOT_OPENED);
        }
        let trainScript = findWhere(guildTrain.trainScripts,{hid});
        if (!trainScript) 
            return resResult(STATUS.WRONG_PARMS); 
        let addScore;
        //结算奖励 TODO


        //是否压制
        let { isComplete, reports, ranks } = guildTrain;
        let index = findIndex(ranks, {roleId});
        if (index !== -1) {
            ranks[index].score +=  addScore;
        }
        let report = {roleId, trainId, hid, score: addScore, time: nowSeconds(), isSuccessed: isSuccess, type: 1};//1表示普通战报， 2表示系统战报即：被成功压制
        if (trainScript.progress < 1000 ) {
            if (trainScript.progress + addScore >= 1000) {
                reports.push(...[{isSuccessed: true, type: 2, time:nowSeconds(), score: addScore, roleId, trainId, hid},report]);
                await GuildTrainModel.updateGuildTrain(code, trainId, {reports, ranks});
                let needLockNext = false;
                if (!isComplete) {
                    isComplete = true;
                    guildTrain.trainScripts.forEach(({hid: otherHid, progress})=>{
                        if (hid != otherHid && progress == 1000) {
                            isComplete = false;
                        }
                    });
                    if (isComplete) {//解锁下一关
                        needLockNext = true;
                    }
                }
                let progress = 1000;
                GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
                if (needLockNext) {

                }
                res.releaseCallback();//解锁
            } else {
                let progress = trainScript.progress + addScore;
                GuildTrainModel.updateGuildTrainProgress(code, trainId, hid, progress, ranks, reports, isComplete);
                res.releaseCallback();//解锁
            }
        } else {
            reports.push(report);
            GuildTrainModel.updateGuildTrain(code, trainId, {reports, ranks});
            res.releaseCallback();//解锁
        }
        let guildTrains = await GuildTrainModel.findGuildTrain(code);
        if (!guildTrains) 
            guildTrains = []; 
        let { trainCount, trainRewards } = userGuild;
        let result = getGuildTrainInfo(guildTrains, roleId, trainCount, trainRewards);
        return resResult(STATUS.SUCCESS, result);
    }
   
    async getTrainScriptBox(msg: { code: string }, session: BackendSession) {
        
    }

    async getTrainLvUpRewards(msg: { trainId: number }, session: BackendSession) {
        
    }
}