import { KeyName, KeyNameParam, RankParam, GuildRankParam, RoleRankInfo, GuildRankInfo, GuildLeader, LineupParam, myIdInter, GeneralRankParamRole, GeneralRankParamBattle } from "../domain/rank";
import { REDIS_RANK_TO_INFO, ROLE_SELECT, GUILD_SELECT, REDIS_KEY, REDIS_RANK_TO_EXTRA, HERO_SELECT, COMPOSE_FIELD_TYPE, KEY_TO_COMPOSE_FIELD, RANK_TYPE_TO_KEY } from "../consts";
import { redisClient, setUserInfo } from "./redisService";
import { RoleType, RoleModel } from "../db/Role";
import { GuildType, GuildModel } from "../db/Guild";
import { HeroModel, HeroType, HeroUpdate } from "../db/Hero";
import { SystemConfigModel } from "../db/SystemConfig";
import { PvpDefenseModel } from "../db/PvpDefense";
import { gameData } from "../pubUtils/data";
import { nowSeconds } from "../pubUtils/timeUtil";
import { getWorldChannelSid } from "./chatChannelService";
import { pinus } from "pinus";


/**
 * @description 排行榜相关操作
 * @export
 * @class Rank
 */
export class Rank {
    isInit: boolean = false;               // 初始排行榜
    key: string;                   // 排行榜原始key
    keyName: KeyName;              // 拼接之后的key
    infoKey: string;               // 玩家数据key
    extraKeys: string[];
    isUnion: boolean;              // 是否使用多个zset联合计算
    limit: number = 200;           // 排行榜长度
    timelen: number = 10;          // 给时间位留的长度
    unionRankLife: number = 10;

    constructor(key: string, keyParam: KeyNameParam, isUnion = false, limit = 200) {
        this.key = key;
        this.keyName = new KeyName(key, keyParam);
        this.infoKey = REDIS_RANK_TO_INFO.get(key);
        this.extraKeys = REDIS_RANK_TO_EXTRA.get(key) || [];
        this.isUnion = isUnion;
        switch (key) {
            case REDIS_KEY.TOP_LINEUP_RANK:
            case REDIS_KEY.TOP_HERO_RANK:
            case REDIS_KEY.SUM_CE_RANK:
            case REDIS_KEY.HERO_RANK:
                this.timelen = 0; break;
            case REDIS_KEY.RACE_ACTIVITY:
                this.timelen = 6; break;
            default: 
                this.timelen = 10; break;
        }

        this.limit = limit;
    }

    public setIsInit(init: boolean) {
        this.isInit = init;
    }

    /**
     * 返回字段修改
     * @param obj 
     */
    private async generFields(obj: GuildRankInfo | RoleRankInfo) {
        return obj;
    }

    /**
     * 从外部设置返回字段
     * @param cb 
     */
    public setGenerFieldsFun(cb: (obj: GuildRankInfo | RoleRankInfo) => any) {
        this.generFields = cb;
    }

    /**
     * 设置合成的排行榜的生命时长 单位s
     * @param unionRankLife 
     */
    public setUnionRankLife(unionRankLife: number) {
        this.unionRankLife = unionRankLife;
    }

    /**
     * 该排行是否为空
     * @param void
     */
    public async existsRank() {
        const result = await redisClient().existsAsync(this.keyName.getName());
        return result;
    }

    /**
     * 根据role表设置更新排行榜&玩家信息
     * @param roleId 玩家id
     * @param score 得分
     * @param timestamp 时间点
     * @param role 玩家数据库数据
     * @param isInc 得分是累加上的还是直接设置的
     */
    public async setRankWithRoleInfo(roleId: string, score: number, timestamp: number, role?: RoleType, isInc = false) {
        // 如果没有信息，更新玩家信息
        for (let infoKey of [this.infoKey, ...this.extraKeys]) {
            const hasCurUser = await redisClient().hexistsAsync(infoKey, roleId);
            if (!hasCurUser) {
                await this.generParamAndSet(infoKey, { roleId }, { role });
            }
        }
        let newScore = await this.setRank({ roleId }, score, timestamp, isInc);

        return newScore;
    }

