local FairSoloTournament_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local fair_tournament_opt_pb = require('Proto/fair_tournament_opt_pb')
local PLAYER_VALUE_KEY = "FAIRSOLOTOURNAMENT_PLAYERDATA"
local CONST_HOT_NUM = 32 --热门人数数量
local INVALID_SORT_NUM = 999 --无效权重值

local CONST_INTERVAL_GETPLAYER = 60
local _townHomeRPTimerHandle = nil -- 刷新可比赛阶段红点 定时器句柄

FairSoloTournament_Model.WATCHTYPE_WATCH = 1
FairSoloTournament_Model.WATCHTYPE_CANCEL = 2

FairSoloTournament_Model.IsOpenMainPanel = false

FairSoloTournament_Model.Enum_State = {
    Ready = 1, -- 准备阶段
    Matching = 2, -- 匹配阶段
    Roll = 3, --掷骰子
    BanPick = 4, --禁选武将
    Battle = 5, -- 战斗阶段
    Finish = 6, -- 活动结束
}

FairSoloTournament_Model.Enum_BigStage = {
    FairAdvance = 1, -- 报名阶段
    FairScreening = 2, -- 小组赛阶段
    FairRank = 3, -- 晋级赛阶段
    FairFinals = 4, -- 决赛阶段
    FairDisplay = 5, -- 展示阶段
}

--配置表FairMatchStage对应的赛制阶段ID
FairSoloTournament_Model.ConfigStage = {
    None = 0,
    Prepare = 1100, -- 报名阶段
    Group_1 = 1200, -- 小组赛第一天
    Group_2 = 1300, -- 小组赛第二天
    Display = 1400, -- 展示期
    Finals_2T1 = 1500, -- 2进1
    Finals_4T2 = 1600, -- 4进2
    Finals_8T4 = 1700,
    Finals_16T8 = 1800,
    Finals_32T16 = 1900,
    Finals_64T32 = 2000,
    Finals_128T64 = 2100,
}

function FairSoloTournament_Model.OnStartup()
    private.storeGoods = {}
    private.moduleInfo = nil
    private.lastStageID = 0
    private.stageInfoDict = {}
    private.myInfo = nil
    private.quizBetInfoArray = nil
    private.taskInfoArray = nil
    private.allPlayerShowInfoDict = {}
    private.groupPlayerInfos = nil
    private.groupCompetitionId = 0
    private.hotAdvanceDict = nil --入围32强
    private.getAllPlayerInfoTimestamp = 0

    EventSystem.Regist(EventID.FunctionUnlockUpdate, private.RefreshUnLockFunc)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentOpen, private.OnFairTournamentOpenResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentGetAllPlayerInfo, private.OnFairTournamentGetAllPlayerInfoResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushFairTournamentStageChange, private.OnG2CPushFairTournamentStageChange)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushFairTournamentPlayerInfo, private.OnG2CPushFairTournamentPlayerInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentGetAllQuizInfo, private.OnFairTournamentGetAllQuizInfoResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentBattleBet, private.OnFairTournamentBattleBetResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentQuizBet, private.OnFairTournamentQuizBetResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentGetStageInfo, private.OnFairTournamentGetStageInfoResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushFairTournamentNeedLeave, private.OnG2CPushFairTournamentNeedLeave)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushFairTournamentBPInfo, private.OnG2CPushFairTournamentBPInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushFairTournamentBattleResult, private.OnG2CPushFairTournamentBattleResult)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentTaskInfo, private.OnFairTournamentTaskResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentTaskReward, private.OnFairTournamentTaskRewardResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentBPWatch, private.OnFairTournamentBPWatchResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentThumbsUp, private.OnFairTournamentThumbsUpResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentGetFamous, private.OnFairTournamentGetFamousResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageFairTournamentGetClassPlayerInfo, private.OnFairTournamentGetClassPlayerInfoResp)

    EventSystem.Regist(EventID.SyncSoloTournament_BattleResult, private.SendBattleResult)
    EventSystem.Regist(EventID.WatchBattle_LevelStop, private.OnWatchBattleOver)
    EventSystem.Regist(EventID.DeepLink_Event,private.OnDeepLink)
end

--IAE扩展
function private.OnDeepLink(key)
    if key ~= LuaConst.Deeplink.FairSoloTournament then
        return
    end

    --强制引导时，不打开界面，清掉deeplink存储
    if CTL.PlayerGuide.IsForceGuiding() then
        return
    end

    --没有参数，只要判断判断活动开启
    if FairSoloTournament_Model.IsShowEntry() then
        --在城镇里，尝试打开
        if BattleDataGetter.IsOnlineTownLevel() then
            if FairSoloTournament_Model.GetCurMatchTimeID() > FairSoloTournament_Model.Enum_BigStage.FairAdvance then
                CTL.FairSoloTournament.OpenMain()
            elseif not UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIPushInterfaceFairSoloTournament) then
                UIManager.OpenView(Const_UI_Lua.UIEnum.UIPushInterfaceFairSoloTournament)
            end
        end
    end
end

function FairSoloTournament_Model.IsShowEntry()
    if private.moduleInfo and private.moduleInfo.seasonId > 0 and UTL.Time.GetServerTimestamp() - private.moduleInfo.startTm >= 5 * UTL.Time.TotalSecondsOneMinute then
        return MDL.Unlock.IsUnlock(MDL.Unlock.FunctionType.FairSoloTournament)
    end
    return false
end

function FairSoloTournament_Model.IsInOpenTime()
    local curTitle = FairSoloTournament_Model.GetCurMatchTimeID()
    if curTitle >= FairSoloTournament_Model.Enum_BigStage.FairScreening and curTitle <= FairSoloTournament_Model.Enum_BigStage.FairFinals then
        local timeCfg = DataSheetManager.FairMatchTime:GetDataByID(curTitle)
        return UTL.Time.IsServerInOpeningTime(timeCfg.StartTime, timeCfg.EndTime)
    end
    return false
end

