import { Application, BackendSession } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, REDIS_KEY, RANK_TYPE_TO_KEY, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT } from "../../../consts";
import { RoleModel } from "../../../db/Role";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildModel } from "../../../db/Guild";
import { UserModel } from "../../../db/User";
import { Rank } from "../../../services/rankService";
import { nowSeconds } from "../../../pubUtils/timeUtil";
import { GeneralRankParamRole, GeneralRankParamBattle, RoleRankInfo } from "../../../domain/rank";
import { gameData } from "../../../pubUtils/data";
import { addItems } from "../../../services/rewardService";
import { HeroModel, HeroUpdate } from "../../../db/Hero";

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

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

    async getGeneralRank(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
        let roleName = session.get('roleName');
        let serverId = session.get('serverId');

        let role = await RoleModel.findByRoleId(roleId, 'rankReceived');
        if(!role) return resResult(STATUS.WRONG_PARMS);

        let { rankReceived = []} = role;

        let res = {
            role: new Array<GeneralRankParamRole>(),
            battle: new Array<GeneralRankParamBattle>()
        };

        for(let { id, general } of gameData.rank) {
            let redisKey = RANK_TYPE_TO_KEY.get(id);
            if(redisKey) {
                let received = rankReceived.filter(rewardId => {
                    let dic = gameData.generalRankReward.get(rewardId);
                    return dic && dic.rankId == id;
                });
                if(general == 1) {
                    let r = new Rank(redisKey, { serverId }, false, 1);
                    let ranks = <RoleRankInfo[]> await r.getRankByRange();
                    if(ranks.length > 0) {
                        let param = new GeneralRankParamRole(id, ranks[0]||new RoleRankInfo({}, false), received);
                        res.role.push(param);
                    }
                } else if (general = 2) {
                    let r = new Rank(redisKey, { serverId }, false, 1);
                    let ranks = <RoleRankInfo[]> await r.getRankByRange();
                    let hero: HeroUpdate;
                    if(ranks.length > 0) {
                        hero = await HeroModel.getMyTopHero(ranks[0].roleId, 'hid skins');
                        let param = new GeneralRankParamBattle(id, ranks[0]||new RoleRankInfo({}, false), hero, received);
                        res.battle.push(param);
                    }
                }
            }
        }

        return resResult(STATUS.SUCCESS, res);
    }

    async getRank(msg: { type: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let serverId = session.get('serverId');

        let { type } = msg;
        let redisKey = RANK_TYPE_TO_KEY.get(type);
        if(!redisKey) return resResult(STATUS.WRONG_PARMS);
        let r = new Rank(redisKey, { serverId });

        let { ranks, myRank } = await r.getRankListWithMyRank({roleId});
        if(!myRank) {
            let role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            if(type == RANK_TYPE.TOP_LINTUP) {
                myRank = await r.generMyRankWithRole(roleId, role.topLineupCe, 0, role);
            } else if (type == RANK_TYPE.TOP_HERO) {
                let hero = await HeroModel.getMyTopHero(roleId, HERO_SELECT.RANK_LINEUP);
                myRank = await r.generMyRankWithHero(roleId, hero.hid, hero.ce, 0, hero, role);
            } else if (type == RANK_TYPE.HERO_NUM) {
                myRank = await r.generMyRankWithRole(roleId, role.heroNum, role.heroNumUpdatedAt, role);
            } else if (type == RANK_TYPE.USER_LV) {
                myRank = await r.generMyRankWithRole(roleId, role.lv, role.updatedAt.getTime(), role);
            } else if (type == RANK_TYPE.SUM_CE) {
                myRank = await r.generMyRankWithRole(roleId, role.ce, role.updatedAt.getTime(), role);
            } else if (type == RANK_TYPE.TOWER) {
                myRank = await r.generMyRankWithRole(roleId, role.towerLv, role.towerUpTime?.getTime()||0, role);
            } else if (type == RANK_TYPE.DUNGEON) {
                myRank = await r.generMyRankWithRole(roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
            } else if (type == RANK_TYPE.MAIN) {
                myRank = await r.generMyRankWithRole(roleId, role.mainWarId, role.mainUpdatedAt, role);
            } else if (type == RANK_TYPE.MAIN_ELITE) {
                myRank = await r.generMyRankWithRole(roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
            }
        }

        return resResult(STATUS.SUCCESS, { type, ranks, myRank });
    }

    // 查看活跃排行榜
    async getGuildRank(msg: { type: number }, session: BackendSession) {

        let roleId = session.get('roleId');
        let serverId = session.get('serverId')

        let { type } = msg;

        let redisKey = RANK_TYPE_TO_KEY.get(type);
        if(!redisKey) return resResult(STATUS.WRONG_PARMS);

        let r = new Rank(redisKey, { serverId });
        const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
        let { ranks, myRank } = await r.getRankListWithMyRank({guildCode: myUserGuild?.guildCode||''});
        if (!myRank) {
            let guild = await GuildModel.findByCode(myUserGuild.guildCode, serverId, GUILD_SELECT.RANK);
            if(type == RANK_TYPE.GUILD_LV) {
                myRank = await r.generMyRankWithGuild(guild.code, guild.lv, guild.lvUpdateTime, guild);
            } else if(type == RANK_TYPE.GUILD_ACTIVE) {
                myRank = await r.generMyRankWithGuild(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
            }
        }

        return resResult(STATUS.SUCCESS, { type, ranks, myRank });
    }

    // 查看单个武将排行榜
    async getHeroRank(msg: { type: number, hid: number }, session: BackendSession) {

        let serverId = session.get('serverId')

        let { type, hid } = msg;
        let redisKey = RANK_TYPE_TO_KEY.get(type);
        if(!redisKey) return resResult(STATUS.WRONG_PARMS);

        let r = new Rank(redisKey, { serverId, hid });
        let ranks = await r.getRankByRange();

        return resResult(STATUS.SUCCESS, {
            type, hid, ranks
        });
    }

    async receiveReward(msg: { type: number, id: number }, session: BackendSession) {
        let roleId = session.get('roleId');
        let serverId = session.get('serverId');
        let roleName = session.get('roleName');
        let sid = session.get('sid');

        let { type, id } = msg;

        let dicReward = gameData.generalRankReward.get(id);
        if(!dicReward || dicReward.rankId != type) return resResult(STATUS.WRONG_PARMS);

        let redisKey = RANK_TYPE_TO_KEY.get(type);
        let r = new Rank(redisKey, { serverId }, false, 1);
        let ranks = await r.getRankByRange();
        let num = ranks.length > 0? ranks[0].num: 0;
        if(num < dicReward.condition) return resResult(STATUS.REWARD_CONDITION_NOT_REACH);

        let role = await RoleModel.receiveRankReward(roleId, id);
        if(!role) return resResult(STATUS.REWARD_HAS_RECEIVED);
        
        let reward = dicReward.reward;
        let goods = await addItems(roleId, roleName, sid, reward);

        let received = role.rankReceived.filter(rewardId => {
            let dic = gameData.generalRankReward.get(rewardId);
            return dic && dic.rankId == type;
        });

        return resResult(STATUS.SUCCESS, {
            type: type,
            received,
            goods
        })
    }

    async test(msg: {  }, session: BackendSession) {
        let roles = await RoleModel.find({}).lean();
        for(let role of roles) {
            let heroes = await HeroModel.find({ roleId: role.roleId }).lean();
            await RoleModel.updateRoleInfo(role.roleId, { heroNum: heroes.length, heroNumUpdatedAt: nowSeconds() });
            
        }
    }
}