local ActivityGacha_Controller = {}
local private = {}
local EventSystem = require('Event/EventSystem')

local CostNumShowStr = "x%d"
--------------------------- 系统函数 ---------------------------

function ActivityGacha_Controller.OnStartup()
	EventSystem.Regist(EventID.UI_OperationActivity_DataChanged, private.RefreshDrawCardAvailableRedPoint)
	EventSystem.Regist(EventID.UI_OperationActivity_InfoChanged, private.RefreshDrawCardAvailableRedPoint)
	EventSystem.Regist(EventID.BagItem_Update, private.RefreshDrawCardAvailableRedPoint)

	private.heroDatas = {}
	private.itemDatas = {}
	private.heroTimelineList = {}
end

function ActivityGacha_Controller.OnShutdown()
	private.heroDatas = nil
	private.itemDatas = nil
end

function private.RefreshDrawCardAvailableRedPoint()
	if MDL.OperationActivity.HotControlInfo then
		private.RefreshRedPointByActivityType(MDL.OperationActivity.ActivityType.GoldenHero, "GoldenHeroMain")
		private.RefreshRedPointByActivityType(MDL.OperationActivity.ActivityType.SuperGold, "SuperGoldMain")
	end
end

function private.RefreshRedPointByActivityType(activityType, module)
	local typeData = MDL.OperationActivity.HotControlInfo:GetDataByActivityType_ActivityID(activityType)
	if typeData then
		for i, v in pairs(typeData) do
			local activityId = v.ActivityID
			local activityInfo = MDL.OperationActivity.GetOperationActivityInfo(activityType, activityId)
			if activityInfo and CTL.OperationActivity.IsOperationActivityOpen(activityInfo) then
				if CTL[module].RpEventId[activityId] then
					if MDL.RedPoint.GetNodeByLogicParams(CTL[module].RpEventId[activityId].TownHome, CTL[module].RpEventId[activityId].DrawCardAvailable) then
						MDL.RedPoint.UpdateNodeStateByLogicParams(ActivityGacha_Controller.IfCanDrawByActivityId(activityId, activityType),
								CTL[module].RpEventId[activityId].TownHome, CTL[module].RpEventId[activityId].DrawCardAvailable)
					else
						CTL[module].InitDrawCardRedPointTreeByActivityId(v.ActivityID)
					end
				else
					CTL[module].InitDrawCardRedPointTreeByActivityId(activityId)
				end
			end
		end
	end
end

function ActivityGacha_Controller.IsRewardClaimed(activityId, rewardId)
	local info = MDL.ActivityGacha.GetActivityDrawInfo(activityId)
	for i, v in ipairs(info.rewardList) do
		if v == rewardId then
			return true
		end
	end
	return false
end

function ActivityGacha_Controller.GetGachatTitleName(drawCardPooId)
	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	return drawCardData and UIUtils.GetLocalizedTxt(Const_IDS[drawCardData.PoolName]) or ""
end

function ActivityGacha_Controller.GetGachaDetailInfo(drawCardPooId)
	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	if drawCardData then
		local guildNoteData = DataSheetManager.GuidanceNotes:GetDataByID(drawCardData.GuidanceNotesID)
		return guildNoteData and UIUtils.GetLocalizedTxt(Const_IDS[guildNoteData.GuideNotesContent]) or ""
	end

	return ""
end

function ActivityGacha_Controller.GetHeroDatas(drawCardPooId, countryId)
	if private.heroDatas[drawCardPooId] then
		return private.heroDatas[drawCardPooId][countryId]
	end

	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	if drawCardData and drawCardData.RewardDropShowHero and #drawCardData.RewardDropShowHero > 0 then
		private.heroDatas[drawCardPooId] = {}
		for _, v in ipairs (drawCardData.RewardDropShowHero) do
			local heroData = DataSheetManager.HeroNum:GetDataByID(v)
			if not private.heroDatas[drawCardPooId][heroData.Kingdom] then
				private.heroDatas[drawCardPooId][heroData.Kingdom] = {}
			end
			table.insert(private.heroDatas[drawCardPooId][heroData.Kingdom], heroData)
		end

		for _, v in pairs (private.heroDatas[drawCardPooId]) do
			table.sort(v, private.SortHeroDatasByQuaility)
		end

		return private.heroDatas[drawCardPooId][countryId]
	end

	return nil