--0:未参赛 -1:参与中 >0:对应阶段id，表示参赛止步于当前阶段
function FairSoloTournament_Model.GetMyHighestStage()
    local highestStage = 0
    if private.myInfo then
        highestStage = private.myInfo.myStage
        if highestStage == -1 then
            if FairSoloTournament_Model.GetCurStageID() == FairSoloTournament_Model.ConfigStage.Finals_2T1 then
                --冠亚未产生之前就是4强，所以需要特殊处理
                return FairSoloTournament_Model.ConfigStage.Finals_4T2
            else
                return FairSoloTournament_Model.GetCurStageID()
            end
        end
    end
    return highestStage
end

--是否能进小组赛
function FairSoloTournament_Model.GetIfInGroup()
    return private.groupCompetitionId > 0
end

--获取小组赛可参加次数，最大次数
function FairSoloTournament_Model.GetCurGroupTimes()
    local isInGroup = private.groupCompetitionId > 0
    local stageInfo = FairSoloTournament_Model.GetStageInfo(FairSoloTournament_Model.GetCurStageID())
    if stageInfo then
        local curRound = 0
        if isInGroup then
            --参赛者以自身为准，在战斗阶段结束前打完也需要计算
            local myGroupInfo
            local myAcid = BattleDataGetter.GetAcID()
            for i, v in ipairs(stageInfo.groupInfos) do
                local acid_1 = v.playerInfos[1].acid
                local acid_2 = v.playerInfos[2].acid
                if acid_1 == myAcid or acid_2 == myAcid then
                    myGroupInfo = v
                    break
                end
            end
            if myGroupInfo then
                if stageInfo.state >= FairSoloTournament_Model.Enum_State.Battle and myGroupInfo.isBattleEnd == true then
                    curRound = myGroupInfo.turn
                else
                    curRound = myGroupInfo.turn - 1
                end
            end
        else
            if stageInfo.state <= FairSoloTournament_Model.Enum_State.Battle then
                if stageInfo.groupInfos[1] then
                    curRound = stageInfo.groupInfos[1].turn - 1
                end
            else
                if stageInfo.groupInfos[1] then
                    curRound = stageInfo.groupInfos[1].turn
                end
            end
        end
        if FairSoloTournament_Model.GetCurStageID() == FairSoloTournament_Model.ConfigStage.Group_1 then
            local maxTimes = DataSheetManager.ConstData:GetDataByID("FairTournamentRace1BattleNum").IntValue
            return maxTimes - curRound, maxTimes
        elseif FairSoloTournament_Model.GetCurStageID() == FairSoloTournament_Model.ConfigStage.Group_2 then
            local maxTimes_1 = DataSheetManager.ConstData:GetDataByID("FairTournamentRace1BattleNum").IntValue
            local maxTimes_2 = DataSheetManager.ConstData:GetDataByID("FairTournamentRace2BattleNum").IntValue
            local curRound = curRound - maxTimes_1
            return maxTimes_2 - curRound, maxTimes_2
        end
    end
    return 0, 0
end

--获取竞猜次数
function FairSoloTournament_Model.GetCurGuessingTimes()
    if private.myInfo then
        local matchTimeCfg = DataSheetManager.FairMatchTime:GetDataByID(FairSoloTournament_Model.GetCurMatchTimeID())
        return matchTimeCfg.GuessTimes - private.myInfo.battleBetNum, matchTimeCfg.GuessTimes
    end
    return 0, 0
end

function FairSoloTournament_Model.GetNextStageID()
    local curStageId = FairSoloTournament_Model.GetCurStageID()
    if curStageId == FairSoloTournament_Model.ConfigStage.Group_2 then
        return FairSoloTournament_Model.ConfigStage.Finals_128T64
    end
    if curStageId < FairSoloTournament_Model.ConfigStage.Display then
        for i = FairSoloTournament_Model.ConfigStage.Prepare, FairSoloTournament_Model.ConfigStage.Group_2, 100 do
            if i > curStageId then
                return i
            end
        end
    else
        for i = FairSoloTournament_Model.ConfigStage.Finals_128T64, FairSoloTournament_Model.ConfigStage.Display, -100 do
            if i < curStageId then
                return i
            end
        end
    end
    return FairSoloTournament_Model.ConfigStage.Display
end

--获取我的小组赛groupId
function FairSoloTournament_Model.GetMyGroupIDInGroup()
    local curStage = FairSoloTournament_Model.GetCurStageID()
    local stageInfo = private.stageInfoDict[curStage]
    if stageInfo then
        for _, groupInfo in ipairs(stageInfo.groupInfos) do
            for _, playerInfo in ipairs(groupInfo.playerInfos) do
                if playerInfo.acid == BattleDataGetter.GetAcID() then
                    return groupInfo.groupId
                end
            end
        end
    end
    return nil
end

--获取我的小组赛名次(无小组赛赛程数据时返回nil)
function FairSoloTournament_Model.GetMyGroupRank()
    local curStage = FairSoloTournament_Model.GetCurStageID()
    if curStage == FairSoloTournament_Model.ConfigStage.Group_1 or curStage == FairSoloTournament_Model.ConfigStage.Group_2 then
        local stageInfo = private.stageInfoDict[curStage]
        if stageInfo then
            local rank = private.GetMyGroupRankFromStageInfo(stageInfo)
            if rank > 0 then
                return rank
            end
        end
    else
        local stageInfo = FairSoloTournament_Model.GetStageInfo(FairSoloTournament_Model.ConfigStage.Group_2)
        if stageInfo then
            local rank = private.GetMyGroupRankFromStageInfo(stageInfo)
            if rank > 0 then
                return rank
            end
        end
    end
    return nil
end

function private.GetMyGroupRankFromStageInfo(stageInfo)
    local infoList = {}
    for _, groupInfo in ipairs(stageInfo.groupInfos) do
        if (CTL.FairSoloTournament.ParseGroupID(groupInfo.groupId) == private.groupCompetitionId) then
            for _, playerInfo in ipairs(groupInfo.playerInfos) do
                table.insert(infoList, playerInfo)
            end
        end
    end
    table.sort(infoList, CTL.FairSoloTournament.SortByWinNum)
    for i, v in ipairs(infoList) do
        if v.acid == BattleDataGetter.GetAcID() then
            return i
        end
    end
    return 0
end

--自己是否是参赛者
function FairSoloTournament_Model.CheckIfInCompetition()
    if private.myInfo then
        return private.myInfo.myStage == -1
    end
    return false
