local HeroFund_Model = {}   --宝物和战骑的逻辑也都在这个模块里
local private = {}
local EventSystem = require('Event/EventSystem')
local hero_fund_opt_pb = require("Proto/hero_fund_opt_pb")

HeroFund_Model.RewardClaimState = {
    Locked = 0,
    CanClaim = 1,
    Claimed = 2,
}

function HeroFund_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageHeroFundSelectHero, private.SyncHeroFundSelectHeroResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageHeroFundReward, private.SyncHeroFundRewardResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageHeroFundRewardAll, private.SyncHeroFundRewardAllResp)
    --初始化本地缓存
    private.xFundDataDic = {}
    for _, v in pairs(LuaConst.ShowGoldenType) do
        private.xFundDataDic[v] = { info = {}, dataCache = {} } -- key是funcYype，value里包含协议数据info，和本地数据缓存seasonData和fundShowData
    end
end

--region Public func
function HeroFund_Model.GetFundID(type)
    local info = private.xFundDataDic[type].info
    return info.fundID
end

function HeroFund_Model.GetFundSeasonDataData(type)
    return private.xFundDataDic[type].dataCache.seasonData
end

function HeroFund_Model.GetFundShowData(type)
    return private.xFundDataDic[type].dataCache.fundShowData
end

--合并后的奖励展示，用于升阶界面
function HeroFund_Model.GetCompinedFundShowData(type, gear)
    return private.xFundDataDic[type].dataCache.fundShowData[gear].combinedRewardDic
end

function HeroFund_Model.IsFundOpen(type)
    --GMS开关判断
    local FuncId = CTL.HeroFund.GetFuncIdByType(type)
    if not MDL.Unlock.IsUnlock(FuncId) then
        return false
    end
    --信任服务器发来的cfgId,是正数就表示活动开着
    local seasonId = private.xFundDataDic[type].info.seasonId
    return seasonId ~= nil and seasonId > 0
end

--某一档位（主界面的一整行）是否已解锁。第一是固定解锁，二三需要购买
function HeroFund_Model.IsGearUnlock(type, gearId)
    local giftGears = private.xFundDataDic[type].info.giftGears
    return giftGears and table.containValue(giftGears, gearId)
end

function HeroFund_Model.GetCurStage(type)
    return private.xFundDataDic[type].info.curStage
end

function HeroFund_Model.GetFundItemState(type, day, gear)
    if not HeroFund_Model.IsGearUnlock(type, gear) or day > private.xFundDataDic[type].info.curStage then
        return HeroFund_Model.RewardClaimState.Locked --档位未购买或没到天数，是未解锁
    end
    local rewardInfos = private.xFundDataDic[type].info.rewardInfos
    if rewardInfos then
        for _, v in ipairs(rewardInfos) do
            if v.gear == gear and table.containValue(v.rewardInfo, day) then
                return HeroFund_Model.RewardClaimState.Claimed -- 服务器判定已领取
            end
        end
    end
    return HeroFund_Model.RewardClaimState.CanClaim  --可领取
end

--判断是否有任何奖励可领取，用于一键领取和红点判断。
function HeroFund_Model.CanClaimAnyReward(type)
    if not HeroFund_Model.IsFundOpen(type) then
        return false --活动没开
    end

    if type ~= LuaConst.ShowGoldenType.GoldIngot then
        local fundID = MDL.HeroFund.GetFundID(type)
        if (not fundID or fundID <= 0) then
            return false --还没选X
        end
        
        if not CTL.HeroFund.IsHasCanSelectQuality(type) then
            return false --没有可选的（一般配置金色品质）
        end
    end
    local fundShowData = private.xFundDataDic[type].dataCache.fundShowData
    if #fundShowData == 0 then
        return false
    end
    local rewardList = fundShowData[1].rewardList
    for gear = 1, 3 do
        for i = 1, #rewardList do
            local day = rewardList[i].Day
            if HeroFund_Model.GetFundItemState(type, day, gear) == HeroFund_Model.RewardClaimState.CanClaim then
                return true
            end
        end
    end
end

function HeroFund_Model.GetFirstClaimDayIndex(type)
    local minDayIndex
    local fundShowData = private.xFundDataDic[type].dataCache.fundShowData

    if #fundShowData > 0 then
        local rewardList = fundShowData[1].rewardList;
        for gear = 1, 3 do
            for i = 1, #rewardList do
                if HeroFund_Model.GetFundItemState(type, rewardList[i].Day, gear) == HeroFund_Model.RewardClaimState.CanClaim then
                    if minDayIndex == nil then
                        minDayIndex = i
                    elseif i < minDayIndex then
                        minDayIndex = i
                    end
                end
            end
        end
    end
    return minDayIndex
end

--endregion

