import { RankConfig } from "./RankConfig"
import { RankModuleC } from "./RankModuleC"





export class RankModuleS extends ModuleS<RankModuleC, null> {


    protected onPlayerLeft(player: mw.Player): void {

        // 当玩家下线的时候，尝试将数据设置到全服排行榜
        let nickName = ""
        if (SystemUtil.isPIE) {
            nickName = "玩家" + player.userId
        } else {
            nickName = player.nickname
        }

        // 检查该玩家的存档数据是否满足各项上榜条件

        // 遍历检查所有排行类型
        Object.values(RankConfig.RankType).forEach(value => {
            if (typeof value === 'number') { // 确保只处理数字值
                this.checkAndSetGameDataByType(value, player.userId, nickName)
            }
        });
    }


    /**
     * 请求获取【房间排行榜】数据
     * @param rankType 排行类型
     * @returns 一份降序排序的排行数据
     */
    public net_getRoomRankDataByType(rankType: RankConfig.RankType) {
        let players = Player.getAllPlayers()
        let rankInfo: string[][] = []
        for (let player of players) {

            let nickName = ""
            if (SystemUtil.isPIE) {
                nickName = "玩家" + player.userId
            } else {
                nickName = player.nickname
            }

            let valueStr = "0"
            valueStr = RankConfig.getUserRankData(player.userId, rankType).toFixed(0)
            rankInfo.push([nickName, valueStr])
        }
        rankInfo.sort((a, b) => Number(b[1]) - Number(a[1]))
        return rankInfo
    }


    /**
     * 请求获取【全服排行榜】数据
     * @param rankType 排行类型
     * @returns 一份降序排序的排行数据
     */
    public async net_getGameRankDataByType(rankType: RankConfig.RankType) {
        const gameDataName = RankConfig.getGameDataName(rankType)
        let resultData = (await DataStorage.asyncGetData(gameDataName)).data
        if (resultData) {
            return resultData
        } else {
            return []
        }
    }


    /**
     * 检查并设置玩家对应类型的排行数据
     * @param rankType 排行类型
     * @param targetUserID 玩家的userID
     * @param nickName 玩家的昵称
     */
    private async checkAndSetGameDataByType(rankType: RankConfig.RankType, targetUserID: string, nickName: string) {

        const gameDataName = RankConfig.getGameDataName(rankType)
        const targetValue = RankConfig.getUserRankData(targetUserID, rankType)

        if (targetValue == -1) { return }

        let result = await DataStorage.asyncGetData(gameDataName)
        let dataArray: string[] = []
        if (result.data) {
            dataArray = result.data
        }

        // 判断自己是否在榜
        let rankIndex = -1
        for (let i = 0; i < dataArray.length; i++) {
            const userID = dataArray[i].split("$$_$$")[2]
            if (userID == targetUserID) {
                rankIndex = i
                break
            }
        }

        // 判断自己是否能上榜
        let isCanRank: boolean = false
        if (dataArray.length > 0) {
            let lastInfo = dataArray[dataArray.length - 1]
            let lastValue = Number(lastInfo.split("$$_$$")[1])
            // console.error(key + "   最后一名：" + lastValue + "   我的：" + targetValue)
            if (targetValue >= lastValue) {
                isCanRank = true
            }
        }

        // 条件修正
        if (dataArray.length < 50) { isCanRank = true }
        if (targetValue <= 0) { isCanRank = false }

        // 不满足上榜条件
        if (!isCanRank) {
            return
        }

        // 如果已经在榜，删除后再添加
        if (rankIndex != -1) {
            dataArray.splice(rankIndex, 1)
        } else {// 没有在榜且排行榜已满，删除最后一名
            if (dataArray.length >= 50) {
                dataArray.pop()
            }
        }

        dataArray.push(nickName + "$$_$$" + targetValue + "$$_$$" + targetUserID)

        // 排序
        dataArray.sort((a, b) => Number(b.split("$$_$$")[1]) - Number(a.split("$$_$$")[1]))

        DataStorage.asyncSetData(gameDataName, dataArray)
    }


}