local SyncSolo_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local fairplay_solo_pb = require 'Proto.fairplay_solo_pb'
local fairplay_tvt_pb = require 'Proto.fairplay_tvt_pb'
local SyncSoloFormationKey = "SyncSoloFormationKey"
local SyncSoloLevelRankKey = "SyncSoloLevelRankKey"
local SyncSoloUsingExperienceCard = "SyncSoloUsingExperienceCard"

--奖励状态
SyncSolo_Model.RewardState = {
    NotReach = 0, --未完成
    NotGet = 1,   --未领取
    Get = 2,      --已领取
}

function SyncSolo_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageFairPlaySoloOpen, private.SyncSoloOpenResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushSyncSoloBattleResult, private.SyncSoloBattleOverResultPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CFairPlayHistoryLegendary, private.SyncSoloToTopRank)

    NetManager.RegisterMsgCB(MessageEnums.MessageFairSoloGetDailyReward, private.FairSoloGetDailyRewardResp) --领取每日首胜奖励
    NetManager.RegisterMsgCB(MessageEnums.MessageFairSoloGetWeeklyReward, private.FairSoloGetWeeklyRewardResp) --领取每周任务奖励
    NetManager.RegisterMsgCB(MessageEnums.MessageFairSoloWeeklyTaskRefresh, private.FairSoloWeeklyTaskRefreshResp) --刷新每周任务
    NetManager.RegisterMsgCB(MessageEnums.MessageGetFairSoloWinNumReward, private.GetFairSoloWinNumRewardResp) --刷新胜场奖励
    
    
    EventSystem.Regist(EventID.SyncSolo_BattleResult, private.SendBattleResult)
    private.syncSoloSeasonInfo = {}
    private.syncSoloRank = 0
    private.syncSoloElo = nil
    private.syncSoloActivityId = 0
    private.syncSoloHistoryDan = 0
    private.syncSoloRewardDan = 0
    private.syncSoloCurNum = 0
    private.syncSoloCurDan = 0
    private.syncSoloLastDan = 0
    private.syncSoloLastSeasonDan = 0
    private.syncSoloFairPlayState = 0
    private.fairSoloTournamentNo1Info = nil
    private.isFairTournamentFamous = false
    private.syncSoloWinInfo = {}
    --最高段位推送
    private.syncSolodan = 0
end

-- 发送战斗结果的请求 
function private.SendBattleResult(msg)
    logging.warn(LTAG.CRIT, "[C-G]SyncSolo : SendBattleResult")
    NetManager.SendMessage(MessageEnums.MessageC2GUploadSyncSoloBattleResult,msg)
end

function SyncSolo_Model.GetSyncSoloRank()
    return private.syncSoloRank
end
--获取当前的积分
function SyncSolo_Model.GetSyncSoloEloPoint()
    return private.syncSoloElo
end
--获取当前赛季信息
function SyncSolo_Model.GetSyncSoloSeasonInfo()
    return private.syncSoloSeasonInfo
end
--获取历史最高段位
function SyncSolo_Model.GetSyncSoloHistoryDan()
    return private.syncSoloHistoryDan
end
--获取段位奖励领到了哪些奖励
function SyncSolo_Model.GetSyncSoloRewardDan()
    return private.syncSoloRewardDan
end
--当前赛季的参与次数
function SyncSolo_Model.GetSyncSoloCurNum()
    return private.syncSoloCurNum
end
--获取这次打开页面的段位
function SyncSolo_Model.GetSyncSoloCurDan()
    if private.syncSolodan ~= 0 then
        private.syncSoloCurDan = private.syncSolodan
    end
    return private.syncSoloCurDan
end
--获取最高段位
function SyncSolo_Model.GetSyncSoloTopRank()
    if private.syncSolodan ~= 0 then
        return private.syncSolodan
    end
    return 0
end
--获取上次页面的段位
function SyncSolo_Model.GetSyncSoloLastDan()
    return private.syncSoloLastDan
end

--获取上赛季的段位
function SyncSolo_Model.GetSyncSoloLastSeasonDan()
    return private.syncSoloLastSeasonDan
end

function SyncSolo_Model.GetSyncSoloFairPlayState()
    return private.syncSoloFairPlayState
end