end

--检查是否处在比赛阶段
function FairSoloTournament_Model.CheckIsBattleStage()
    local curMatchTimeID = FairSoloTournament_Model.GetCurMatchTimeID()
    return FairSoloTournament_Model.IsShowEntry() and curMatchTimeID > FairSoloTournament_Model.Enum_BigStage.FairAdvance and curMatchTimeID < FairSoloTournament_Model.Enum_BigStage.FairDisplay
end

--活动开启后，获取距离活动结束的时间
function FairSoloTournament_Model.GetTimeToClose()
    local MatchTime = DataSheetManager.FairMatchTime:GetDataByID(FairSoloTournament_Model.GetCurMatchTimeID())
    local closeTime = 0
    local offsetTime = UTL.Time.GetServerIntervalTimeByTimeId(MatchTime.EndTime)
    if offsetTime > 0 then
        if closeTime == 0 then
            closeTime = offsetTime
        elseif closeTime > offsetTime then
            closeTime = offsetTime
        end
    end
    return closeTime
end

--是否显示战前ban武将入口
function FairSoloTournament_Model.CheckIfShowBanEntry()
    return FairSoloTournament_Model.CheckIfInCompetition()
     and FairSoloTournament_Model.GetCurMatchTimeID() <= FairSoloTournament_Model.Enum_BigStage.FairScreening
end

--是否竞猜了该选手
--isGroup 是否小组赛
--小组赛的groupId是第x组
function FairSoloTournament_Model.CheckIsGuessByGroupID_ACID(groupId, acid, isGroup)
    local guessingInfo = FairSoloTournament_Model.GetGuessingInfoByGroupID_ACID(groupId, acid, isGroup)
    return guessingInfo ~= nil
end

function FairSoloTournament_Model.GetGuessingInfoByGroupID(groupId)
    if private.myInfo then
        for k, v in ipairs(private.myInfo.betInfo) do
            if v.groupId == groupId then
                return v
            end
        end
    end
    return nil
end

function FairSoloTournament_Model.GetGuessingInfoByGroupID_ACID(groupId, acid, isGroup)
    if private.myInfo then
        for k, v in ipairs(private.myInfo.betInfo) do
            if v.isClass == isGroup and v.betAcid == acid then
                if isGroup then
                    --小组赛不需要判断groupId，acid就是唯一的
                    return v
                else
                    if v.groupId == groupId then
                        return v
                    end
                end
            end
        end
    end
    return nil
end

--是否竞猜过该玩家
function FairSoloTournament_Model.CheckIfGuessingByAcid(acid)
    if private.myInfo then
        for k, v in ipairs(private.myInfo.betInfo) do
            if v.betAcid == acid then
                return true
            end
        end
    end
    return false
end

function FairSoloTournament_Model.GetModuleInfo()
    return private.moduleInfo
end

function FairSoloTournament_Model.GetMyInfo()
    return private.myInfo
end

--指定比赛阶段对战信息
function FairSoloTournament_Model.GetStageInfo(stageId)
    return private.stageInfoDict[stageId]
end

--商店道具迭代器
function FairSoloTournament_Model.GetStoreGoodsEnumerator()
    if private.moduleInfo == nil then
        logging.error(LTAG.ERROR, "[FairSoloTournament]moduleInfo nil")
        return nil
    end
    table.clearArray(private.storeGoods)
    local tabID = private.moduleInfo.storeId
    for _, v in MDL.OperationActivity.StoreGoodsData:GetEnumerator() do
        if v.TabID == tabID then
            table.insert(private.storeGoods, v)
        end
    end
    return ipairs(private.storeGoods)
end

--当前赛程阶段ID
function FairSoloTournament_Model.GetCurStageID()
    if private.moduleInfo then
        return private.moduleInfo.curStage
    end
    return 0
end

--当前赛程大阶段编号
function FairSoloTournament_Model.GetCurMatchTimeID()
    if private.moduleInfo then
        return private.moduleInfo.curTitle
    end
    return 0
end

function FairSoloTournament_Model.GetGroupPlayerInfos()
    return private.groupPlayerInfos
end

function FairSoloTournament_Model.GetPlayerShowInfo(acid)
    local info = private.allPlayerShowInfoDict[acid]
    if info then
        return info.showInfo
    end
    return nil
end

--获取玩家1v1积分
function FairSoloTournament_Model.GetPlayerSyncSoloPoint(acid)
    local info = private.allPlayerShowInfoDict[acid]
    if info then
        return info.syncSoloPoint
    end
    return 0
end

--获取玩家1v1排名
function FairSoloTournament_Model.GetPlayerSyncSoloRank(acid)
    local info = private.allPlayerShowInfoDict[acid]
    if info then
        return info.syncSoloRank
    end
    return 0
end

--获取玩家小组赛胜场数
function FairSoloTournament_Model.GetPlayerGroupWinNum(acid)
    local info = private.allPlayerShowInfoDict[acid]
    if info then
        return info.classWinNum
    end
    return 0
end

--获取玩家小组赛击败武将总数
function FairSoloTournament_Model.GetPlayerGroupDefeatNum(acid)
    local info = private.allPlayerShowInfoDict[acid]
    if info then
        return info.defeatNum
    end
    return 0
end

--enterWorld只传几个基础值
function FairSoloTournament_Model.SyncBaseData(base)
    if private.moduleInfo == nil then
        private.moduleInfo = {}
    end
    private.moduleInfo.seasonId = base.info.seasonId
    private.moduleInfo.storeId = base.info.storeId
    private.moduleInfo.startTm = base.info.startTm
    private.moduleInfo.curTitle = base.info.curTitle
    private.moduleInfo.curStage = base.info.curStage
    private.moduleInfo.groupId = base.info.groupId
    private.moduleInfo.groupNum = base.info.groupNum

    local classId = base.myInfo.classId
    private.groupCompetitionId = classId

    CTL.FairSoloTournament.RefreshActivityRed()

    local curTitle = FairSoloTournament_Model.GetCurMatchTimeID()
    if curTitle >= FairSoloTournament_Model.Enum_BigStage.FairScreening
            and curTitle <= FairSoloTournament_Model.Enum_BigStage.FairFinals then
        local timeCfg = DataSheetManager.FairMatchTime:GetDataByID(curTitle)
        local time = { StartTime = timeCfg.StartTime, EndTime = timeCfg.EndTime }

        _townHomeRPTimerHandle = TimerUtil.Interval(private.UpdateTownHomeRP, 1, 1)
    end
    if FairSoloTournament_Model.IsShowEntry() and FairSoloTournament_Model.GetCurMatchTimeID() >= FairSoloTournament_Model.Enum_BigStage.FairScreening and
            FairSoloTournament_Model.GetCurMatchTimeID() <= FairSoloTournament_Model.Enum_BigStage.FairFinals then
        FairSoloTournament_Model.FairTournamentOpenReq()
        FairSoloTournament_Model.FairTournamentTaskInfoReq()
    end
