import { Application, BackendSession, ChannelService, pinus } from "pinus";
import { getMedianCe, getGuildActivityStatus, getRecordScore, getGateActivityObj, sendSingleGateActEndMsg, participants, getGateActivityRank, getCityActivityObj } from "../../../services/guildActivityService";
import { resResult } from "../../../pubUtils/util";
import { STATUS, GUILD_ACTIVITY_TYPE, GUILD_POINT_WAYS, ENEMIES_TYPE, GET_POINT_WAYS } from "../../../consts";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { GUILDACTIVITY } from "../../../pubUtils/dicParam";
import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { RoleModel, RoleType } from "../../../db/Role";
import { GuildModel } from "../../../db/Guild";
import { RankParam, GuildRankParam } from "../../../domain/rank";
import { setRank, getGuildKeyName, getRankScore, setUserGuildActivityRank, delGuildActivityRank } from "../../../services/redisService";
import { REDIS_KEY } from "../../../consts";
import { addActive } from "../../../services/guildService";
import { gameData } from "../../../pubUtils/data";
import { getGuildChannelSid } from "../../../services/chatService";
import { guildActivityStart, gateActivityEnd, cityActivityEnd } from "../../../services/timeTaskService";
import { UserGuildModel } from "../../../db/UserGuild";

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

export class GateActivityHandler {
    channelService: ChannelService;
    constructor(private app: Application) {
        this.channelService = app.get('channelService');
    }

    private aid = GUILD_ACTIVITY_TYPE.GATE_ACTIVITY; // 蛮夷入侵id

    // 进入蛮夷入侵界面
    async getGateActivity(msg: {}, session: BackendSession) {

        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const serverId = session.get('serverId');
        const guildCode = session.get('guildCode');
        if(!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);

        let statusResult = getGuildActivityStatus(this.aid);
        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
        if(!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);

        let { code: sourceCode } = guildActivityRec;
        let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
        let { challengeCnt } = myGuildActivityRec; 

        let ranks = await getGateActivityRank(guildCode, serverId, roleId, roleName);

        let obj = getGateActivityObj();
        let gateHp = obj.getGateHpAndInc(guildCode);
        return resResult(STATUS.SUCCESS, {
            ...statusResult,
            challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
            gateHp,
            ...ranks
        });
    }

    // 开启挑战
    async checkBattle(msg: { heroes: number[] }, session: BackendSession) {
        let { heroes } = msg;
        if(!heroes || heroes.length <= 0) return resResult(STATUS.WRONG_PARMS);

        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const serverId = session.get('serverId');
        const guildCode = session.get('guildCode');
        if(!guildCode) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
        let obj = getGateActivityObj();

        let gateHp = obj.getGateHpAndInc(guildCode);
        if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);

        let statusResult = getGuildActivityStatus(this.aid);
        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        // TODO 测试完成后去掉这条判断
        // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);

        let userGuild = await UserGuildModel.getMyGuild(roleId, 'job');

        let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
        if(!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);

        let { code: sourceCode } = guildActivityRec;
        let myGuildActivityRec = await UserGuildActivityRecModel.getRecord(roleId, roleName, guildCode, serverId, sourceCode, this.aid);
        if(myGuildActivityRec.challengeCnt > 0) {
            return resResult(STATUS.CHALLENGE_CNT_NOT_ENOUGH);
        }
        myGuildActivityRec = await UserGuildActivityRecModel.incChallengeCnt(myGuildActivityRec.code, heroes);
        let { code, challengeCnt } = myGuildActivityRec; 

        // 更新公会参与的玩家
        obj.pushMembers(guildCode, serverId, roleId, userGuild.job);

        // 返回当前军团总军功
        let guildScore = await getRankScore(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);

        // 前一天中位数战力
        let medianCe = await getMedianCe(serverId);
        