-- 获取当前状态需要达到排名
function SyncSolo_Model.GetSoloLevelRank()
    return CTL.FairPlay.GetLevelRankByFairPlayState(private.syncSoloFairPlayState)
end

function SyncSolo_Model.SetSyncSoloRank(rank)
    private.syncSoloRank = rank
end

function SyncSolo_Model.SetSyncSoloEloPoint(point)
    private.syncSoloElo = point
end

function SyncSolo_Model.GetSyncSoloState()
    return private.syncSoloState
end

--登录游戏时发的信息
function SyncSolo_Model.UpdateSyncSoloSeasonInfo(info)
    private.syncSoloSeasonInfo = info
    private.syncSoloHistoryDan = info.historyDan >= 0 and info.historyDan or private.syncSoloHistoryDan
    private.syncSoloRewardDan = info.rewardDan >= 0 and info.rewardDan or private.syncSoloRewardDan
    private.syncSoloCurNum = info.curNum
    private.syncSoloState = info.seasonState
    private.syncSoloElo = private.syncSoloElo or info.eloPoint
    private.syncSoloFairPlayState = info.state -- 当前状态
    
    private.syncSoloWinInfo.winNum = info.winNum -- 本赛季胜场数
    private.syncSoloWinInfo.maxReceivedRewardID = private.GetMaxReceivedWinCountRewardID(info.rewardWinNum) -- 胜场奖励最大领取数ID
    EventSystem.Dispatch(EventID.UI_FairPlay_SyncSoloSeasonInfoUpdate)
end

function SyncSolo_Model.GetNextTime()
    local endTime = private.syncSoloSeasonInfo.endTime
    return os.difftime(endTime, UTL.Time.GetServerTimestamp())
end

function SyncSolo_Model.IsSeasonOpen()
    return private.syncSoloSeasonInfo.seasonState == MDL.FairPlay.SeasonState.SeasonOpening
end

function SyncSolo_Model.GetSeasonId()
    return private.syncSoloSeasonInfo.curSeasonId
end

function SyncSolo_Model.SaveSyncSoloFormation(formationList)
    PersistentData.PlayerData:Set(SyncSoloFormationKey, formationList, true)
end

function private.FillCommonLineUpList(list)
    for i, heroId in ipairs(MDL.Player.GetHeroLinUpIds()) do
        if MDL.HeroAwaken.GetIsHeroAwaken(heroId) then
            list[i] = CTL.HeroAwaken.EncodeHeroId(heroId)
        else
            list[i] = heroId
        end
    end
end

---获取时校验，如果没有根据KEY获取到值，则要检查该赛季ID的上一个赛季所储存的值，清空。
function SyncSolo_Model.LoadSyncSoloFormation()
    local list = PersistentData.PlayerData:Get(SyncSoloFormationKey)
    if list == nil then
        list = {}
        private.FillCommonLineUpList(list)
        SyncSolo_Model.SaveSyncSoloFormation(list)
    else
        for _, heroId in ipairs(list) do
            local id, isAwaken = CTL.HeroAwaken.DecodeHeroId(heroId)
            if not SyncSolo_Model.IsHeroAvailable(id) or (isAwaken and MDL.HeroAwaken.GetIsHeroAwaken(id) == false) then
                --缓存的阵容有失效的，切换为上阵阵容
                private.FillCommonLineUpList(list)
                SyncSolo_Model.SaveSyncSoloFormation(list)
                break
            end
        end
    end
    return list
end

function SyncSolo_Model.SaveSyncSoloLevelRank()
    local key = SyncSoloLevelRankKey..BattleDataGetter.GetAcID()
    local levelRank = CTL.SyncSolo.GetSyncSoloLevelRank()
    PersistentData.DeviceData:Set(key, levelRank)
end

function SyncSolo_Model.LoadSyncSoloLevelRank()
    local oldKey = SyncSoloLevelRankKey..BattleDataGetter.GetAcID()
    local levelRank = PersistentData.DeviceData:Get(oldKey)
    if levelRank == 0 then
        SyncSolo_Model.SaveSyncSoloLevelRank()
        levelRank = CTL.SyncSolo.GetSyncSoloLevelRank()
    end
    return levelRank
end

function SyncSolo_Model.GetMaxScore()
    local maxScore = 0
    for key, value in DataSheetManager.SyncSoloData:GetEnumerator() do
        if value.LevelRank == 0 and value.LevelScore > maxScore then
            maxScore = value.LevelScore
        end
    end
    return maxScore