end

function private.SortHeroDatasByQuaility(a, b)
	if a.HeroIntelligence == b.HeroIntelligence then
	    if a.HeroQuality == b.HeroQuality then
	        return a.ID < b.ID
	    end
	    return a.HeroQuality > b.HeroQuality
	end

    return a.HeroIntelligence > b.HeroIntelligence
end

function ActivityGacha_Controller.GetItemDatas(drawCardPooId, quality)
	if private.itemDatas[drawCardPooId] then
		return private.itemDatas[drawCardPooId][quality]
	end

	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	if drawCardData and drawCardData.RewardDropShowItem and #drawCardData.RewardDropShowItem > 0 then
		private.itemDatas[drawCardPooId] = {}
		for _, v in ipairs (drawCardData.RewardDropShowItem) do
			local itemData = DataSheetManager.ItemData:GetDataByID(v)
			local quality = itemData.Color
			if not private.itemDatas[drawCardPooId][quality] then
				private.itemDatas[drawCardPooId][quality] = {}
			end
			table.insert(private.itemDatas[drawCardPooId][quality], itemData)
		end

		for _, v in pairs (private.itemDatas[drawCardPooId]) do
            table.sort(v, private.SortItemDatas)
        end
	end

	return private.itemDatas[drawCardPooId][quality]
end

function private.SortItemDatas(a, b)
	if a.RewardShowPriority == b.RewardShowPriority then
		return a.ID < b.ID
	end

    return a.RewardShowPriority > b.RewardShowPriority
end

function ActivityGacha_Controller.SetTitleImage(img, drawCardPooId)
	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	if img and drawCardData then
		UIUtils.SetLocalizationImage(img, drawCardData.PoolNamePic)
	end
end

function ActivityGacha_Controller.GetConsumeItemInfos(drawCardPooId)
	local drawCardData = DataSheetManager.DrawCardData:GetDataByID(drawCardPooId)
	if drawCardData then
		return drawCardData.Item, UTL.Item.GetItemStockCount(drawCardData.Item)
	end

	return 0, 0
end

function private.GetConsumeItemInfosByActivityId(activityId, activityType)
	local baseData = MDL.OperationActivity.ActivityBaseData[activityType]:GetDataByActivityID(activityId)
	return ActivityGacha_Controller.GetConsumeItemInfos(baseData.DrawCardPoolID)
end

function ActivityGacha_Controller.IfCanDrawByActivityId(activityId, activityType)
	local itemId, countInBag = private.GetConsumeItemInfosByActivityId(activityId, activityType)
	local superGoldActivityType = MDL.OperationActivity.ActivityType.SuperGold
	if activityType == superGoldActivityType then
		local activityInfo = MDL.OperationActivity.GetOperationActivityInfo(superGoldActivityType, activityId)
		if activityInfo then
			if not CTL.SuperGoldMain.IsActivityInValidFuncTime(activityId) then
				return false
			end
		end
	end
	return countInBag > 0
end

function ActivityGacha_Controller.GetGachaCostNumShow(itemId, needCount)
	local costStr = string.format(CostNumShowStr, needCount)
	return UTL.Color.FormatTextByColor(UTL.Item.GetItemStockCount(itemId) >= needCount and UTL.Color.ModelNameColor.White or UTL.Color.Red, costStr)
end

function ActivityGacha_Controller.ShowWholeHero(drawCardResult, appearIndex, heroId)
	private.drawCardResult = drawCardResult
	private.lastAppearIndex = appearIndex
	ActivityGacha_Controller.PlayHeroTimeline(heroId)