    /**
     * 根据军团表设置更新排行榜&军团信息
     * @param guildCode 军团code
     * @param score 得分
     * @param timestamp 时间点
     * @param guild 军团数据库
     * @param isInc 得分是累加上的还是直接设置的
     */
    public async setRankWithGuildInfo(guildCode: string, score: number, timestamp: number, guild?: GuildType, isInc = false) {
        for (let infoKey of [this.infoKey, ...this.extraKeys]) {
            const hasCurUser = await redisClient().hexistsAsync(infoKey, guildCode);
            if (!hasCurUser) {
                await this.generParamAndSet(infoKey, { guildCode }, { guild });
            }
        }
        let newScore = await this.setRank({ guildCode }, score, timestamp, isInc);

        return newScore;
    }

    /**
     * 根据武将表设置更新排行榜&玩家信息
     * @param roleId 玩家id
     * @param hid 武将id
     * @param score 得分
     * @param timestamp 时间点
     * @param hero 武将数据库
     * @param isInc 得分是累加上的还是直接设置的
     */
    public async setRankWithHeroInfo(roleId: string, hid: number, score: number, timestamp: number, hero?: HeroType, isInc = true) {
        // 如果没有信息，更新玩家信息
        for (let infoKey of [this.infoKey, ...this.extraKeys]) {
            await this.generParamAndSet(infoKey, { roleId, hid }, { hero });
        }
        let newScore = await this.setRank({ roleId, hid }, score, timestamp, isInc);

        return newScore;
    }

    /**
     * 将玩家信息按顺序组成 如：roleId:hid
     * @param {{ string }} key redis key
     * @param {{ roleId?: string; guildCode?: string; hid?: number }} param 玩家信息 
     */
    private composeFields(key: string, param: myIdInter) {
        let type = KEY_TO_COMPOSE_FIELD.get(key);

        if (type == COMPOSE_FIELD_TYPE.ROLE) {
            return param.roleId;
        } else if (type == COMPOSE_FIELD_TYPE.GUILD) {
            return param.guildCode;
        } else if (type == COMPOSE_FIELD_TYPE.ROLE_HERO) {
            return `${param.roleId}:${param.hid}`;
        } else {
            return '';
        }
    }

    /**
     * 将合成了的玩家顺序解开
     * @param key redis key
     * @param field 
     * @returns {{ roleId?: string; guildCode?: string; hid?: number }}
     */
    private decodeFields(key: string, field: string) {
        let type = KEY_TO_COMPOSE_FIELD.get(key);

        let arr = field.split(':');
        if (type == COMPOSE_FIELD_TYPE.ROLE) {
            return { roleId: arr[0] };
        } else if (type == COMPOSE_FIELD_TYPE.GUILD) {
            return { guildCode: arr[0] };
        } else if (type == COMPOSE_FIELD_TYPE.ROLE_HERO) {
            return { roleId: arr[0], hid: parseInt(arr[1]) };
        } else {
            return {};
        }
    }