end

function SyncSolo_Model.GetLevelByScore(score)
    if score <= 0 then
        return DataSheetManager.SyncSoloData:GetDataByLevelID(1)
    end
    local battleLevel = DataSheetManager.SyncSoloData:GetDataByLevelID(1)
    for key, value in DataSheetManager.SyncSoloData:GetEnumerator() do
        --不用考虑有名次要求的档位
        if value.LevelRank == 0 then
            if value.LevelScore > score then
                return battleLevel
            end
            battleLevel = value
        end
    end
    return battleLevel
end

function SyncSolo_Model.IsHeroAvailable(heroId)
    if MDL.HeroSelect.IsHasHero(heroId) then
        return true
    end
    -- 测试武将
    if SyncSolo_Model.CheckIsTestFreeHero(heroId) then
        return true
    end

    -- 限免武将
    if SyncSolo_Model.CheckIsTemporaryFreeHero(heroId) then
        return true
    end

    -- 体验卡武将
    local value = PersistentData.PlayerData:Get(SyncSoloUsingExperienceCard)
    if value == nil or value == true then
        if SyncSolo_Model.CheckIsExperienceFreeHero(heroId) then
            PersistentData.PlayerData:Set(SyncSoloUsingExperienceCard, true, true)
            return true
        end
    end 

    return false
end

function SyncSolo_Model.ResetSyncSoloExperienceFormationKey()
    PersistentData.PlayerData:Set(SyncSoloUsingExperienceCard, true, true)
end

--- 检查武将是否是限免武将
function SyncSolo_Model.CheckIsTemporaryFreeHero(heroId)
    local freeHeroes = private.syncSoloSeasonInfo.freeHeroes
    for i, v in ipairs(freeHeroes) do
        local itemData = DataSheetManager.ItemData:GetDataByID(v)
        if heroId == itemData.BelongToHero then
            return true
        end
    end
    return false
end

--- 检查武将是否是体验卡武将
function SyncSolo_Model.CheckIsExperienceFreeHero(heroId)
    if UTL.Item.GetItemStockCount(CTL.FairPlayCard.experienceCardId) > 0 then
        local unactiveGoldenHeros = MDL.HeroSelect.GetUnactiveGoldenHeroData()
        for i, v in ipairs(unactiveGoldenHeros) do
            if heroId == v.ID then
                return true
            end
        end
    end
    return false
end

--region -------------------------- 1v1胜场奖励相关-----------------------------
function private.GetMaxReceivedWinCountRewardID(maxReceivedNum)
    local maxReceivedID = 0
    for i, v in DataSheetManager.SyncSoloSeasonWin:GetEnumerator() do
        if maxReceivedNum >= v.ID then
            maxReceivedID = v.ID
        end
    end
    return maxReceivedID
end

function SyncSolo_Model.GetSyncSoloWinInfo()
    return private.syncSoloWinInfo
end

--region

function SyncSolo_Model.DealWithSyncSoloMatch(activityID, state)
    MDL.TeamMatch.PlayerMatchOperateReq(activityID, state, nil, SyncSolo_Model.LoadSyncSoloFormation())
end

function SyncSolo_Model.SyncSoloOpenReq()
    local msg = fairplay_solo_pb.FairPlaySoloOpenReq()
    NetManager.SendMessage(MessageEnums.MessageFairPlaySoloOpen, msg)
end

function SyncSolo_Model.SyncSoloBattleMatchResultReceive(msg)
    if msg.needCountDown == true then
        --匹配返回时，什么情况下，可以打开匹配成功界面？这里在其他需要跳转场景的玩法处做判断，使用IsCanGoOtherScene
        UIManager.OpenView(Const_UI_Lua.UIEnum.UISyncSoloMatchSuccessPanel, msg)
    else
        if not UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UISyncSoloMatchSuccessPanel) then
            UIManager.OpenView(Const_UI_Lua.UIEnum.UISyncSoloMatchSuccessPanel, msg)
        end
    end
    EventSystem.Dispatch(EventID.UI_SyncSolo_MatchSuccess)
    if not MDL.FairPlayCard.GetIs1V1ContinuousUseExperienceCard() then
        PersistentData.PlayerData:Set(SyncSoloUsingExperienceCard, false, true)
    end