end

function private.InitDelayOpenEntryTimer()
    if private.delayOpenEntryTimer then
        return
    end
    local time = private.moduleInfo.startTm + 5 * UTL.Time.TotalSecondsOneMinute - UTL.Time.GetServerTimestamp()  + 1
    if time > 0 then
        private.delayOpenEntryTimer = TimerUtil.Interval(function()
            private.delayOpenEntryTimer = nil
            EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshModuleInfo)
        end, time, 1)
    end
end

function private.GetCurSeasonPlayerDict()
    if private.localPlayerDict == nil then
        private.localPlayerDict = PersistentData.PlayerData:Get(PLAYER_VALUE_KEY)
        if private.localPlayerDict == nil then
            private.localPlayerDict = {
                seasonId = private.moduleInfo.seasonId
            }
        else
            if private.localPlayerDict.seasonId ~= private.moduleInfo.seasonId then
                --本地存储的赛季id有变化，清除上次存储的数据
                private.localPlayerDict = {
                    seasonId = private.moduleInfo.seasonId
                }
            end
        end
    end
    return private.localPlayerDict
end

function FairSoloTournament_Model.SetSeasonPlayerValue(name, value)
    local localPlayerDict = private.GetCurSeasonPlayerDict()
    localPlayerDict[name] = value
    PersistentData.PlayerData:Set(PLAYER_VALUE_KEY, localPlayerDict, true)
end

function FairSoloTournament_Model.GetSeasonPlayerValue(name)
    local localPlayerDict = private.GetCurSeasonPlayerDict()
    return localPlayerDict[name]
end

function private.UpdateTownHomeRP()
    if _townHomeRPTimerHandle then
        TimerUtil.Remove(_townHomeRPTimerHandle)
        _townHomeRPTimerHandle = nil
    end

    local curTitle = FairSoloTournament_Model.GetCurMatchTimeID()
    if curTitle >= FairSoloTournament_Model.Enum_BigStage.FairScreening
            and curTitle <= FairSoloTournament_Model.Enum_BigStage.FairFinals then
        local timeCfg = DataSheetManager.FairMatchTime:GetDataByID(curTitle)
        if UTL.Time.IsServerInOpeningTime(timeCfg.StartTime, timeCfg.EndTime) then
            _townHomeRPTimerHandle = TimerUtil.Interval(private.UpdateTownHomeRP, UTL.Time.GetServerIntervalTimeByTimeId(timeCfg.StartTime) + UTL.Time.TotalSecondsOneDay, 1)
        else
            _townHomeRPTimerHandle = TimerUtil.Interval(private.UpdateTownHomeRP, UTL.Time.GetServerIntervalTimeByTimeId(timeCfg.StartTime), 1)
        end
    end
end

function FairSoloTournament_Model.GetGroupCompetitionId()
    return private.groupCompetitionId
end

function FairSoloTournament_Model.IsGroupCompetitionFinish()
    local stageId = FairSoloTournament_Model.GetCurStageID()
    if stageId > FairSoloTournament_Model.ConfigStage.Group_2 then
        return true
    end
    if stageId == FairSoloTournament_Model.ConfigStage.Group_2 then
        local stageInfo = FairSoloTournament_Model.GetStageInfo(stageId)
        if stageInfo then
            return stageInfo.state >= FairSoloTournament_Model.Enum_State.Finish
        end
    end
    return false
end

function FairSoloTournament_Model.IsNo1Generated()
    local stageId = FairSoloTournament_Model.GetCurStageID()
    if stageId == FairSoloTournament_Model.ConfigStage.Display then
        return true
    end
    if stageId == FairSoloTournament_Model.ConfigStage.Finals_2T1 then
        local stageInfo = FairSoloTournament_Model.GetStageInfo(stageId)
        if stageInfo then
            return stageInfo.state >= FairSoloTournament_Model.Enum_State.Finish
        end
    end
    return false
end

function private.SetModuleInfo(info)
    private.moduleInfo = info
    private.SetStageInfos(info.stageInfo)
    if info.seasonId == 0 then
        CTL.FairSoloTournament.CloseAllOnSeasonEnd()
    end
    private.InitDelayOpenEntryTimer()
    EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshModuleInfo)
end

function private.SetStageInfos(stageInfo)
    private.stageInfoDict[stageInfo.stageId] = stageInfo
    EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshStageInfo)
end

function private.SetMyInfo(myInfo)
    private.myInfo = myInfo
    private.groupCompetitionId = myInfo.classId
    if #myInfo.banHeroId > 0 then
        FairSoloTournament_Model.SetSeasonPlayerValue("banHeroId", myInfo.banHeroId[1])
    end
    EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshMyInfo)
end

function private.SetQuizInfo(quizInfo)
    private.quizBetInfoArray = quizInfo
    EventSystem.Dispatch(EventID.UI_FairTournament_RefreshQuizInfo)
end

function FairSoloTournament_Model.SetTaskInfo(taskInfos)
    private.taskInfoArray = taskInfos
    --处理任务红点
    CTL.FairSoloTournament.RefreshTaskRed()
    EventSystem.Dispatch(EventID.UI_FairSoloTournament_UpdateTask)
end

function FairSoloTournament_Model.GetGuessingInfo()
    local guessingInfo = {}
    for _, guessCfg in DataSheetManager.FairMatchTalkGuess:GetEnumerator() do
        for _, guessServer in ipairs(private.quizBetInfoArray) do
            if guessServer.questionId == guessCfg.ID then
                table.insert(guessingInfo, { serverInfo = guessServer, guessCfg = guessCfg })
                break
            end
        end
    end
    table.sort(guessingInfo, private.GuessingSort)
    return guessingInfo
