local GoldenHeroAnecdote_Controller = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local Infrast = require("Infrast/Infrast")

function GoldenHeroAnecdote_Controller.OnStartup()
    EventSystem.Regist(EventID.UI_GoldenHero_RefreshCurrency, GoldenHeroAnecdote_Controller.RefreshAnecdoteRp)

    private.ActivityType = MDL.OperationActivity.ActivityType.GoldenHero
    private.initRedPoint = {}
end

function GoldenHeroAnecdote_Controller.OpenAnecdoteView(activityId)
    if MDL.GoldenHeroMain.IsActivityInFuncTime(activityId) then
        UIManager.OpenAndPushAll(Const_UI_Lua.UIEnum.UIGoldenHeroAnecdote, {heroType = MDL.GoldenHeroMain.GetHeroTypeByActivityId(activityId), activityId = activityId})
    end
end

function GoldenHeroAnecdote_Controller.ShowBattleSummary(msg)
    CTL.HomeMain.CloseOpenView()
    UIManager.OpenView(Const_UI_Lua.UIEnum.UIGoldenHeroAnecdoteSummary, {Reward = msg.Resp.Rewards, isWin = msg.isWin, Time = msg.passTime}, "Common/UICommonSummary")
end

function GoldenHeroAnecdote_Controller.RefreshAnecdoteRp()
    local goldHeroInfo = MDL.OperationActivity.GetOperationActivityInfo(private.ActivityType)
    if goldHeroInfo then
        for activityId, v in pairs(goldHeroInfo) do
            if MDL.GoldenHeroAnecdote.GetAnecdoteInfo(activityId) then
                if private.initRedPoint[activityId] then
                    local redPointKey = CTL.GoldenHeroMain.RpEventId[activityId]
                    local isOpenActive = MDL.GoldenHeroMain.IsActivityInFuncTime(activityId)
                    MDL.RedPoint.UpdateNodeStateByLogicParams(GoldenHeroAnecdote_Controller.IsActivityHasLevelCanSweep(activityId) and isOpenActive, redPointKey.TownHome, redPointKey.AnecdoteSweep)
                    MDL.RedPoint.UpdateNodeStateByLogicParams(GoldenHeroAnecdote_Controller.IsHasNewAnecdote(activityId) and isOpenActive, redPointKey.TownHome, redPointKey.AnecdoteNew)
                    MDL.RedPoint.UpdateNodeStateByLogicParams(GoldenHeroAnecdote_Controller.IsActivityHasReward(activityId) and isOpenActive, redPointKey.TownHome, redPointKey.AnecdoteReward)
                    MDL.RedPoint.UpdateNodeStateByLogicParams(GoldenHeroAnecdote_Controller.IsHasEnergy(activityId) and isOpenActive, redPointKey.TownHome, redPointKey.AnecdoteHasEnergy)
                else
                    CTL.GoldenHeroMain.InitAnecdoteRedPointTreeByActivityId(activityId)
                    private.initRedPoint[activityId] = true
                end
            end
        end
    end
end

---@public 轶事关卡的消耗体力道具是否足够
function GoldenHeroAnecdote_Controller.IsEnergyEnough(activityId, anecdoteId)
    local levelCfg = DataSheetManager.GoldHeroActivityAnecdoteLevel:GetDataByID(anecdoteId)
    local hasNum = MDL.GoldenHeroStory.GetGoldHeroLevelCurrencyCountByActivityId(activityId)
    return hasNum >= levelCfg.EnergyNum
end

function GoldenHeroAnecdote_Controller.IsHasEnergy(activityId)
    local hasNum = MDL.GoldenHeroStory.GetGoldHeroLevelCurrencyCountByActivityId(activityId)
    return hasNum >= 1
end

function GoldenHeroAnecdote_Controller.IsLevelUnlock(activityId, anecdoteId)
    return MDL.GoldenHeroAnecdote.GetAnecdoteStateById(activityId, anecdoteId) >= MDL.GoldenHeroAnecdote.AnecdoteState.Unlock
end

function GoldenHeroAnecdote_Controller.IsLevelPassed(activityId, anecdoteId)
    return MDL.GoldenHeroAnecdote.GetAnecdoteStateById(activityId, anecdoteId) >= MDL.GoldenHeroAnecdote.AnecdoteState.Passed
end

function GoldenHeroAnecdote_Controller.IsLevelFirstPass(activityId, anecdoteId)
    return GoldenHeroAnecdote_Controller.IsLevelUnlock(activityId, anecdoteId) and not GoldenHeroAnecdote_Controller.IsLevelPassed(activityId, anecdoteId)
end

function GoldenHeroAnecdote_Controller.IsLevelRewardCollected(activityId, anecdoteId)
    return MDL.GoldenHeroAnecdote.GetAnecdoteStateById(activityId, anecdoteId) == MDL.GoldenHeroAnecdote.AnecdoteState.Collected