        return resResult(STATUS.SUCCESS, {
            code,
            ...statusResult,
            guildScore: guildScore||0,
            myScore: 0,
            gateHp,
            challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - challengeCnt,
            medianCe
        });
    }

    // 上报玩家获得军功
    async action(msg: { code: string, round: number, record: { round: number, dataId: number }[] }, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let guildCode = session.get('guildCode');
        let serverId = session.get('serverId');

        let { code, round, record } = msg;
        let obj = getGateActivityObj();

        let statusResult = getGuildActivityStatus(this.aid);
        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        // TODO 测试完成后去掉这条判断
        // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);

        let gateHp = obj.getGateHpAndInc(guildCode);
        if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);

        // 计算record内得分
        let memberRecord = obj.getMemberRecord(code, roleId);
        let scoreResult = getRecordScore(this.aid, round, record, memberRecord);
        if(!scoreResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        let { score, newRecords, memberRecord: newMemberRecord } = scoreResult;
        obj.setMemberRecord(code, newMemberRecord);

        // 更新redis数据
        let role = await RoleModel.findByRoleId(roleId);
        let { lv, vLv, head, frame, spine, title } = role;
        let userParam = new RankParam(roleName, lv, vLv, head, frame, spine, title);
        let myScore = await setUserGuildActivityRank(REDIS_KEY.USER_GATE_ACTIVITY, guildCode, serverId, roleId, score, Date.now(), userParam);

        let guild = await GuildModel.findByCode(guildCode, serverId);
        let leader = <RoleType>guild.leader;
        let params = new GuildRankParam(guild.icon, guild.name, guild.lv, leader);
        let guildScore = await setRank(REDIS_KEY.GATE_ACTIVITY, serverId, guild.code, score, Date.now(), params, true);
        
        // 更新数据库
        let rec = await UserGuildActivityRecModel.pushRecord(code, newRecords, round);

        return resResult(STATUS.SUCCESS, {
            code: rec.code,
            ...statusResult,
            guildScore: guildScore||0,
            myScore: myScore||0,
            gateHp
        });
    }

    // 上报敌军攻打城门情况
    async hitGate(msg: { code: string, damage: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let guildCode = session.get('guildCode');
        let serverId = session.get('serverId');

        let { code, damage } = msg;
        let obj = getGateActivityObj();
        let gateHp = obj.getGateHpAndInc(guildCode);
        if(gateHp <= 0) return resResult(STATUS.GATE_HP_IS_ZERO);

        let statusResult = getGuildActivityStatus(this.aid);
        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);
        // TODO 测试完成后去掉这条判断
        // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);

        gateHp = obj.getGateHpAndInc(guildCode, -1 * damage);
        if(gateHp <= 0) {
            // 推送 停止活动并结算奖励
            await sendSingleGateActEndMsg(guildCode, serverId);
        }
        // 推送 城门血量
        let chatSid = await getGuildChannelSid(guildCode);
        pinus.app.rpc.chat.guildRemote.pushGateHp.toServer(chatSid, guildCode, gateHp);

        // 返回当前军团总军功
        let guildScore = await getRankScore(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);
        let myScore = await getRankScore(getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode), serverId, roleId, true);
        
        return resResult(STATUS.SUCCESS, {
            code,
            ...statusResult,
            guildScore,
            myScore,
            gateHp
        })
    }

    // 结束挑战
    async battleEnd(msg: { code: string, isSuccess: boolean }, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let guildCode = session.get('guildCode');
        let serverId = session.get('serverId');

        let { code, isSuccess } = msg;
        let obj = getGateActivityObj();
        
        let statusResult = getGuildActivityStatus(this.aid);
        if(!statusResult) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        // 更新userGuildActivityRecord
        let myGuildActivityRec = await UserGuildActivityRecModel.updateInfo(code, { isSuccess, isCompleted: true });
        if(!myGuildActivityRec) return resResult(STATUS.INTERNAL_ERR);

        // 功劳簿计算
        let { record, round } = myGuildActivityRec;
        let enemyCnt = 0, littleBossCnt = 0, bossCnt = 0;
        for(let { enemyType, round: r } of record) {
            if(enemyType == ENEMIES_TYPE.ENEMY || enemyType == ENEMIES_TYPE.ELITE_ENEMY ) {
                enemyCnt ++;
            } else if (enemyType == ENEMIES_TYPE.LITTLE_BOSS) {
                littleBossCnt ++;
            } else if (enemyType == ENEMIES_TYPE.BOSS) {
                bossCnt ++;
            }
        }

        if(isSuccess) {
            let score = gameData.gateActivityPoint.get(GET_POINT_WAYS.DEFENSE_SUCCESS);
            // 更新redis数据
            let role = await RoleModel.findByRoleId(roleId);
            let { lv, vLv, head, frame, spine, title } = role;
            let userParam = new RankParam(roleName, lv, vLv, head, frame, spine, title);
            await setUserGuildActivityRank(REDIS_KEY.USER_GATE_ACTIVITY, guildCode, serverId, roleId, score, Date.now(), userParam);

            let guild = await GuildModel.findByCode(guildCode, serverId);
            let leader = <RoleType>guild.leader;
            let params = new GuildRankParam(guild.icon, guild.name, guild.lv, leader);
            await setRank(REDIS_KEY.GATE_ACTIVITY, serverId, guild.code, score, Date.now(), params, true);    
        }

        // 发放活跃
        await addActive(roleId, serverId, GUILD_POINT_WAYS.ACTIVITY);  //获得活跃值
        // 返回当前军团总军功
        let guildScore = await getRankScore(REDIS_KEY.GATE_ACTIVITY, serverId, guildCode);
        let myScore = await getRankScore(getGuildKeyName(REDIS_KEY.USER_GATE_ACTIVITY, guildCode), serverId, roleId, true);
        let gateHp = obj.getGateHpAndInc(guildCode);

        obj.delMemberRecord(code);
        let info = {
            round,
            enemyCnt, littleBossCnt, bossCnt, 
            isSuccess
        }

        return resResult(STATUS.SUCCESS, {
            code,
            ...statusResult,
            guildScore,
            myScore,
            gateHp,
            info
        })
    }

    // ! 测试接口
    async debugGetPrivate(msg: { }, session: BackendSession) {
        let guildCode = session.get('guildCode');
        console.log(guildCode);
        let serverId = session.get('serverId');
        let res = getGateActivityObj().getObj(guildCode, serverId);
        return resResult(STATUS.SUCCESS, res)
    }

    // ! 测试接口
    async test(msg: { sourceType: number, sourceCode: string }, session: BackendSession) {
        let guildCode = session.get('guildCode');
        let serverId = session.get('serverId');

        // await GuildActivityCityModel.declare(serverId, 1, guildCode);
        let {sourceType, sourceCode} = msg;
        let result = await participants(guildCode, sourceType, sourceCode);
        return result;

        // let result = await setMedianCe();
        // return resResult(STATUS.SUCCESS, {result});
    }

    // ! 测试接口
    async debugIncChallengeCnt(msg: {  }, session: BackendSession) {
        let roleId = session.get('roleId');
        let res = await UserGuildActivityRecModel.updateInfoByRoleId(roleId, { challengeCnt: -100 });

        return resResult(STATUS.SUCCESS, { challengeCnt: GUILDACTIVITY.GATEACTIVITY_CHALLENGE_TIMES - (res?.challengeCnt||0) });
    }

    // ! 测试接口
    async debugStartActivity(msg: { aid: number }, session: BackendSession) {
        let { aid } = msg;
        let dic = gameData.guildActivity.get(aid);
        let result = await pinus.app.rpc.systimer.systimerRemote.guildActivityStart.toServer('systimer-server-1', dic);
        if(!result) {
            return resResult(STATUS.GUILD_ACTIVITY_IS_OPEN)
        }

        return resResult(STATUS.SUCCESS);
    }

    // ! 测试接口
    async debugEndActivity(msg: { aid: number }, session: BackendSession) {
        let { aid } = msg;
        if(aid == GUILD_ACTIVITY_TYPE.GATE_ACTIVITY) {
            await pinus.app.rpc.systimer.systimerRemote.gateActivityEnd.toServer('systimer-server-1');
        } else if (aid == GUILD_ACTIVITY_TYPE.CITY_ACTIVITY) {
            await pinus.app.rpc.systimer.systimerRemote.cityActivityEnd.toServer('systimer-server-1');
        } else if (aid == GUILD_ACTIVITY_TYPE.RACE_ACTIVITY) {
            await pinus.app.rpc.systimer.systimerRemote.raceActivityEnd.toServer('systimer-server-1');
        }
        return resResult(STATUS.SUCCESS);
    }

    async debugDelRedis(msg: { aid: number }, session: BackendSession) {
        let { aid } = msg;

        let map = new Map<number, string[]>();
        let guilds = await GuildModel.findAllGuild('serverId code');
        for(let { serverId, code } of guilds) {
            if(map.has(serverId)) {
                map.get(serverId).push(code);
            } else {
                map.set(serverId, [code]);
            }
        }
        await delGuildActivityRank(aid, map);
    }

    // ! 测试接口 将自己添加进活动roleId里
    async debugAddParticipants(msg: { aid: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let guildCode = session.get('guildCode');
        if(!guildCode) return resResult(STATUS.GUILD_NOT_FOUND);
        let serverId = session.get('serverId');
        let { aid } = msg;
        await GuildActivityRecordModel.getRecord(guildCode, serverId, aid);
        let userGuild = await UserGuildModel.getMyGuild(roleId);
        let result = await GuildActivityRecordModel.updateInfo(guildCode, { memberCnt: 1, members: [{ roleId, job: userGuild.job }], auctionType: aid + 1 });
        
        return resResult(STATUS.SUCCESS, {
            sourceType: result.auctionType,
            sourceCode: result.code
        });
    }
}