end

function FairSoloTournament_Model.GetTaskInfo()
    return private.taskInfoArray
end

function private.RefreshUnLockFunc(funcID, isUnlock)
    if funcID == MDL.Unlock.FunctionType.FairSoloTournament then
        if not isUnlock then
            CTL.FairSoloTournament.CloseAllOnSeasonEnd()
        else
            CTL.FairSoloTournament.RefreshActivityRed()
        end
    end
end

--获取阶段信息
function FairSoloTournament_Model.FairTournamentGetStageInfoReq(stage)
    local msg = fair_tournament_opt_pb.FairTournamentGetStageInfoReq()
    msg.stage = stage
    NetManager.SendMessage(MessageEnums.MessageFairTournamentGetStageInfo, msg)
end

function private.OnFairTournamentGetStageInfoResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetStageInfos(msgResp.info)
    end
end

function FairSoloTournament_Model.FairTournamentOpenReq()
    local msg = fair_tournament_opt_pb.FairTournamentOpenReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentOpen, msg)
end

function private.OnFairTournamentOpenResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetModuleInfo(msgResp.info.info)
        private.SetMyInfo(msgResp.info.myInfo)
    end
end

--获取小组赛数据
function FairSoloTournament_Model.FillGroupCompetitionInfo(infoList, group)
    local curStage = math.min(FairSoloTournament_Model.GetCurStageID(), FairSoloTournament_Model.ConfigStage.Group_2)
    local stageInfo = FairSoloTournament_Model.GetStageInfo(curStage)
    if group == 0 then
        for _, groupInfo in ipairs(stageInfo.groupInfos) do
            local sortNum = private.GetRecommendSortNum(groupInfo)
            if sortNum ~= INVALID_SORT_NUM then
                table.insert(infoList, groupInfo)
            end
        end
        table.sort(infoList, private.SortByRecommendRule)
    else
        for _, groupInfo in ipairs(stageInfo.groupInfos) do
            if CTL.FairSoloTournament.ParseGroupID(groupInfo.groupId) == group then
                table.insert(infoList, groupInfo)
            end
        end
    end
end

--判断缓存数据内是否有展示信息，不满足则请求FairTournamentGetAllPlayerInfoReq
--group 小组赛第几组 0表示推荐
function FairSoloTournament_Model.TryGetAllPlayerInfo(stage, group)
    local isIncludeAll = true
    local stageInfo = private.stageInfoDict[stage]
    if stageInfo then
        for _, groupInfo in ipairs(stageInfo.groupInfos) do
            if (group == nil or group == 0 or (CTL.FairSoloTournament.ParseGroupID(groupInfo.groupId) == group)) then
                for _, playerInfo in ipairs(groupInfo.playerInfos) do
                    if string.isNilOrEmpty(playerInfo.acid) == false then
                        if private.allPlayerShowInfoDict[playerInfo.acid] == nil then
                            --这里先给k-v表赋值，防止服务器出bug，出现死循环
                            private.allPlayerShowInfoDict[playerInfo.acid] = false
                            isIncludeAll = false
                            break
                        end
                    end
                end
            end
        end
    else
        FairSoloTournament_Model.FairTournamentGetStageInfoReq(stage)
        isIncludeAll = false
    end
    if isIncludeAll == false then
        FairSoloTournament_Model.TryFairTournamentGetAllPlayerInfoReq(true)
    end
    --返回是否有请求allPlayer
    return not isIncludeAll
end

function FairSoloTournament_Model.TryFairTournamentGetAllPlayerInfoReq(isForce)
    if isForce then
        private.FairTournamentGetAllPlayerInfoReq()
    else
        if table.getDictCount(private.allPlayerShowInfoDict) == 0 or UTL.Time.GetServerTimestamp() - private.getAllPlayerInfoTimestamp >= CONST_INTERVAL_GETPLAYER then
            private.FairTournamentGetAllPlayerInfoReq()
        end
    end
end

function private.FairTournamentGetAllPlayerInfoReq()
    private.getAllPlayerInfoTimestamp = UTL.Time.GetServerTimestamp()
    local msg = fair_tournament_opt_pb.FairTournamentGetAllPlayerInfoReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentGetAllPlayerInfo, msg)
end

function private.OnFairTournamentGetAllPlayerInfoResp(msgResp)
    if msgResp.Resp.Code == 0 then
        --优化：没必要每次返回都排序，因为1v1排名已经确定不会再改变
        if private.hotAdvanceDict == nil then
            private.hotAdvanceDict = {}
            --不允许对proto数组排序，建一个table排
            local sortedList = {}
            for _, v in ipairs(msgResp.infos) do
                private.allPlayerShowInfoDict[v.acid] = v
                table.insert(sortedList, v)
            end
            table.sort(sortedList, private.SortBySyncSoloRank)
            for i = 1, #sortedList do
                if i <= CONST_HOT_NUM then
                    private.hotAdvanceDict[sortedList[i].acid] = i
                else
                    break
                end
            end
        else
            for _, v in ipairs(msgResp.infos) do
                private.allPlayerShowInfoDict[v.acid] = v
            end
        end
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshPlayerInfo)
    end
end

function FairSoloTournament_Model.GetIfHotAdvance(acid)
    if private.hotAdvanceDict then
        return private.hotAdvanceDict[acid] ~= nil
    end
    return false
end

function FairSoloTournament_Model.GetHotAdvanceRankIndex(acid)
    if private.hotAdvanceDict then
        return private.hotAdvanceDict[acid] or INVALID_SORT_NUM
    end
    return INVALID_SORT_NUM
end