--region Private func
function private.RefreshDataCache(type)
    local info = private.xFundDataDic[type].info
    local seasonId = info.seasonId
    local dataCache = private.xFundDataDic[type].dataCache
    local seasonData = DataSheetManager.HeroFundSeason:GetDataByID(seasonId)
    local fundShowData = {} -- 3个档位的展示数据，按行存储，最后可能不需要，争取删掉
    dataCache.seasonData = seasonData
    dataCache.fundShowData = fundShowData
    if not seasonData then
        logging.error(LTAG.ERROR, ": cannnot find HeroFundSeason Data by ID:", seasonId)
        return
    end
    for _, excelData in DataSheetManager.HeroFundData:GetEnumerator() do
        if excelData.Type == type and table.containValue(seasonData.TeamID, excelData.TeamID) then
            --设计上当前时间段每种type只有一个
            local rewardList = {}
            local combinedRewardDic = {} --key是ItemID,value是ItemNum
            fundShowData[excelData.ID] = { IAPID = excelData.IAPID, ShowPrice = excelData.ShowPrice, 
                                           Pic = string.format(ConstAssetPathConfig.Path8, excelData.Pic),
                                           rewardList = rewardList, combinedRewardDic = combinedRewardDic }

            for i, eachItem in ipairs(excelData.Item_Table) do
                local showItem
                if eachItem.IsShowItem and info.fundID > 0 then
                    --选了将、马、宝物的，默认展示道具的id要换算成相应武将、马、宝物资源
                    showItem = { Day = eachItem.Day, ItemID = private.GetItemByDefaultShow(eachItem.ItemID, info.fundID), ItemNum = eachItem.ItemNum }
                else
                    showItem = eachItem
                end
                table.insert(rewardList, showItem)
                --计算合并奖励
                local findCombined = false
                for k, v in pairs(combinedRewardDic) do
                    if combinedRewardDic[showItem.ItemID] ~= nil then
                        findCombined = true
                        combinedRewardDic[showItem.ItemID] = combinedRewardDic[showItem.ItemID] + showItem.ItemNum
                        break
                    end
                end
                if not findCombined then
                    combinedRewardDic[showItem.ItemID] = showItem.ItemNum
                end
            end
        end
    end
end

--如果已经选了将、马、宝物，换成对应武将的资源
function private.GetItemByDefaultShow(defaultId, fundID)
    for _, v in DataSheetManager.HeroFundItemMapping:GetEnumerator() do
        if v.ItemID == defaultId then
            return v.BaseID + fundID
        end
    end
    return defaultId
end

--endregion

--region NetWork Sync

function HeroFund_Model.SyncHeroFundInfo(infoList)
    local totalNone --没有任何活动，也需要遍历本地数据设置
    if not IsServerDataNotNil(infoList) or #infoList == 0 then
        totalNone = true
    end
    --for _, v in ipairs(infoList) do
    --    logging.log(LTAG.LOG, "[gjh]sync infoList:", v)
    --end
    for type, fundData in pairs(private.xFundDataDic) do
        local serverInfo
        local info = fundData.info
        for _, v in ipairs(infoList) do
            if v.typ == type then
                serverInfo = v
                break
            end
        end
        if not serverInfo or serverInfo.cfgId == 0 or totalNone then
            info.seasonId = 0 --本期没有这个类型的活动，设置为0，不刷新数据了
        else
            --刷新缓存里的info
            info.curStage = serverInfo.curStage --当前阶段，到第几天了
            info.giftGears = serverInfo.giftGear --已购买档位的数组，1档是送的，如果又买了第3档，就是{1,3}
            info.rewardInfos = serverInfo.rewardInfo --各档位领取情况，没选将的话长度为0。每个档位元素是:{档位，{领取情况数组}}  
            --判断刷新缓存里的dataCache
            local needRefreshCache = false
            if info.fundID ~= serverInfo.id then
                info.fundID = serverInfo.id
                needRefreshCache = true
            end
            if info.seasonId ~= serverInfo.cfgId then
                info.seasonId = serverInfo.cfgId --当前开的是第几期，对应HeroFundSeason表的ID，如果是0表示没开
                needRefreshCache = true
            end
            if needRefreshCache then
                private.RefreshDataCache(type)
            end
        end
    end

    private.RefreshMainUI()
end

function HeroFund_Model.HeroFundSelectReq(type, id)
    local msg = hero_fund_opt_pb.HeroFundSelectHeroReq()
    msg.heroId = id --武将、马、宝物的id
    msg.typ = type
    NetManager.SendMessage(MessageEnums.MessageHeroFundSelectHero, msg)
end

function HeroFund_Model.HeroFundRewardReq(type, gear, day)
    local msg = hero_fund_opt_pb.HeroFundRewardReq()
    msg.typ = type
    msg.gear = gear --档位
    msg.day = day   --天数/次数
    NetManager.SendMessage(MessageEnums.MessageHeroFundReward, msg)
end

function HeroFund_Model.HeroFundRewardAllReq(type)
    local msg = hero_fund_opt_pb.HeroFundRewardAllReq()
    msg.typ = type
    NetManager.SendMessage(MessageEnums.MessageHeroFundRewardAll, msg)
end

function private.SyncHeroFundSelectHeroResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.RefreshMainUI()
    end
end

function private.SyncHeroFundRewardResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.RefreshMainUI()
    end
end

function private.SyncHeroFundRewardAllResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.RefreshMainUI()
    end
end

function private.RefreshMainUI()
    EventSystem.Dispatch(EventID.UI_HeroFund_RefreshPanel)
end

--endregion

function HeroFund_Model.OnShutdown()
    private.xFundDataDic = {}
    private.fundID = 0
end

return HeroFund_Model