end

function private.SyncSoloOpenResp(msgResp)
    private.syncSoloRank = msgResp.playerRank
    private.syncSoloElo = msgResp.eloPoint
    private.syncSoloCurDan = msgResp.curDan
    private.syncSoloLastDan = msgResp.lastDan
    private.syncSoloLastSeasonDan = msgResp.lastSeasonDan
    private.syncSoloCurNum = msgResp.curNum
    private.syncSoloHistoryDan = msgResp.historyDan
    private.syncSoloRewardDan = msgResp.rewardDan
    private.fairSoloTournamentNo1Info = msgResp.basicInfo --天下会武冠军信息
    private.isFairTournamentFamous = msgResp.isFairTournamentFamous
    private.syncSoloWinInfo.winNum = msgResp.winNum -- 本赛季胜场数
    private.syncSoloWinInfo.maxReceivedRewardID = private.GetMaxReceivedWinCountRewardID(msgResp.rewardWinNum) -- 胜场奖励最大领取数ID
    
    EventSystem.Dispatch(EventID.UI_SyncSolo_RankRefresh)
    if IsServerDataNotNil(private.fairSoloTournamentNo1Info) then
        EventSystem.Dispatch(EventID.UI_FairSoloTournament_UpdateThumbsUpParam, msgResp.thumbsUpNum, msgResp.myThumbsUp)
    end
end

function SyncSolo_Model.GetFairSoloTournamentNo1Info()
    return private.fairSoloTournamentNo1Info
end

function SyncSolo_Model.GetIsFairTournamentFamous()
    return private.isFairTournamentFamous
end

-- 领取1v1赛季胜场奖励
function SyncSolo_Model.GetFairSoloWinNumRewardReq()
    local msg = fairplay_solo_pb.GetFairSoloWinNumRewardReq()
    NetManager.SendMessage(MessageEnums.MessageGetFairSoloWinNumReward, msg)
end

function private.GetFairSoloWinNumRewardResp(msgResp)
    private.syncSoloWinInfo.maxReceivedRewardID = private.GetMaxReceivedWinCountRewardID(msgResp.rewardWinNum)
    EventSystem.Dispatch(EventID.UI_SyncSolo_WinRewardRefresh)
    EventSystem.Dispatch(EventID.UI_SyncSolo_RefreshRedPoint)
    
end

function SyncSolo_Model.SyncSoloRewardReq()
    MDL.FairPlay.FairPlayRewardReq(LuaConst.ActivityType.SyncSolo)
end

--一键领取信息
function SyncSolo_Model.SyncSoloRewardResp(msgResp)
    private.syncSoloRewardDan = msgResp.rewardDan
    EventSystem.Dispatch(EventID.UI_SyncSolo_RankRefresh)
end

function private.SyncSoloBattleOverResultPush(msg)
    logging.log(LTAG.LOG, "收到SyncSolo战斗结算协议", msg)
    MDL.Level.TrySendBattleEvent()
    if LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.None and LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.FastPlay then
        EventSystem.Dispatch(EventID.BI_LevelMiddle,BIManager.BIType.SyncBattle,"[sync]1v1ResultAtBeforeBegin")
        NotSyncBattleSetter.StopCurLevel()
        LevelManager.SetLoadingLevelEnd()
    end
    BIManager.DispatchBIClientEvent(BIManager.EventName.SyncSoloFinish)
    CameraController.Instance:SetGray(false)
    UIManager.CloseAllBase()
    UIManager.OpenView(Const_UI_Lua.UIEnum.UISyncSoloBattleOverPanel, msg)
end

function private.SyncSoloToTopRank(msg)
    private.syncSolodan = msg.dan
end

--这块是赛季结束服务器数据
function SyncSolo_Model.SyncSoloPlayInfoPush(msg)
    private.syncSoloElo = msg.EloScore
    private.syncSoloActivityId = msg.activityId
    private.syncSoloHistoryDan = msg.historyDan >= 0 and msg.historyDan or private.syncSoloHistoryDan
    private.syncSoloRewardDan = msg.rewardDan >= 0 and msg.rewardDan or private.syncSoloRewardDan
    private.syncSoloCurNum = msg.curNum
    
    private.syncSoloWinInfo.winNum = msg.winNum
    private.syncSoloWinInfo.maxReceivedRewardID = private.GetMaxReceivedWinCountRewardID(msg.rewardWinNum) -- 胜场奖励最大领取数ID
    EventSystem.Dispatch(EventID.UI_FairPlay_SyncSoloEloScoreUpdate)
    if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UISyncSoloMainPanel) then
        SyncSolo_Model.SyncSoloOpenReq()
    end