function private.OnG2CPushFairTournamentStageChange(msgResp)
    if msgResp and msgResp.info.seasonId > 0 then
        private.SetModuleInfo(msgResp.info)
        if private.lastStageID > 0 and msgResp.info.curStage ~= private.lastStageID then
            --匹配场景中，切阶段时自动打开主界面
            if BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.CrossFairSoloTournamentTown) or BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.SingleFairSoloTournamentTown) then
                CTL.FairSoloTournament.OpenMain()
            elseif BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.SyncFairSoloTournament) then
                CTL.HomeMain.AddTownHomeDelayFunc(CTL.FairSoloTournament.TryOpenMain)
            end
        end
        private.lastStageID = msgResp.info.curStage
        private.OnStageBattleStateChanged(msgResp.info.stageInfo)
    elseif msgResp.info.seasonId == 0 then
        private.moduleInfo.seasonId = 0
        CTL.FairSoloTournament.CloseAllOnSeasonEnd()
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_RefreshModuleInfo)
    end
end

--处理roll点、bp界面的自动弹出
function private.OnStageBattleStateChanged(stageInfo)
    if stageInfo.stageId > FairSoloTournament_Model.ConfigStage.Prepare and stageInfo.stageId ~= FairSoloTournament_Model.ConfigStage.Display then
        if BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.CrossFairSoloTournamentTown) or BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.SingleFairSoloTournamentTown) then
            local myAcid = BattleDataGetter.GetAcID()
            local myGroupInfo
            for i, v in ipairs(stageInfo.groupInfos) do
                local acid_1 = v.playerInfos[1].acid
                local acid_2 = v.playerInfos[2].acid
                if string.isNilOrEmpty(acid_1) == false and string.isNilOrEmpty(acid_2) == false and (acid_1 == myAcid or acid_2 == myAcid) then
                    myGroupInfo = v
                    break
                end
            end
            if myGroupInfo and CTL.FairSoloTournament.CheckBattleGroupEnd(myGroupInfo) == false then
                local groupState = FairSoloTournament_Model.GetBattleGroupState(myGroupInfo)
                if groupState ~= FairSoloTournament_Model.Enum_State.Finish then
                    if stageInfo.state == FairSoloTournament_Model.Enum_State.Roll then
                        local acid_1 = myGroupInfo.playerInfos[1].acid
                        local acid_2 = myGroupInfo.playerInfos[2].acid
                        local leftAcid, rightAcid
                        if myAcid == acid_1 then
                            leftAcid = acid_1
                            rightAcid = acid_2
                        else
                            leftAcid = acid_2
                            rightAcid = acid_1
                        end
                        CTL.FairSoloTournament.OpenRoll(leftAcid, rightAcid, myGroupInfo.groupId, stageInfo.stateEndTime - UTL.Time.GetServerTimestamp())
                        return
                    elseif stageInfo.state == FairSoloTournament_Model.Enum_State.BanPick then
                        CTL.FairSoloTournament.OpenBanPick(myGroupInfo.groupId, myGroupInfo.turn, stageInfo.stateEndTime, false)
                        return
                    end
                end
                if stageInfo.state == FairSoloTournament_Model.Enum_State.Roll or stageInfo.state == FairSoloTournament_Model.Enum_State.BanPick then
                    logging.error(LTAG.ERROR, "[天下会武]没在bp或者roll阶段弹出对应界面", stageInfo.state, myGroupInfo.isBattleEnd, myGroupInfo.groupId, stageInfo.stateEndTime, UTL.Time.GetServerTimestamp())
                end
            end
        end
    end
    --小组赛结束时在打开界面的时候要刷新胜场数
    if stageInfo.stageId == FairSoloTournament_Model.ConfigStage.Group_1 or stageInfo.stageId == FairSoloTournament_Model.ConfigStage.Group_2 then
        if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIFairSoloTournamentBase) and stageInfo.state == FairSoloTournament_Model.Enum_State.Matching then
            MDL.FairSoloTournament.FairTournamentGetClassPlayerInfoReq()
        end
    end
end

--获取对战小组状态
function FairSoloTournament_Model.GetBattleGroupState(groupInfo)
    local stageInfo = FairSoloTournament_Model.GetStageInfo(FairSoloTournament_Model.GetCurStageID())
    if stageInfo.state == FairSoloTournament_Model.Enum_State.Battle then
        if groupInfo.isBattleEnd then
            --战斗是否结束 仅当阶段状态为战斗中时读取，其余状态和阶段状态保持一致
            return FairSoloTournament_Model.Enum_State.Finish
        else
            return FairSoloTournament_Model.Enum_State.Battle
        end
    end
    return stageInfo.state
end

--个人信息推送，一般用于打完战斗后，玩家个人信息推送
function private.OnG2CPushFairTournamentPlayerInfo(msgResp)
    private.SetMyInfo(msgResp.myInfo)
end

--获取全部竞猜题目信息
function FairSoloTournament_Model.FairTournamentGetAllQuizInfoReq()
    local msg = fair_tournament_opt_pb.FairTournamentGetAllQuizInfoReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentGetAllQuizInfo, msg)
end

function private.OnFairTournamentGetAllQuizInfoResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetQuizInfo(msgResp.quizInfo)
    end
end

--战斗押注
function FairSoloTournament_Model.FairTournamentBattleBetReq(stageId, groupId, betAcid, betNum)
    local msg = fair_tournament_opt_pb.FairTournamentBattleBetReq()
    msg.stageId = stageId
    msg.groupId = groupId
    msg.betAcid = betAcid
    msg.betNum = betNum
    NetManager.SendMessage(MessageEnums.MessageFairTournamentBattleBet, msg)
end

function private.OnFairTournamentBattleBetResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetMyInfo(msgResp.myInfo)
    end
end

--竞猜押注
function FairSoloTournament_Model.FairTournamentQuizBetReq(questionId, optionId, betNum)
    local msg = fair_tournament_opt_pb.FairTournamentQuizBetReq()
    msg.questionId = questionId
    msg.optionId = optionId
    msg.betNum = betNum
    NetManager.SendMessage(MessageEnums.MessageFairTournamentQuizBet, msg)
end

function private.OnFairTournamentQuizBetResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.SetQuizInfo(msgResp.quizInfo)
    end
end

function private.OnG2CPushFairTournamentNeedLeave(msgResp)
    if msgResp.isBye then
        CTL.FairSoloTournament.OnBattleGroupBye(msgResp.groupId)
    else
        --收到推送，直接返回洛阳
        CTL.FairSoloTournament.QuitFromLobby()
    end
end

