import { Application, BackendSession, ChannelService, HandlerService, pinus } from "pinus";
import { GVG_ITEM, DATA_NAME, GVG_ACTIVE_TYPE, GVG_PERIOD, GVG_SERVER_TYPE, ITEM_CHANGE_REASON, LEAGUE_JOB, LEAGUE_MANAGE_TYPE, STATUS } from "../../../consts";
import { GVGLeagueModel } from "../../../db/GVGLeague";
import { GVGLeaguePrepareModel } from "../../../db/GVGLeaguePrepare";
import { GVGMainData, LeagueDistributeInfo, LeagueMemberDistributeInfo, LeagueMemberListInfo } from "../../../domain/gvgField/returnData";
import { resResult } from "../../../pubUtils/util";
import { calLeagueCe, getGVGConfig, getGVGPeriodData, getGVGServerType } from "../../../services/gvg/gvgService";
import { autoCreateLeague, checkCanChooseJob, checkCanPrepare, checkLeagueAuth, getMyAuth } from "../../../services/gvg/gvgTeamService";
import { getAllServerName } from "../../../services/redisService";
import { Distribute, GVGUserDataModel } from "../../../db/GVGUserData";
import { GVGUserItemModel } from "../../../db/GVGUserItem";
import { GVGUserTaskModel } from "../../../db/GVGUserTask";
import { GVG } from "../../../pubUtils/dicParam";
import { RoleModel } from "../../../db/Role";
import { addGVGTechActive, calProduce, checkPreTech, checkTechIsIng, getDailyLoginReward, getMyDistribute } from "../../../services/gvg/gvgPrepareService";
import { GVGUserDailyDataModel } from "../../../db/GVGUserDailyData";
import { gameData } from "../../../pubUtils/data";
import { lockLeagueData } from "../../../services/redLockService";
import { addGVGReward, handleGVGCost } from "../../../services/gvg/gvgItemService";
import { RewardInter } from "../../../pubUtils/interface";
import { getGVGCities } from "../../../services/gvg/gvgBattleService";

