import { Application, BackendSession, HandlerService, pinus, } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, getRedisKeyByRankType, ROLE_SELECT, RANK_TYPE, HERO_SELECT, GUILD_SELECT, RANK_FIRST_REWARD_STATUS, ITEM_CHANGE_REASON, REDIS_KEY } from "../../../consts";
import Role from "../../../db/Role";
import { UserGuildModel } from "../../../db/UserGuild";
import { GuildModel } from "../../../db/Guild";
import { Rank, getGeneralRank, getRankFirstReward, getRankInHandler } from "../../../services/rankService";
import { gameData } from "../../../pubUtils/data";
import { addItems } from "../../../services/role/rewardService";
import { RewardInter } from "../../../pubUtils/interface";
import { RankFirstType } from "../../../db/RankFirst";
import Hero from "../../../db/Hero";
import { LineupParam, RoleAndGuildRankInfo, RoleRankInfo } from "../../../domain/rank";

export default function (app: Application) {
    new HandlerService(app, {});
    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 Role.findByRoleId(roleId, 'rankReceived');
        if (!role) return resResult(STATUS.WRONG_PARMS);

        let ranks = await getGeneralRank(role, serverId);

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


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

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

        let ranks = await getRankFirstReward(role, serverId);

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

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

        let { type } = msg;
        let redisKey = getRedisKeyByRankType(type);
        if (!redisKey) return resResult(STATUS.WRONG_PARMS);

        if(redisKey == REDIS_KEY.TOP_HERO_RANK) {
            let heroRanks = await Hero.findByServerIdAndSortByCe(serverId);

            let r = new Rank(REDIS_KEY.TOP_HERO_RANK, { serverId });
            let ranks: RoleAndGuildRankInfo[] = [], myRank: RoleAndGuildRankInfo;
            for(let rank = 1; rank <= heroRanks.length; rank++) {
                let hero = heroRanks[rank - 1];
                let result = new RoleAndGuildRankInfo(rank, hero.ce);
                let param = <RoleRankInfo>await r.getParam(rank, hero.roleId, [hero.ce]);
                if(!param) {
                    let role = await Role.findByRoleId(hero.roleId, ROLE_SELECT.RANK);
                    await r.generParamAndSet(REDIS_KEY.USER_INFO, { roleId: hero.roleId }, { role });
                    param = <RoleRankInfo>await r.getParam(rank, hero.roleId, [hero.ce]);
                }
    
                param.setTopLine([new LineupParam(hero)]);
                result.setUserInfo(param);
                ranks.push(result);
                if(!myRank && param.roleId == roleId) myRank = result;
            }
            if(!myRank) {
                let myHeroes = await Hero.findAndSortByCe(roleId);
                let myHero = myHeroes[0];
                let result = new RoleAndGuildRankInfo(0, myHero.ce);
                let param = <RoleRankInfo>await r.getParam(0, roleId, [myHero.ce]);
                if(!param) {
                    let role = await Role.findByRoleId(roleId, ROLE_SELECT.RANK);
                    await r.generParamAndSet(REDIS_KEY.USER_INFO, { roleId }, { role });
                    param = <RoleRankInfo>await r.getParam(0, roleId, [myHero.ce]);
                }
    
                param.setTopLine([new LineupParam(myHero)]);
                result.setUserInfo(param);
                myRank = result;
            }
            return resResult(STATUS.SUCCESS, { type, myRank, ranks });
        } else {
            let result = await getRankInHandler(redisKey, type, { serverId }, session);
            return resResult(STATUS.SUCCESS, { type, ...result });
        }

    }

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

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

        let { type } = msg;

        let redisKey = getRedisKeyByRankType(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 roleId = session.get('roleId');

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

        let heroRanks = await Hero.findByServerIdAndHidAndSortByCe(serverId, hid);

        let r = new Rank(redisKey, { serverId });
        let ranks: RoleRankInfo[] = [], myRank: RoleRankInfo;
        for(let rank = 1; rank <= heroRanks.length; rank++) {
            let hero = heroRanks[rank - 1];
            let param = <RoleRankInfo>await r.getParam(rank, hero.roleId, [hero.ce]);
            if(!param) {
                let role = await Role.findByRoleId(hero.roleId, ROLE_SELECT.RANK);
                await r.generParamAndSet(REDIS_KEY.USER_INFO, { roleId: hero.roleId }, { role });
                param = <RoleRankInfo>await r.getParam(rank, hero.roleId, [hero.ce]);
            }

            param.setSingleHero([new LineupParam(hero)]);
            ranks.push(param);
            if(!myRank && param.roleId == roleId) myRank = param;
        }
        if(!myRank) {
            let myHero = await Hero.findByHidAndRole(hid, roleId);
            let param = <RoleRankInfo>await r.getParam(0, roleId, [myHero?.ce||0]);
            if(!param) {
                let role = await Role.findByRoleId(roleId, ROLE_SELECT.RANK);
                await r.generParamAndSet(REDIS_KEY.USER_INFO, { roleId }, { role });
                param = <RoleRankInfo>await r.getParam(0, roleId, [myHero?.ce||0]);
            }

            if(myHero) {
                param.setSingleHero([new LineupParam(myHero)]);
            }
            myRank = param;
        }
        return resResult(STATUS.SUCCESS, { type, hid, myRank, 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 ids: number[] = [];
        if (id == 0) {
            gameData.generalRankReward.forEach((dic, id) => {
                if (dic.rankId == type) {
                    ids.push(id);
                }
            });
        } else {
            ids.push(id);
        }
        let rewards: RewardInter[] = [];
        let canReceiveId: number[] = [];
        let role = await Role.findByRoleId(roleId, 'rankReceived');

        for (let id of ids) {
            let dicReward = gameData.generalRankReward.get(id);
            if (!dicReward || dicReward.rankId != type) continue;

            let rankFirst: RankFirstType = pinus.app.get('rankFirstRewards').get(serverId)?.get(id);
            // console.log('*******', pinus.app.get('rankFirstRewards'), rankFirst);
            if (!rankFirst) continue;
            if (role.rankReceived.includes(id)) continue;

            let reward = dicReward.reward;
            rewards = rewards.concat(reward);
            canReceiveId.push(id);
        }

        role = await Role.receiveRankReward(roleId, canReceiveId);
        if (canReceiveId.length <= 0) return resResult(STATUS.REWARD_CONDITION_NOT_REACH);

        let rewardStatus = canReceiveId.map(id => {
            return { id, type, status: RANK_FIRST_REWARD_STATUS.RECEIVED }
        })

        let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.RANK_REWARD);

        return resResult(STATUS.SUCCESS, {
            rewards: rewardStatus,
            goods
        })
    }
}