function FairSoloTournament_Model.C2GFairTournamentBP(groupId, dice, banArray, pickArray)
    local msg = fair_tournament_opt_pb.C2GFairTournamentBP()
    msg.GroupID = groupId
    msg.Dice = dice
    if banArray and #banArray > 0 then
        for i, v in ipairs(banArray) do
            msg.BanHero:append(v)
        end
    end
    if pickArray and #pickArray > 0 then
        for i, v in ipairs(pickArray) do
            local id, isAwaken = CTL.HeroAwaken.DecodeHeroId(v)
            msg.PickHero:append(id)
            msg.PickHeroAwaken:append(isAwaken)
        end
    end
    NetManager.SendMessage(MessageEnums.MessageC2GFairTournamentBP, msg)
end

function private.OnG2CPushFairTournamentBPInfo(msgResp)
    for i, info in ipairs(msgResp.BPInfo) do
        private.PreprocessPickHero(info)
    end
    EventSystem.Dispatch(EventID.UI_FairSoloTournament_NoticeBPInfo, msgResp.BPInfo)
end

function private.PreprocessPickHero(info)
    for i, heroId in ipairs(info.PickHero) do
        if info.PickHeroAwaken[i] then
            info.PickHero[i] = CTL.HeroAwaken.EncodeHeroId(heroId)
        end
    end
end

-- 发送战斗结果
function private.SendBattleResult(msg)
    NetManager.SendMessage(MessageEnums.MessageC2GUploadFairTournamentBattleResult, msg)
end

-- 收到战斗结果
function private.OnG2CPushFairTournamentBattleResult(msgResp)
    if BattleDataGetter.IsInLevelWatchBattle() and not BattleDataGetter.HadStopLevel() then
        private.watchBattleSummary = msgResp
    else
        CTL.FairSoloTournament.OnBattleResultPush(msgResp)
    end
end

function private.OnWatchBattleOver(isClickExitBtn)
    if BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.SyncFairSoloTournament) then
        if private.watchBattleSummary then
            CTL.FairSoloTournament.OnBattleResultPush(private.watchBattleSummary)
            private.watchBattleSummary = nil
        else
            if not isClickExitBtn then-- 是否是按下退出按钮退出 。处理case：关卡结束时不是玩家点击退出而是自然看完且未收到服务器的战斗结果，此时不能被卡在关卡内要主动离开。
                EventSystem.Dispatch(EventID.Level_SendRoleLeaveFuben ,true)
            end
        end
    end
end

function FairSoloTournament_Model.FairTournamentTaskInfoReq()
    local msg = fair_tournament_opt_pb.FairTournamentTaskInfoReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentTaskInfo, msg)
end

function private.OnFairTournamentTaskResp(msgResp)
    if msgResp.Resp.Code == 0 then
        FairSoloTournament_Model.SetTaskInfo(msgResp.taskInfos)
    end
end

function FairSoloTournament_Model.FairTournamentTaskRewardReq(taskId)
    local msg = fair_tournament_opt_pb.FairTournamentTaskRewardReq()
    msg.fairTournamentId = taskId
    NetManager.SendMessage(MessageEnums.MessageFairTournamentTaskReward, msg)
end

function private.OnFairTournamentTaskRewardResp(msgResp)
    if msgResp.Resp.Code == 0 then
        FairSoloTournament_Model.FairTournamentTaskInfoReq()
    end
end

function FairSoloTournament_Model.FairTournamentBPWatchReq(watchType, groupId, turn, acid)
    if watchType == FairSoloTournament_Model.WATCHTYPE_WATCH then
        --观战
        private.watchParam = { groupId = groupId, round = turn, acid = acid }
    else
        --取消观战
        FairSoloTournament_Model.ClearWatchParam()
    end
    local msg = fair_tournament_opt_pb.FairTournamentBPWatchReq()
    msg.groupId = groupId
    msg.watchType = watchType
    NetManager.SendMessage(MessageEnums.MessageFairTournamentBPWatch, msg)
end

function private.OnFairTournamentBPWatchResp(msgResp)
    if msgResp.Resp.Code == 0 then
        if private.watchParam then
            local stageInfo = FairSoloTournament_Model.GetStageInfo(FairSoloTournament_Model.GetCurStageID())
            CTL.FairSoloTournament.OpenBanPick(private.watchParam.groupId, private.watchParam.round, stageInfo.stateEndTime, true, private.watchParam.acid)
        end
    end
end

function FairSoloTournament_Model.FairTournamentThumbsUpReq()
    local msg = fair_tournament_opt_pb.FairTournamentThumbsUpReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentThumbsUp, msg)
end

function private.OnFairTournamentThumbsUpResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_UpdateThumbsUpParam, msgResp.thumbsUpNum, msgResp.todayMyNum)
    end
end

function FairSoloTournament_Model.FairTournamentGetFamousReq()
    local msg = fair_tournament_opt_pb.FairTournamentGetFamousReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentGetFamous, msg)
end

function private.OnFairTournamentGetFamousResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_UpdateFamousInfo, msgResp.info.seasonFamous)
    end
end

function FairSoloTournament_Model.FairTournamentGetClassPlayerInfoReq()
    local msg = fair_tournament_opt_pb.FairTournamentGetClassPlayerInfoReq()
    NetManager.SendMessage(MessageEnums.MessageFairTournamentGetClassPlayerInfo, msg)
end

function private.OnFairTournamentGetClassPlayerInfoResp(msgResp)
    if msgResp.Resp.Code == 0 then
        for i, info in ipairs(msgResp.infos) do
            local playerInfo = private.allPlayerShowInfoDict[info.acid]
            if playerInfo then
                playerInfo.classWinNum = info.classWinNum
                playerInfo.defeatNum = info.defeatNum
            end
        end
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_UpdateClassPlayerInfo)
    end
end

function FairSoloTournament_Model.GetWatchParam()
    return private.watchParam
end

function FairSoloTournament_Model.ClearWatchParam()
    private.watchParam = nil
end