export default function (app: Application) {
    new HandlerService(app, {});
    return new GVGHandler(app);
}

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

    // 测试
    async getData(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const serverId = session.get('serverId');
        const guildCode = session.get('guildCode');
        const sid = session.get('sid');

        let { configId, period, countdownTime } = getGVGPeriodData();
        let serverType = await getGVGServerType(serverId);
        if(serverType == GVG_SERVER_TYPE.NO) return resResult(STATUS.GVG_NO_SERVER_TYPE);

        let data = new GVGMainData(configId, period, countdownTime, serverType);

        let serverNames = await getAllServerName();
        let league = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!league) {
            league = await autoCreateLeague(guildCode);
        }
        if(league) {
            data.setLeague(league, serverNames);
        
            let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, league.leagueCode);
            data.setLeagueParpare(leaguePrepare);
            
            let userData = await GVGUserDataModel.findByRole(configId, league.leagueCode, roleId);
            let items = await GVGUserItemModel.findByRole(configId, league.leagueCode, roleId);
            let tasks = await GVGUserTaskModel.findByRole(configId, league.leagueCode, roleId);
            data.setPlayerInfo(userData, getMyAuth(league, roleId), await checkCanPrepare(roleId), checkCanChooseJob(userData?.job, leaguePrepare), items, tasks);

            let dailyReward = await getDailyLoginReward(roleId, roleName, sid, league.leagueCode, userData?.job);
            if(dailyReward) data.setFistLogin(dailyReward.reward);

            data.setLeagueCe(await calLeagueCe(league));

            let cities = await getGVGCities(league);
            data.setCities(cities);
        }

        return resResult(STATUS.SUCCESS, data)
    }

    // TODO 获取动态
    async getRec(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        return resResult(STATUS.SUCCESS, { recs: [] });
    }

    // 选择职能
    async chooseJob(msg: { job: number }, session: BackendSession) {
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const sid = session.get('sid');
        const guildCode = session.get('guildCode');
        const { job } = msg;

        let { configId, period } = getGVGPeriodData();
        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

        // 是否已经选过
        let myUserData = await GVGUserDataModel.findByRole(configId, myLeague.leagueCode, roleId);
        if(myUserData && myUserData.job) return resResult(STATUS.GVG_HAS_CHOOSE_JOB); 

        let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
        if(!leaguePrepare) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        // 是否超过人数
        let limit = Math.floor(leaguePrepare.maxMemberCnt * GVG.GVG_ROLE_TOTAL_RATIO);
        if(leaguePrepare.fighterCnt + leaguePrepare.producerCnt >= limit) return resResult(STATUS.GVG_JOB_LIMIT);
        let cnt = job == LEAGUE_JOB.FIGHTER? leaguePrepare.fighterCnt: leaguePrepare.producerCnt;
        if(cnt >= Math.floor(limit * GVG.GVG_ROLE_RATIO / 2)) return resResult(STATUS.GVG_JOB_LIMIT);

        // 更新userData
        myUserData = await GVGUserDataModel.chooseJob(configId, myLeague.leagueCode, roleId, job);
        // 更新prepare
        leaguePrepare = await GVGLeaguePrepareModel.chooseJob(configId, myLeague.leagueCode, job);
        let dailyReward = await getDailyLoginReward(roleId, roleName, sid, myLeague.leagueCode, myUserData?.job);

        return resResult(STATUS.SUCCESS, {
            leagueCode: myLeague.leagueCode,
            job: myUserData.job,
            producerCnt: leaguePrepare.producerCnt,
            fighterCnt: leaguePrepare.fighterCnt,
            leagueGoods: dailyReward? dailyReward.reward: []
         });
    }

    // 查看贡献
    async getDistribute(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const guildCode = session.get('guildCode');

        let { configId, period } = getGVGPeriodData();
        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

        const members = myLeague.members||[];
        const roleIds = members.map(member => member.roleId);
        const roles = await RoleModel.findByRoleIds(roleIds);
        const serverNames = await getAllServerName();

        const myUserData = await GVGUserDataModel.findByRole(configId, myLeague.leagueCode, roleId);
        const { distribute = new Distribute(), box = [] } = myUserData||{};
        const userDatas = await GVGUserDataModel.findByRoles(configId, myLeague.leagueCode, roleIds);

        const result: LeagueDistributeInfo[] = [];
        for(let curJob of [LEAGUE_JOB.PRODUCER, LEAGUE_JOB.FIGHTER]) {
            const memberResult: LeagueMemberDistributeInfo[] = [];
            for(let member of members) {
                let role = roles.find(role => role.roleId == member.roleId);
                if(!role) continue;
                let userData = userDatas.find(userData => userData.roleId == member.roleId);
                let obj = new LeagueMemberDistributeInfo(role, serverNames);
                obj.setByUserData(userData);
                if(curJob == LEAGUE_JOB.PRODUCER && calProduce(obj) > 0) memberResult.push(obj);
                if(curJob == LEAGUE_JOB.FIGHTER && obj.score > 0) memberResult.push(obj);
            }

            memberResult.sort((a, b) => {
                return curJob == LEAGUE_JOB.PRODUCER? calProduce(b) - calProduce(a): b.score - a.score;
            });
            let sumDistribute = curJob == LEAGUE_JOB.FIGHTER? calProduce(distribute): distribute.score; 
            let curBox = box.find(cur => cur.job == curJob);
            let disObj = new LeagueDistributeInfo(curJob, sumDistribute, curBox?.received||[] );
            disObj.setMembers(memberResult);
            result.push(disObj)
        }

        const userDailyData = await GVGUserDailyDataModel.findByRole(configId, myLeague.leagueCode, roleId);

        return resResult(STATUS.SUCCESS, {
            myDistribute: getMyDistribute(userDailyData),
            list: result
         });
    }

    // 千机阁数据
    async getTech(msg: {}, session: BackendSession) {
        const roleId = session.get('roleId');
        const guildCode = session.get('guildCode');

        let { configId, period } = getGVGPeriodData();
        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
        const leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);

        return resResult(STATUS.SUCCESS, {
            activeTech: leaguePrepare?.activeTech||[],
            queue: leaguePrepare?.techQueue||[]
         });
    }

    // 千机阁解锁
    async unlockTech(msg: { techId: number }, session: BackendSession) {
        const roleId = session.get('roleId');
        const guildCode = session.get('guildCode');
        const { techId } = msg;

        let { configId, period } = getGVGPeriodData();
        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        const dicTech = gameData.gvgTech.get(techId);
        if(!dicTech) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

        // 权限
        const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.UNLOCK_TECH);
        if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);

        // 并发锁
        let res: any = await lockLeagueData(DATA_NAME.LEAGUE_TECH, myLeague.leagueCode);//加锁
        if (!!res.err) return resResult(STATUS.REDLOCK_ERR);

        let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
        if(!leaguePrepare || leaguePrepare.lv < dicTech.levelLimit) {
            res.releaseCallback();
            return resResult(STATUS.GVG_TECH_LV_NOT_ENOUGH);
        }

        if(checkTechIsIng(techId, leaguePrepare?.activeTech||[], leaguePrepare?.techQueue||[])) {
            res.releaseCallback();
            return resResult(STATUS.GVG_TECH_HAS_UNLOCKED);
        }

        if(!checkPreTech(techId, leaguePrepare?.activeTech||[], leaguePrepare?.techQueue||[])) {
            res.releaseCallback();
            return resResult(STATUS.GVG_TECH_PRE_POSITION_NOT_UNLOCK);
        }

        leaguePrepare = await GVGLeaguePrepareModel.unlockTech(configId, myLeague.leagueCode, techId, dicTech.consume);
        if(!leaguePrepare) {
            res.releaseCallback();
            return resResult(STATUS.GVG_TECH_QUEUECNT_MAX);
        }

        res.releaseCallback();
        return resResult(STATUS.SUCCESS, {
            queue: leaguePrepare?.techQueue||[]
         });
    }

    // 千机阁解锁
    async activate(msg: { techId: number, battleFeats: number }, session: BackendSession) {
        const roleId = session.get('roleId');
        const guildCode = session.get('guildCode');
        const sid = session.get('sid');
        const { techId, battleFeats } = msg;

        let { configId, period } = getGVGPeriodData();
        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);

        const dicTech = gameData.gvgTech.get(techId);
        if(!dicTech) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        const myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

        // 权限
        const checkAuth = await checkLeagueAuth(roleId, myLeague, LEAGUE_MANAGE_TYPE.ACTIVATE_TECH);
        if(!checkAuth) return resResult(STATUS.GVG_HAS_NO_AUTH);

        let leaguePrepare = await GVGLeaguePrepareModel.findByLeague(configId, myLeague.leagueCode);
        if(!checkTechIsIng(techId, [], leaguePrepare?.techQueue||[])) {
            return resResult(STATUS.GVG_TECH_NOT_QUEUE);
        }

        // 扣战功
        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, [{ id: GVG_ITEM.BATTLE_FEAT, count: battleFeats }], [], ITEM_CHANGE_REASON.GVG_ACTIVE_TECH);
        if(!costResult) return resResult(STATUS.GVG_BATTLE_FEAT_NOT_ENOUGH);

        leaguePrepare = await GVGLeaguePrepareModel.addProgress(configId, myLeague.leagueCode, techId, battleFeats);
        if(!leaguePrepare) {
            return resResult(STATUS.GVG_TECH_NOT_QUEUE);
        }
        let curQueue = leaguePrepare.techQueue.find(cur => cur.id == techId);
        if(curQueue.progress >= curQueue.maxProgress) {
            leaguePrepare = await GVGLeaguePrepareModel.activate(configId, myLeague.leagueCode, techId);
        }

        // 添加 活跃
        let active = await addGVGTechActive(myLeague.leagueCode, roleId);

        return resResult(STATUS.SUCCESS, {
            active,
            activeTech: leaguePrepare?.activeTech||[],
            queue: leaguePrepare?.techQueue||[]
         });
    }

    // 获取道具
    async debugAddLeagueItem(msg: { id: number, count: number }, session: BackendSession) {
        const roleId = session.get('roleId');
        const roleName = session.get('roleName');
        const sid = session.get('sid');
        const guildCode = session.get('guildCode');
        const { id, count } = msg;
        let dicGVGItem = gameData.gvgItem.get(id);
        if(!dicGVGItem) return resResult(STATUS.DIC_DATA_NOT_FOUND);

        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
        const leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, [{ id, count }], [], ITEM_CHANGE_REASON.DEBUG);

        return resResult(STATUS.SUCCESS, { leagueGoods });
    }

    async debugHandleCost(msg: { items: RewardInter[], leagueItems: RewardInter[] }, session: BackendSession) {
        const roleId = session.get('roleId');
        const guildCode = session.get('guildCode');
        const sid = session.get('sid');
        const { items, leagueItems } = msg;

        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);

        const result = await handleGVGCost(roleId, myLeague.leagueCode, sid, leagueItems, items, ITEM_CHANGE_REASON.DEBUG);
        return resResult(STATUS.SUCCESS, { result });
    }
}