    /**
     * 将玩家数据设置进redis
     * @param infoKey 玩家信息的redis key
     * @param fields 玩家id
     * @param db 数据库内的数据
     */
    public async generParamAndSet(infoKey: string, fields: myIdInter, db: { role?: RoleType, guild?: GuildType, hero?: HeroType }) {
        let { roleId, guildCode, hid } = fields;
        let { role, guild, hero } = db;

        if (infoKey == REDIS_KEY.USER_INFO) {
            if (!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            let param = new RankParam(role, true);
            await this.setUserInfo(infoKey, { roleId }, param);
        } else if (infoKey == REDIS_KEY.GUILD_INFO) {
            if (!guild) {
                guild = await GuildModel.findByCode(guildCode, this.keyName.serverId, GUILD_SELECT.RANK)
            }
            let param = new GuildRankParam(guild);
            await this.setUserInfo(infoKey, { guildCode }, param);
        } else if (infoKey == REDIS_KEY.TOP_LINEUP_INFO) {
            if (!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            let { topLineup = [] } = role;
            let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
            let arr = new Array<LineupParam>();
            for (let { hid } of topLineup) {
                let curHero = heroes.find(cur => cur.hid == hid);
                if (curHero) {
                    let param = new LineupParam(curHero);
                    arr.push(param);
                }
            }
            await this.setUserInfo(infoKey, { roleId }, arr);
        } else if (infoKey == REDIS_KEY.HERO_INFO) {
            if (!hero) {
                hero = await HeroModel.findByHidAndRole(hid, roleId, HERO_SELECT.RANK_LINEUP, true);
            }
            let arr = new Array<LineupParam>();
            if (hero) {
                let param = new LineupParam(hero);
                arr.push(param);
                await this.setUserInfo(infoKey, { roleId, hid }, arr);
            }
        } else if (infoKey == REDIS_KEY.DUNGEON_LINEUP) {
            if (!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            let { dungeonWarId, dungeonHeroes } = role;
            if(dungeonWarId > 0) {
                let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
                let lineup = cur?cur.heroes: [];
                let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
                let arr = new Array<LineupParam>();
                for (let seqId of lineup) {
                    let curHero = heroes.find(cur => cur.seqId == seqId);
                    if (curHero) {
                        let param = new LineupParam(curHero);
                        arr.push(param);
                    }
                }
                await this.setUserInfo(infoKey, { roleId }, arr);
            }
        } else if (infoKey == REDIS_KEY.SHOW_LINEUP) {
            if (!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            let { showLineup, topLineup = [] } = role;
            let heroes = await HeroModel.findByRole(roleId, [], HERO_SELECT.RANK_LINEUP);
            let arr = new Array<LineupParam>();
            if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
            for (let hid of showLineup) {
                let curHero = heroes.find(cur => cur.hid == hid);
                if (curHero) {
                    let param = new LineupParam(curHero);
                    arr.push(param);
                }
            }
            await this.setUserInfo(infoKey, { roleId }, arr);
        }
    }

    /**
     * 设置信息
     * @param infoKey 
     * @param myId 
     * @param param 
     */
    private async setUserInfo(infoKey: string, myId: myIdInter, param: RankParam | GuildRankParam | LineupParam[]) {
        let field = this.composeFields(infoKey, myId);
        let value = JSON.stringify(param);
        return await redisClient().hsetAsync(infoKey, field, value);
    }

    /**
     * 更新排行榜数据
     * @param myId 
     * @param score 
     * @param timestamp 
     * @param isInc 
     */
    public async setRank(myId: myIdInter, score: number, timestamp: number, isInc = false) {
        let oldTop = await this.getRankByRank(0, 0);
        let oldScore = oldTop.length > 0? oldTop[0].num: 0;
        // 更新分数
        let newScore = score;
        if (this.isUnion) {
            newScore = await this.updateRankScoreAtom(myId, score, timestamp, isInc);
        } else {
            newScore = await this.updateRankScoreEncode(myId, score, timestamp, isInc)
        }
        this.checkMyRankAndPush(myId, oldScore, newScore);
        return newScore;
    }

    /**
     * @description 使用将score和time合成一个字段更新分数
     * @param myId 
     * @param score 
     * @param timestamp 
     */
    private async updateRankScoreEncode(myId: myIdInter, score: number = 0, timestamp: number = 0, isInc = false) {
        let newScore = score;
        let key = this.keyName.getName();
        if (isInc) {
            let oldScore = await this.getMyScore(myId);
            newScore = oldScore + score;
        }

        let scoreStr = this.encodeScore(newScore, timestamp);
        await redisClient().zaddAsync(key, scoreStr, this.composeFields(this.key, myId));
        return newScore
    }

    /**
     * @description 使用分两个zset更新redis中某field的值
     * @param myId 
     * @param score 
     * @param timestamp 
     * @param isInc
     * @class Rank 
     */
    private async updateRankScoreAtom(myId: myIdInter, score: number = 0, timestamp: number = 0, isInc = false) {
        let key = this.keyName.getName();
        let timeKey = this.keyName.getTimeName();

        let pow = Math.pow(10, this.timelen + 1);
        let newScore = 0;
        // 分数zset
        if (isInc) {
            newScore = await redisClient().zincrbyAsync(key, score, this.composeFields(this.key, myId));
        } else {
            newScore = await redisClient().zaddAsync(key, score, this.composeFields(this.key, myId));
        }
        // 时间zset
        await redisClient().zaddAsync(timeKey, pow - 1 - this.handleTimestamp(timestamp), this.composeFields(this.key, myId));

        return parseInt(newScore.toString());
    }


    /**
     * @description 设置到期时间
     * @param time 到期时间，10位时间戳
     * @class Rank
     */
    public async setExpire(time: number) {
        let key = this.keyName.getName();
        let timeKey = this.keyName.getTimeName();

        await redisClient().expireatAsync(key, time);
        await redisClient().expireatAsync(timeKey, time);
    }

    public async generMyRankWithRole(roleId: string, score: number = 0, time: number = 0, role?: RoleType) {
        // 如果没有信息，更新玩家信息
        let param: RoleRankInfo;

        let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
        if (!hasCurUser) {
            if (!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            param = new RoleRankInfo(role, true);
            param.setInfo(0, { roleId }, score, time);
        } else {
            const info = await redisClient().hgetAsync(this.infoKey, roleId);
            const userInfo = JSON.parse(info);

            param = new RoleRankInfo(userInfo, false);
            param.setInfo(0, { roleId }, score, time);
        }

        for (let extraKey of this.extraKeys) {
            await this.setExInfoToParam(extraKey, param, { roleId }, {role});
        }

        return await this.generFields(param);
    }

    public async generMyRankWithGuild(guildCode: string, score: number, time: number, guild?: GuildType) {
        // 如果没有信息，更新玩家信息
        let param: GuildRankInfo;

        let hasCurUser = await redisClient().hexistsAsync(this.infoKey, guildCode);
        if (!hasCurUser) {
            if (!guild) {
                guild = await GuildModel.findByCode(guildCode, this.keyName.serverId, GUILD_SELECT.RANK);
            }
            param = new GuildRankInfo(guild);
            param.setInfo(0, { guildCode }, score, time);
        } else {
            const info = await redisClient().hgetAsync(this.infoKey, guildCode);
            const guildInfo = JSON.parse(info);
            param = new GuildRankInfo(guildInfo);
            param.setInfo(0, { guildCode }, score, time);
        }

        for (let extraKey of this.extraKeys) {
            await this.setExInfoToParam(extraKey, param, { guildCode }, { guild } );
        }

        return await this.generFields(param);
    }

    public async generMyRankWithHero(roleId: string, hid: number, score: number, time: number, hero?: HeroType, role?: RoleType) {
        // 如果没有信息，更新玩家信息
        let param: RoleRankInfo;

        let hasCurUser = await redisClient().hexistsAsync(this.infoKey, roleId);
        if (!hasCurUser) {
            if(!role) {
                role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.RANK, true);
            }
            param = new RoleRankInfo(role, true);
            param.setInfo(0, { roleId, hid }, score, time);
        } else {
            const info = await redisClient().hgetAsync(this.infoKey, roleId);
            const userInfo = JSON.parse(info);

            param = new RoleRankInfo(userInfo, false);
            param.setInfo(0, { roleId, hid }, score, time);
        }

        for (let extraKey of this.extraKeys) {
            await this.setExInfoToParam(extraKey, param, { roleId, hid }, { hero, role });
        }

        return await this.generFields(param);
    }

    private async setExInfoToParam(extraKey: string, param: RoleRankInfo | GuildRankInfo, myId: myIdInter, db: { role?: RoleType, guild?: GuildType, hero?: HeroType }) {
        let { role, guild, hero } = db;

        if (extraKey == REDIS_KEY.TOP_LINEUP_INFO) {
            param = <RoleRankInfo>param;

            let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
            if (!hasCurUser) {
                if (!role) {
                    role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
                }

                let { topLineup } = role;
                let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
                let arr = new Array<LineupParam>();
                for (let { hid } of topLineup) {
                    let curHero = heroes.find(cur => cur.hid == hid);
                    if (curHero) {
                        let param = new LineupParam(curHero);
                        arr.push(param);
                    }
                }
                param.setTopLine(arr);
            } else {
                const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
                const infoObj = JSON.parse(info);
                param.setTopLine(infoObj);
            }
        } else if (extraKey == REDIS_KEY.HERO_INFO) {
            param = <RoleRankInfo>param;

            let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
            if (!hasCurUser) {
                if(!hero) {
                    hero = await HeroModel.findByHidAndRole(myId.hid, myId.roleId, HERO_SELECT.RANK_LINEUP);
                }
                let arr = new Array<LineupParam>();
                let lineParam = new LineupParam(hero);
                arr.push(lineParam);
                if(this.key == REDIS_KEY.HERO_RANK) {
                    param.setSingleHero(arr);
                } else {
                    param.setTopLine(arr);
                }
            } else {
                const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
                const infoObj = JSON.parse(info);
                if(this.key == REDIS_KEY.HERO_RANK) {
                    param.setSingleHero(infoObj);
                } else {
                    param.setTopLine(infoObj);
                }
            }
        } else if (extraKey == REDIS_KEY.DUNGEON_LINEUP) {
            param = <RoleRankInfo>param;

            let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
            if (!hasCurUser) {
                if (!role) {
                    role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
                }
                let { dungeonWarId, dungeonHeroes } = role;
                let cur = dungeonHeroes.find(cur => cur.battleId == dungeonWarId);
                let lineup = cur?cur.heroes: [];
                let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.RANK_LINEUP);
                let arr = new Array<LineupParam>();
                for (let seqId of lineup) {
                    let curHero = heroes.find(cur => cur.seqId == seqId);
                    if (curHero) {
                        let param = new LineupParam(curHero);
                        arr.push(param);
                    }
                }
                param.setTopLine(arr);
            } else {
                const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
                const infoObj = JSON.parse(info);
                param.setTopLine(infoObj);
            }
        } else if (extraKey == REDIS_KEY.SHOW_LINEUP) {
            param = <RoleRankInfo>param;

            let hasCurUser = await redisClient().hexistsAsync(extraKey, this.composeFields(extraKey, myId));
            if (!hasCurUser) {
                if (!role) {
                    role = await RoleModel.findByRoleId(myId.roleId, ROLE_SELECT.RANK, true);
                }

                let { showLineup, topLineup = [] } = role;
                let heroes = await HeroModel.findByRole(myId.roleId, [], HERO_SELECT.HERO_DETAIL);
                let arr = new Array<LineupParam>();
                if(!showLineup) showLineup = topLineup.map(cur => cur.hid);
                for (let hid of showLineup) {
                    let curHero = heroes.find(cur => cur.hid == hid);
                    if (curHero) {
                        let param = new LineupParam(curHero);
                        arr.push(param);
                    }
                }
                param.setTopLine(arr);
            } else {
                const info = await redisClient().hgetAsync(extraKey, this.composeFields(extraKey, myId));
                const infoObj = JSON.parse(info);
                param.setTopLine(infoObj);
            }
        }
    }

    public async getRankListWithMyRank(myId: myIdInter) {
        let ranks = await this.getRankByRange();
        let newRanks = [], newMyRank: RoleRankInfo | GuildRankInfo;
        let myRank = ranks.find(cur => {
            return cur.isMyInfo(myId);
        });
        if (this.generFields) {
            for (let rank of ranks) {
                let n = await this.generFields(rank);
                newRanks.push(n);
            }
            if (myRank) {
                newMyRank = await this.generFields(myRank);
            }
        }

        return { myRank: newMyRank, ranks: newRanks }
    }

    public async getRankByRange(from: number | string = '+inf', to: number | string = '-inf') {

        let ranks = new Array<RoleRankInfo | GuildRankInfo>();
        let key = this.keyName.getName();
        if (this.isUnion) {
            key = await this.generateUnionRank();
        }

        const rankFromDb = await redisClient().zrevrangebyscoreAsync(key, from, to, "WITHSCORES");

        let num = 0;
        for (let ii = 0; ii < rankFromDb.length; ii += 2) {
            if(num >= this.limit) break;

            const field = rankFromDb[ii];
            let myId = this.decodeFields(this.key, field);
            const { score, time } = this.decodeScore(rankFromDb[ii + 1]);
            const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
            const userInfo = JSON.parse(info);

            let param: RoleRankInfo | GuildRankInfo;
            if (this.infoKey == REDIS_KEY.USER_INFO) {
                if(nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
                    continue;
                }
                param = new RoleRankInfo(userInfo, false);
                param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
            } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
                param = new GuildRankInfo(userInfo);
                param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
            }

            for (let extraKey of this.extraKeys) {
                await this.setExInfoToParam(extraKey, param, myId, {});
            }
            ranks.push(param);
            num ++;
        }
        return ranks
    }

    public async getRankByRank(start: number, end: number) {

        let ranks = new Array<RoleRankInfo | GuildRankInfo>();
        let key = this.keyName.getName();
        if (this.isUnion) {
            key = await this.generateUnionRank();
        }

        const rankFromDb = await redisClient().zrevrangeAsync(key, start, end, "WITHSCORES");

        let num = 0;
        for (let ii = 0; ii < rankFromDb.length; ii += 2) {
            if(num >= this.limit) break;

            const field = rankFromDb[ii];
            let myId = this.decodeFields(this.key, field);
            const { score, time } = this.decodeScore(rankFromDb[ii + 1]);
            const info = await redisClient().hgetAsync(this.infoKey, this.composeFields(this.infoKey, myId));
            const userInfo = JSON.parse(info);

            let param: RoleRankInfo | GuildRankInfo;
            if (this.infoKey == REDIS_KEY.USER_INFO) {
                if(nowSeconds() - userInfo.updatedAt > 2 * 30 * 24 * 60 * 60) {
                    continue;
                }
                param = new RoleRankInfo(userInfo, false);
                param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
            } else if (this.infoKey == REDIS_KEY.GUILD_INFO) {
                param = new GuildRankInfo(userInfo);
                param.setInfo(Math.floor(ii / 2) + 1, myId, score, time);
            }

            for (let extraKey of this.extraKeys) {
                await this.setExInfoToParam(extraKey, param, myId, {});
            }
            ranks.push(param);
            num ++;
        }
        return ranks
    }


    // 获取我的排名
    public async getMyRank(myId: myIdInter) {
        let key = this.keyName.getName();
        if (this.isUnion) {
            key = await this.generateUnionRank();
        }
        // console.log('**getMyRank',key, this.composeFields(this.key, myId), this.key, myId)
        let myRank = await redisClient().zrevrankAsync(key, this.composeFields(this.key, myId));
        if(!myRank && myRank != 0) {
            return 0;
        } else {
            return myRank + 1;
        }
    }

    // 获取排名第几名的信息
    public async getUserByRank(rank: number) {
        let key = this.keyName.getName();
        let myRank = await redisClient().zrevrangeAsync(key, rank - 1, rank - 1);
        return myRank;
    }


    // 获取排名第几名的信息
    public async getMyScore(myId: myIdInter) {
        let key = this.keyName.getName();
        let score = await redisClient().zscoreAsync(key, this.composeFields(this.key, myId));
        if (!score) score = 0;
        if (!this.isUnion) {
            let result = this.decodeScore(score.toString());
            score = result.score;
        }
        return parseInt(score.toString());
    }

    // 从排行榜中移除
    public async removeFromRank(myId: myIdInter) {
        let key = this.keyName.getName();
        await redisClient().zremAsync(key, this.composeFields(this.key, myId));

        return true;
    }

    private async generateUnionRank() {
        let unionKey = this.keyName.getUnionName(); // 联合的key
        let existsKey = await redisClient().existsAsync(unionKey);
        if (!existsKey) {
            let originKey = this.keyName.getName();
            let timeKey = this.keyName.getTimeName();

            let pow = Math.pow(10, this.timelen + 1);
            await redisClient().zunionstoreAsync(unionKey, 2, originKey, timeKey, 'WEIGHTS', pow, 1);
            await redisClient().expireAsync(unionKey, this.unionRankLife); // 10秒更新一次
        }
        return unionKey;
    }

    // 有序排行综合时间和得分排序
    private encodeScore(score: number, timestamp: number) {
        let timelen = this.timelen;
        let pow = Math.pow(10, timelen + 1);
        return score * pow + pow - 1 - this.handleTimestamp(timestamp)
    }

    private decodeScore(num: string) {
        let timelen = this.timelen;
        let pow = Math.pow(10, timelen + 1);
        let _num = parseInt(num);
        return {
            time: pow - _num % pow,
            score: Math.floor(_num / pow)
        };
    }

    private handleTimestamp(timestamp: number = 0) {
        let l = timestamp.toString().length;
        if(l > this.timelen) {
            timestamp = Math.floor(timestamp / Math.pow(10, l - this.timelen));
        }
        return timestamp
    }

    private async checkMyRankAndPush(myId: myIdInter, oldScore: number, newScore: number) {
        if(this.isInit) return;
        let myRank = await this.getMyRank(myId);
        if(myRank == 1 && newScore > oldScore) {
            let serverId = this.keyName.serverId;
            let sid = await getWorldChannelSid(serverId);
            for(let { id, general } of gameData.rank) {
                let redisKey = RANK_TYPE_TO_KEY.get(id);
                if(redisKey == this.key) {
                    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));
                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
                        }
                    } 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);
                            pinus.app.rpc.chat.chatRemote.sendRankTopUpdated.toServer(sid, serverId, {...param, general});
                        }
                    }

                    break;
                }
            }
        }
    }
}