--获取当天的最大竞猜次数
--小组赛之后，需要判断是否处于阶段结束时间的同一天，且过了5点半，才可取该阶段的次数，否则应该取上一个阶段的次数
function FairSoloTournament_Model.GetTodayGuessingMaxTimes()
    local curTitle = FairSoloTournament_Model.GetCurMatchTimeID()
    if curTitle == FairSoloTournament_Model.Enum_BigStage.FairScreening then
        return DataSheetManager.FairMatchTime:GetDataByID(curTitle).GuessTimes
    else
        local curStageId = FairSoloTournament_Model.GetCurStageID()
        local stageInfo = FairSoloTournament_Model.GetStageInfo(curStageId)
        local targetTime = UTL.Time.GetDayStartTimestamp(stageInfo.stateEndTime)
        if UTL.Time.GetServerTimestamp() >= targetTime then
            return DataSheetManager.FairMatchTime:GetDataByID(curTitle).GuessTimes
        else
            --拿到上一个stage
            local lastStage = FairSoloTournament_Model.ConfigStage.Group_2
            for stage = FairSoloTournament_Model.ConfigStage.Finals_128T64, FairSoloTournament_Model.ConfigStage.Finals_2T1, -100 do
                if stage == curStageId then
                    break
                else
                    lastStage = stage
                end
            end
            local title = DataSheetManager.FairMatchStage:GetDataByID(lastStage).NowStage
            return DataSheetManager.FairMatchTime:GetDataByID(title).GuessTimes
        end
    end
end

--按照胜场数排序
function private.SortByWinNum(playerInfo_1, playerInfo_2)
    local winNum_1 = FairSoloTournament_Model.GetPlayerGroupWinNum(playerInfo_1.acid)
    local winNum_2 = FairSoloTournament_Model.GetPlayerGroupWinNum(playerInfo_2.acid)
    return winNum_1 > winNum_2
end

function private.GuessingSort(guessingA, guessingB)
    return guessingA.guessCfg.SortId < guessingB.guessCfg.SortId
end

function private.SortBySyncSoloRank(info_1, info_2)
    local rank_1 = FairSoloTournament_Model.GetPlayerSyncSoloRank(info_1.acid)
    local rank_2 = FairSoloTournament_Model.GetPlayerSyncSoloRank(info_2.acid)
    return rank_1 < rank_2
end

--获取groupInfo推荐排序权重值
function private.GetRecommendSortNum(groupInfo)
    local myAcid = BattleDataGetter.GetAcID()
    --自己
    if groupInfo.playerInfos[1].acid == myAcid or groupInfo.playerInfos[2].acid == myAcid then
        return 0
    end
    --小组赛竞猜过
    if MDL.FairSoloTournament.GetGuessingInfoByGroupID_ACID(nil, groupInfo.playerInfos[1].acid, true) or MDL.FairSoloTournament.GetGuessingInfoByGroupID_ACID(nil, groupInfo.playerInfos[2].acid, true) then
        return 1
    end
    --同势力
    local showInfo_1 = FairSoloTournament_Model.GetPlayerShowInfo(groupInfo.playerInfos[1].acid)
    if showInfo_1 and MDL.Guild.IsSameGuild(showInfo_1.guildId) then
        return 2
    end
    local showInfo_2 = FairSoloTournament_Model.GetPlayerShowInfo(groupInfo.playerInfos[2].acid)
    if showInfo_2 and MDL.Guild.IsSameGuild(showInfo_2.guildId) then
        return 2
    end
    --同服
    local myServer = MDL.Login.GetServerShowId()
    if showInfo_1 and showInfo_1.ShowServerId == myServer then
        return 3
    end
    if showInfo_2 and showInfo_2.ShowServerId == myServer then
        return 3
    end
    --同战区
    if showInfo_1 and showInfo_1.IsSameWarZone then
        return 4
    end
    if showInfo_2 and showInfo_2.IsSameWarZone then
        return 4
    end
    --热门
    if FairSoloTournament_Model.GetIfHotAdvance(groupInfo.playerInfos[1].acid) or FairSoloTournament_Model.GetIfHotAdvance(groupInfo.playerInfos[2].acid) then
        return 5
    end
    return INVALID_SORT_NUM
end

--自己、同势力-同服-同战区、热门
function private.SortByRecommendRule(groupInfo_1, groupInfo_2)
    local sort_1 = private.GetRecommendSortNum(groupInfo_1)
    local sort_2 = private.GetRecommendSortNum(groupInfo_2)
    if sort_1 == sort_2 then
        --相同页签，按1v1排名排
        local rank_1 = math.min(FairSoloTournament_Model.GetHotAdvanceRankIndex(groupInfo_1.playerInfos[1].acid), FairSoloTournament_Model.GetHotAdvanceRankIndex(groupInfo_1.playerInfos[2].acid))
        local rank_2 = math.min(FairSoloTournament_Model.GetHotAdvanceRankIndex(groupInfo_2.playerInfos[1].acid), FairSoloTournament_Model.GetHotAdvanceRankIndex(groupInfo_2.playerInfos[2].acid))
        return rank_1 < rank_2
    end
    return sort_1 < sort_2
end

--当前是否是冠军产生第二天5点
function FairSoloTournament_Model.IsNo1GeneratedNextDay()
    if FairSoloTournament_Model.IsNo1Generated() then
        local startTimestamp = FairSoloTournament_Model.GetModuleInfo().startTm
        local sumDays = 0
        for k, v in DataSheetManager.FairMatchTime:GetEnumerator() do
            if v.ID < MDL.FairSoloTournament.Enum_BigStage.FairDisplay then
                sumDays = sumDays + v.Day
            end
        end
        local targetTimestamp = UTL.Time.GetDayStartTimestamp(startTimestamp + sumDays * UTL.Time.TotalSecondsOneDay)
        return UTL.Time.GetServerTimestamp() >= targetTimestamp
    end
    return false
end

--获取玩家小组赛在第几个小组
function FairSoloTournament_Model.GetPlayerGroup(acid)
    local curStage = math.min(FairSoloTournament_Model.GetCurStageID(), FairSoloTournament_Model.ConfigStage.Group_2)
    local stageInfo = FairSoloTournament_Model.GetStageInfo(curStage)
    if stageInfo then
        for _, groupInfo in ipairs(stageInfo.groupInfos) do
            for _, playerInfo in ipairs(groupInfo.playerInfos) do
                if playerInfo.acid == acid then
                    return CTL.FairSoloTournament.ParseGroupID(groupInfo.groupId)
                end
            end
        end
    end
    return nil
end

return FairSoloTournament_Model