end

function private.OnErrorConfirm()
    CameraController.Instance:SetGray(false)
    MDL.Level.SendRoleLeaveFuben()
end

function SyncSolo_Model.IsAchieveTargetLevel(levelID)
    if not levelID then
        return false
    end

    local syncSoloData = DataSheetManager.SyncSoloData:GetDataByLevelID(levelID)
    if not syncSoloData then
        return false
    end

    return private.syncSoloElo >= syncSoloData.LevelScore
end

--region 每日首胜、周奖励

--1v1公平竞技奖励信息
function SyncSolo_Model.SyncRewardInfo(fairPlaySoloRewardInfo)
    logging.log(LTAG.LOG,"SyncRewardInfo",fairPlaySoloRewardInfo)
    --每日首胜奖励状态 0未完成，1未领取，2已领取
    private.firstWinOfEveryDayState = fairPlaySoloRewardInfo.state
    --周奖励信息
    private.fairPlaySoloWeeklyRewardArray = fairPlaySoloRewardInfo.rewards
    
    EventSystem.Dispatch(EventID.UI_SyncSolo_RefreshRedPoint) --刷红点
    EventSystem.Dispatch(EventID.UI_FairPlay_RefreshDailyRewardUI)
    EventSystem.Dispatch(EventID.UI_FairPlay_SyncSoloSeasonInfoUpdate)
end

--领取1v1公平竞技每日首胜奖励 Req
function SyncSolo_Model.FairSoloGetDailyRewardReq()
    local msg = fairplay_solo_pb.FairSoloGetDailyRewardReq()
    NetManager.SendMessage(MessageEnums.MessageFairSoloGetDailyReward, msg)
end

--领取1v1公平竞技每日首胜奖励 Rsp
function private.FairSoloGetDailyRewardResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SyncSolo_RefreshRedPoint) --刷红点
        EventSystem.Dispatch(EventID.UI_FairPlay_RefreshDailyRewardUI)
        EventSystem.Dispatch(EventID.UI_FairPlay_SyncSoloSeasonInfoUpdate)
    end
end

--领取1v1公平竞技周奖励任务 Req
-- id 任务id
function SyncSolo_Model.FairSoloGetWeeklyRewardReq(id)
    local msg = fairplay_solo_pb.FairSoloGetWeeklyRewardReq()
    msg.id = id
    NetManager.SendMessage(MessageEnums.MessageFairSoloGetWeeklyReward, msg)
end

--领取1v1公平竞技周奖励任务 Rsp
function private.FairSoloGetWeeklyRewardResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SyncSolo_RefreshRedPoint) --刷红点
        EventSystem.Dispatch(EventID.UI_FairPlay_RefreshWeeklyRewardUI)
    end
end

--刷新周奖励任务 Req
--id 刷新前的任务id
function SyncSolo_Model.FairSoloWeeklyTaskRefreshReq(id)
    local msg = fairplay_solo_pb.FairSoloWeeklyTaskRefreshReq()
    msg.id = id
    private.beforeRefreshTaskId = id
    NetManager.SendMessage(MessageEnums.MessageFairSoloWeeklyTaskRefresh, msg)
end

--刷新周奖励任务 Rsp
function private.FairSoloWeeklyTaskRefreshResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SyncSolo_RefreshRedPoint) --刷红点
        EventSystem.Dispatch(EventID.UI_FairPlay_RefreshWeeklyRewardUI)
    end
end

--获取 周奖励信息
function SyncSolo_Model.GetWeeklyRewardArray()
    return private.fairPlaySoloWeeklyRewardArray
end

-- 获取每日首胜状态  0未完成，1未领取，2已领取
function SyncSolo_Model.GetFirstWinOfEveryDayState()
    return private.firstWinOfEveryDayState
end

--获取周任务总数量
function SyncSolo_Model.GetTotalWeeklyTaskNum()
    if private.fairPlaySoloWeeklyRewardArray then
        return #private.fairPlaySoloWeeklyRewardArray
    end
    return 0