/**
 * 从数据库内获取排行榜存入redis
 * @param type 排行榜类型
 * @param serverId 分服
 */
export async function setRankRedisFromDb(type: string, args?: {serverId?: number}) {

    if(type == REDIS_KEY.TOWER_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('tower', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            // console.log(roleId);
            await r.setRankWithRoleInfo(role.roleId, role.towerLv, role.towerUpTime?role.towerUpTime.getTime():0, role);
        }
    } else if (type == REDIS_KEY.GUILD_ACTIVE_RANK) {
        let serverId = args.serverId;
        let ranks = await GuildModel.getRank(type, serverId);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let guild of ranks) {
            await r.setRankWithGuildInfo(guild.code, guild.activeWeekly, guild.activeUpdateTime, guild);
        }
    } else if (type == REDIS_KEY.GUILD_LV_RANK) {
        let serverId = args.serverId;
        let ranks = await GuildModel.getRank(type, serverId);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let guild of ranks) {
            await r.setRankWithGuildInfo(guild.code, guild.lv, guild.lvUpdateTime, guild);
        }
    } else if ( type == REDIS_KEY.PVP_RANK) {
        let { seasonNum } = await SystemConfigModel.findSystemConfig();
        console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
        let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
        let r = new Rank(type, {});
        r.setIsInit(true);
        for(let {roleId, role: _role, score, updatedAt } of ranks) {
            let role = <RoleType>_role;
            if (!role) {
                continue;
            }
            await r.setRankWithRoleInfo(roleId, score, updatedAt.getTime(), role);
        }
    } else if (type == REDIS_KEY.TOP_LINEUP_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('topLineup', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            // console.log(roleId);
            await r.setRankWithRoleInfo(role.roleId, role.topLineupCe, role.updatedAt.getTime(), role);
        }
    } else if (type == REDIS_KEY.TOP_HERO_RANK) {
        let serverId = args.serverId;
        let ranks = await HeroModel.getAllRank(serverId, HERO_SELECT.RANK_LINEUP);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let hero of ranks) {
            await r.setRankWithHeroInfo(hero.roleId, hero.hid, hero.ce, hero.updatedAt.getTime(), hero);
        }
    } else if (type == REDIS_KEY.HERO_NUM_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('heroNum', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.heroNum, role.heroNumUpdatedAt, role );
        }
    } else if (type == REDIS_KEY.USER_LV) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('lv', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.lv, role.updatedAt.getTime(), role);
        }
    } else if (type == REDIS_KEY.SUM_CE_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('ce', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.ce, role.updatedAt.getTime(), role);
        }
    } else if (type == REDIS_KEY.DUNGEON_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('dungeon', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.dungeonWarId, role.dungeonUpdatedAt, role);
        }
    } else if (type == REDIS_KEY.MAIN_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('main', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.mainWarId, role.mainUpdatedAt, role);
        }
    } else if (type == REDIS_KEY.MAIN_ELITE_RANK) {
        let serverId = args.serverId;
        let ranks = await RoleModel.getRank('mainElite', serverId, ROLE_SELECT.RANK);
        let r = new Rank(type, { serverId });
        r.setIsInit(true);
        for(let role of ranks) {
            await r.setRankWithRoleInfo(role.roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
        }
    } else if (type == REDIS_KEY.HERO_RANK) {
        let serverId = args.serverId;

        for(let hid of gameData.dicMyHeroes) {
            let ranks = await HeroModel.getRank(hid, serverId, HERO_SELECT.RANK_LINEUP);
            let r = new Rank(type, { serverId, hid });
            r.setIsInit(true);
            for(let hero of ranks) {
                await r.setRankWithHeroInfo(hero.roleId, hid, hero.ce, hero.updatedAt.getTime(), hero);
            }
        }
    }
}

/**
 * 获取排行榜总览
 * @param role 玩家数据
 * @param serverId 所在服务器
 */
export async function getGeneralRank(role: RoleType&{rankReceived: number[]}, serverId: number) {
    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 res;
}