end

function GoldenHeroAnecdote_Controller.IsLevelCanSweep(activityId, anecdoteId)
    if GoldenHeroAnecdote_Controller.IsEnergyEnough(activityId, anecdoteId) then
        return GoldenHeroAnecdote_Controller.IsLevelPassed(activityId, anecdoteId)
    end
    return false
end

function GoldenHeroAnecdote_Controller.IsActivityHasLevelCanSweep(activityId)
    local anecdoteInfo = MDL.GoldenHeroAnecdote.GetAnecdoteInfo(activityId)
    if anecdoteInfo then
        for id, v in pairs(anecdoteInfo) do
            if GoldenHeroAnecdote_Controller.IsLevelCanSweep(activityId, id) then
                return true
            end
        end
    end
    return false
end

function GoldenHeroAnecdote_Controller.IsActivityHasReward(activityId)
    local anecdoteInfo = MDL.GoldenHeroAnecdote.GetAnecdoteInfo(activityId)
    if anecdoteInfo then
        for id, v in pairs(anecdoteInfo) do
            if MDL.GoldenHeroAnecdote.GetAnecdoteStateById(activityId, id) == MDL.GoldenHeroAnecdote.AnecdoteState.Passed then
                return true
            end
        end
    end
    return false
end

function GoldenHeroAnecdote_Controller.IsAnecdoteNotCheck(activityId, anecdoteId)
    if not private.anecdoteCheck then
        private.LoadAnecdoteCheckData()
    end
    local isChecked = private.anecdoteCheck[BattleDataGetter.GetAcID()][activityId][anecdoteId] or false
    local isUnlock = GoldenHeroAnecdote_Controller.IsLevelUnlock(activityId, anecdoteId)
    return not isChecked and isUnlock
end

function GoldenHeroAnecdote_Controller.IsHasNewAnecdote(activityId)
    if not private.anecdoteCheck then
        private.LoadAnecdoteCheckData()
    end
    local heroType = MDL.GoldenHeroMain.GetHeroTypeByActivityId(activityId)
    for i, v in DataSheetManager.GoldHeroActivityAnecdoteLevel:GetEnumerator() do
        if heroType == v.HeroType then
            if GoldenHeroAnecdote_Controller.IsAnecdoteNotCheck(activityId, v.ID) then
                return true
            end
        end
    end
    return false
end

function GoldenHeroAnecdote_Controller.SetAnecdoteCheck(activityId, anecdoteId)
    if not private.anecdoteCheck then
        private.LoadAnecdoteCheckData()
    end
    private.anecdoteCheck[BattleDataGetter.GetAcID()][activityId][anecdoteId] = true
    private.SaveAnecdoteCheckData()

    local redPointKey = CTL.GoldenHeroMain.RpEventId[activityId]
    MDL.RedPoint.UpdateNodeStateByLogicParams(GoldenHeroAnecdote_Controller.IsHasNewAnecdote(activityId) and MDL.GoldenHeroMain.IsActivityInFuncTime(activityId),
            redPointKey.TownHome, redPointKey.AnecdoteNew)
end

local GoldenHeroAnecdoteCheckKey = "GoldenHeroAnecdoteCheckKey"
function private.LoadAnecdoteCheckData()
    if not private.anecdoteCheck then
        private.anecdoteCheck = {}
    end
    local acId = BattleDataGetter.GetAcID()
    if not private.anecdoteCheck[acId] then
        private.anecdoteCheck[acId] = {}
    end

    local typeInfoList = MDL.OperationActivity.GetOperationActivityInfo(private.ActivityType)
    if typeInfoList then
        for key, value in pairs(typeInfoList) do
            if type(value) == "table" then
                private.anecdoteCheck[acId][value.activityId] = {}
            end
        end
    end

    local localData = PersistentData.PlayerData:Get(GoldenHeroAnecdoteCheckKey)
    --通过现在有效的数据，使用存储在本地的数据进行覆盖
    if localData then
        local playerData = localData[acId]
        if playerData then
            for activityId, value in pairs(playerData) do
                private.anecdoteCheck[acId][activityId] = value
            end
        end
    end
    private.SaveAnecdoteCheckData()
end

function private.SaveAnecdoteCheckData()
    PersistentData.PlayerData:Set(GoldenHeroAnecdoteCheckKey, private.anecdoteCheck, true)
end

function GoldenHeroAnecdote_Controller.DeleteAnecdoteCheckByActivityId(activityId)
    private.anecdoteCheck[BattleDataGetter.GetAcID()][activityId] = nil
    private.SaveAnecdoteCheckData()
end

function GoldenHeroAnecdote_Controller.DeleteAnecdoteCheck()
    PersistentData.PlayerData:Remove(GoldenHeroAnecdoteCheckKey, true)
end

return GoldenHeroAnecdote_Controller