end

--获取已经领取的周任务数量
function SyncSolo_Model.GetHasGetWeeklyTaskNum()
    if private.fairPlaySoloWeeklyRewardArray then
        local count = 0
        for i,v in ipairs(private.fairPlaySoloWeeklyRewardArray) do
            if v.state == SyncSolo_Model.RewardState.Get then
                count = count + 1
            end
        end
        return count
    end
    return 0
end

--endregion

--region ************************ 测试武将相关 *************************************
---@public 获取测试武将数据
function SyncSolo_Model.GetTestHeroArray()
    private.TestHeroOpenTimer = 0
    private.TestHeroCloseTimer = 0
    local testHeroOpenTimestamp = 0
    local testHeroCloseTimestamp = 0
    local SyncSoloTestHeroList = {}
    for _, testHeroData in MDL.OperationActivity.TVTTestHero:GetEnumerator() do
        if testHeroData.OneOnOne == 1 then
            if UTL.Time.IsServerInOpeningTime(testHeroData.OpenTime, testHeroData.CloseTime, true) then
                local closeTimer = UTL.Time.GetServerIntervalTimeByTimeId(testHeroData.CloseTime, true)
                if (testHeroCloseTimestamp == 0 and closeTimer > 0) or (closeTimer > 0 and closeTimer < testHeroCloseTimestamp) then
                    testHeroCloseTimestamp = closeTimer
                end
                table.insert(SyncSoloTestHeroList, testHeroData.HeroItemID)
            else
                local openTimer = UTL.Time.GetServerIntervalTimeByTimeId(testHeroData.OpenTime, true)
                if (testHeroOpenTimestamp == 0 and openTimer > 0) or (openTimer > 0 and openTimer < testHeroOpenTimestamp) then
                    testHeroOpenTimestamp = openTimer
                end
            end
        end
    end

    if testHeroOpenTimestamp > 0 then
        private.TestHeroOpenTimer = testHeroOpenTimestamp
    end
    if testHeroCloseTimestamp > 0 then
        private.TestHeroCloseTimer = testHeroCloseTimestamp
    end

    return SyncSoloTestHeroList
end

---@public 检查武将是否是测试武将且在测试时间，是否是测试武将，是否在活动时间
function SyncSolo_Model.CheckIsTestHero(heroItemId, isHeroId)
    local isTestHeroAndOpen, isTestHero, isOpen = false, false, false
    for _, testHeroData in MDL.OperationActivity.TVTTestHero:GetEnumerator() do
        local heroId = 0
        if isHeroId then
            heroId = testHeroData.HeroID
        else
            heroId = testHeroData.HeroItemID
        end
        if testHeroData.OneOnOne == 1 and heroId == heroItemId then
            isTestHero = true
            if UTL.Time.IsServerInOpeningTime( testHeroData.OpenTime,  testHeroData.CloseTime, true) then
                isOpen = true
            end
        end
    end
    isTestHeroAndOpen = isTestHero and isOpen

    return isTestHeroAndOpen, isTestHero, isOpen
end

---@public 获取测试武将刷新倒计时（取最接近当前时间的武将倒计时）
function SyncSolo_Model.GetTestHeroTimer()
    if private.TestHeroOpenTimer > 0 and private.TestHeroCloseTimer > 0 then
        return  private.TestHeroOpenTimer < private.TestHeroCloseTimer and private.TestHeroOpenTimer or private.TestHeroCloseTimer
    elseif private.TestHeroOpenTimer > 0 and private.TestHeroCloseTimer <= 0 then
        return private.TestHeroOpenTimer
    elseif private.TestHeroOpenTimer <= 0 and private.TestHeroCloseTimer > 0 then
        return private.TestHeroCloseTimer
    end
    return  0
end

---@public 检查武将是否是测试武将(heroId)
function SyncSolo_Model.CheckIsTestFreeHero(heroId)
    local testHeroArray = SyncSolo_Model.GetTestHeroArray()
    if #testHeroArray > 0 then
        for i, v in ipairs(testHeroArray) do
            local itemData = DataSheetManager.ItemData:GetDataByID(v)
            if heroId == itemData.BelongToHero then
                return true
            end
        end
    end
    return false
end
--endregion ************************ 测试武将相关 *************************************

return SyncSolo_Model