end

function ActivityGacha_Controller.PlayHeroTimeline(heroId)
	if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIResonanceLevelUp) then
		UIManager.CloseView(Const_UI_Lua.UIEnum.UIResonanceLevelUp)
	end
	--要判断是否是整卡转换成了碎片
	local isCanSkip = CTL.DrawCard.IsHeroTransToPiece(heroId)
	UIManager.OpenAndPushAll(Const_UI_Lua.UIEnum.UIGachaExpressionLimit, {heroId = heroId, isCanSkip = isCanSkip}, Const_UI_Lua.UIEnum.UIGachaExpression)
end

--这里不使用ShowHeroExpression的回调来执行，是因为回调是在关闭HeroExpression执行的，这个时序优先于压栈界面的出栈，层级不对，因此在出栈界面的onopend执行
function ActivityGacha_Controller.TryReOpenDrawCardResult()
	if private.drawCardResult then
		UIManager.OpenView(Const_UI_Lua.UIEnum.UIGachaGetLimit, { result = private.drawCardResult })
		private.drawCardResult = nil
		private.lastAppearIndex = nil
	elseif private.drawCardTempData then
        ActivityGacha_Controller.ExecuteTimelineList()
	end
end

function ActivityGacha_Controller.GetLastAppearIndex()
	return private.lastAppearIndex
end

local DrawCardSkipAnim = "ActivityGachaSkipAnim"
function ActivityGacha_Controller.IsSkipAnim(activityType)
	if private.isSkipAnim == nil then
		private.isSkipAnim = PersistentData.PlayerData:Get(DrawCardSkipAnim, {})
	end
	return private.isSkipAnim[activityType] or false
end

function ActivityGacha_Controller.SetSkipAnim(activityType, isSkip)
	private.isSkipAnim[activityType] = isSkip
	PersistentData.PlayerData:Set(DrawCardSkipAnim, private.isSkipAnim, true)
end

function ActivityGacha_Controller.AddTimeLineList(heroId)
	if not table.containValue(private.heroTimelineList, heroId) then
		table.insert(private.heroTimelineList, heroId)
	end
end

function ActivityGacha_Controller.SetTimeLineList(result)
	if result then
		private.drawCardTempData = result
		private.heroTimelineList = {}
	else --传入空值的时候检测队列中是否还有未播放的武将timeline
		if private.heroTimelineList and #private.heroTimelineList == 0 then
			private.drawCardTempData = nil
		end
	end
end

function ActivityGacha_Controller.ExecuteTimelineList()
	if private.drawCardTempData then
        if #private.heroTimelineList == 0 then
			CTL.DrawCard.UpdateHeroCardState()
			if not UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIGachaGetLimit) then
                UIManager.OpenView(Const_UI_Lua.UIEnum.UIGachaGetLimit, { result = private.drawCardTempData, isDirectShow = true })
            end
        else
            local heroId = table.remove(private.heroTimelineList)
            ActivityGacha_Controller.PlayHeroTimeline(heroId)
        end
    end
end

function ActivityGacha_Controller.IsCanSwitchCardHero(activityId, drawCardStoreId, heroID, checkHasDrawCount, activityType)
    -- 日服金将屏蔽自选心愿
    if GameAppInfo.IsJapanesePackage() and activityType == MDL.OperationActivity.ActivityType.GoldenHero then
        return false
    end
    local activityPoolInfo = MDL.ActivityGacha.GetActivityDrawInfo(activityId)
	local cardPoolList = MDL.ActivityGacha.GetGoldHeroChooseList(drawCardStoreId, heroID)
    if not activityPoolInfo.canChoose then
        return false
    end
	if #cardPoolList <= 1 then
        return false
    end
    if checkHasDrawCount then
        return activityPoolInfo.drawCount<=0
    end
    return true
end

return ActivityGacha_Controller