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

local auction_operate = require 'Proto.auction_operate_pb'
local auction_base = require 'Proto.auction_base_pb'
local WorldPriceRatio = DataSheetManager.ConstData:GetDataByID("WorldAuctionPriceRatio").FloatValue
local CrossPriceRatio = DataSheetManager.ConstData:GetDataByID("CrossServerAuctionPriceRatio").FloatValue

GuildAuction_Model.TownHomeBtnState = {
	None = 0,
	Guild = 1,
	Cross = 2,
	World = 3,
}

GuildAuction_Model.AuctionTypeOfGuild = {
	[1] = auction_base.GuildWar,
	[2] = auction_base.GuildBoss,
}

GuildAuction_Model.AllAuctionType = {
	GuildAuctionShare = -1,
	GuildWar = auction_base.GuildWar,
	GuildBoss = auction_base.GuildBoss,
	Cross = auction_base.Cross,
	World = auction_base.World,
	Collect = auction_base.Collect,
	Escort = auction_base.Escort,
	FightThrone = auction_base.FightThrone,
	SlgGvE = auction_base.GVE,
}

GuildAuction_Model.GetAuctionRecordReqTyp = {
	Common = auction_operate.Common,
	SlgGvE = auction_operate.Gve,
}

-- 参与势力分红的拍卖行类型索引
GuildAuction_Model.AuctionGuildShareIndex = {
	[GuildAuction_Model.AllAuctionType.GuildWar] = LuaConst.ActivityType.GuildWar,
	[LuaConst.ActivityType.GuildWar] = GuildAuction_Model.AllAuctionType.GuildWar,
	
	[GuildAuction_Model.AllAuctionType.Escort] = LuaConst.ActivityType.GuildEscort,
	[LuaConst.ActivityType.GuildEscort] = GuildAuction_Model.AllAuctionType.Escort,
	
	[GuildAuction_Model.AllAuctionType.FightThrone] = LuaConst.ActivityType.FightThrone,
	[LuaConst.ActivityType.FightThrone] =GuildAuction_Model.AllAuctionType.FightThrone,

	[GuildAuction_Model.AllAuctionType.SlgGvE] = LuaConst.ActivityType.SlgGvE,
	[LuaConst.ActivityType.SlgGvE] =GuildAuction_Model.AllAuctionType.SlgGvE,
}

GuildAuction_Model.GuildAuctionShareBonusState = {
	UnOpen = auction_base.UnOpen, -- 拍卖行未开启
	Opening = auction_base.Opening, -- 拍卖行开放中
	ClosedAndCanNotReward = auction_base.ClosedAndCanNotReward, -- 拍卖行已结束，无领取资格
	ClosedAndNoReward = auction_base.ClosedAndNoReward, -- 拍卖行已结束，尚未领取
	ClosedAndHasReward = auction_base.ClosedAndHasReward, -- 拍卖行已结束，已领取
}
---------------------------------- 系统函数 ----------------------------------------

function GuildAuction_Model.OnStartup()
	-- 表缓存
	private.showAuctionTabs = {}
	
	-- 服务器数据缓存
	private.curAuctionType = -1
	private.curWorldAuctionType = -1
	private.showAuctionTypeDict = nil
	private.isBanAuction = false
	private.auctionItems = nil
	private.auctionCollection = nil
	private.worldAuctionItems = nil
	private.crossAuctionItems = nil
	private.bonus = nil
	private.isForbid = false
	private.isJoin = false
	private.isShowConfirmBox = true -- 拍卖二级弹窗确认
	private.zoneWarTypeInfos = nil
	private.requestCounter = 0
	private.collectsStatus = nil --收藏品状态

	-- 协议缓存数据
	private.requestItemsProtoVersion = {}
	private.auctionHouseCache = {}
	private.auctionsEndTime = {}
	
	NetManager.RegisterMsgCB(MessageEnums.MessageGetAuctionHouse, private.ResponseGuildAuctionItems)
    NetManager.RegisterMsgCB(MessageEnums.MessageAuction, private.ResponseAuction)
    NetManager.RegisterMsgCB(MessageEnums.MessageAddCollect, private.ResponseCollect)
    NetManager.RegisterMsgCB(MessageEnums.MessageGetAuctionRecord, private.ResponseAuctionRecord)
	EventSystem.Regist(EventID.UI_GuildAuctionTabRefresh, GuildAuction_Model.InitShowAuctionTabs)
	EventSystem.Regist(EventID.UI_Guild_BeKickOutRefresh, private.ClearProtoCacheData)
end

function GuildAuction_Model.OnShutdown()
	private.showWorldAuctionTypes = nil
	private.showAuctionTypeDict = nil
	private.auctionItems = nil
	private.auctionCollection = nil
	private.worldAuctionItems = nil
	private.bonus = nil
	private.zoneWarTypeInfos = nil
	
	private.requestItemsProtoVersion = nil
	private.auctionHouseCache = nil
end

-----------------------------------------------------------------------------------
function private.ClearProtoCacheData()
	table.clear(private.requestItemsProtoVersion)
	table.clear(private.auctionHouseCache)
	table.clear(private.auctionsEndTime)
end

-- 处理显示拍卖页签
function GuildAuction_Model.SetShowGuildAuctionTypes(personAuctionHouse)
	if not IsServerDataNotNil(personAuctionHouse) then
		return
	end

	-- 更新势力拍卖分红状态
	if IsProtoDataNotNil(personAuctionHouse.auctionBonusRewardInfo) then
		MDL.Guild.SetGuildAuctionShareChange(personAuctionHouse.auctionBonusRewardInfo)
		EventSystem.Dispatch(EventID.UI_Guild_AuctionShareBonusRefresh)
	end
	
	-- 势力拍卖行结束时间
	if IsProtoDataNotNil(personAuctionHouse.auctionEndTime) then
		private.HandleAuctionEndTime(personAuctionHouse.auctionEndTime)
	end
		
	if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIGuildAuctionBase) or UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIGuildAuctionMy) then
		UIManager.CloseView(Const_UI_Lua.UIEnum.UIMessageBoxView)
	end

	local auctionTypes = personAuctionHouse.auctionHouseTyps
	
	if not IsServerDataNotNil(auctionTypes) or #auctionTypes == 0 then
		private.showAuctionTypeDict = nil
		EventSystem.Dispatch(EventID.UI_GuildAuctionBase_RefreshPanel, private.curAuctionType, private.curWorldAuctionType, true)
		return
	end

	if GuildAuction_Model.IsShowTypeDicChanged(auctionTypes) then
		private.curAuctionType = -1
	end
	
	private.showAuctionTypeDict = {}
	for i, auctionType in ipairs (auctionTypes) do
		private.showAuctionTypeDict[auctionType] = true
	end
	EventSystem.Dispatch(EventID.UI_GuildAuctionBtnState_Refresh)
	
	if private.curAuctionType ~= auction_base.Collect or private.curAuctionType ~= GuildAuction_Model.AllAuctionType.GuildAuctionShare then
		local auctionType = auction_base.GuildWar
		if not private.showAuctionTypeDict[auctionType] and (private.showAuctionTypeDict[auction_base.World] or 
				private.showAuctionTypeDict[auction_base.Cross]) then
			auctionType = private.showAuctionTypeDict[auction_base.World] and auction_base.World or auction_base.Cross
		end

		if private.curAuctionType ~= auctionType then
			private.curAuctionType = auctionType
			if auctionType == auction_base.World or auctionType == auction_base.Cross then
				private.curWorldAuctionType = 1
			end
		end
		EventSystem.Dispatch(EventID.UI_GuildAuctionBase_RefreshPanel, private.curAuctionType, private.curWorldAuctionType, true)
	end
end

function private.HandleAuctionEndTime(auctionEndTime)
	for _, v in ipairs(auctionEndTime) do
		private.auctionsEndTime[v.auctionType] = v.endTime
	end
end

function GuildAuction_Model.GetAuctionEndTime(auctionType)
	return private.auctionsEndTime[auctionType] or 0
end

-- 新增分红页签不设置type,手动设置当前类型
function GuildAuction_Model.SetCurAuctionType(auctionType)
	private.curAuctionType = auctionType
end

function GuildAuction_Model:GetEnterGuildAuctionBaseType()
	local auctionTyp = GuildAuction_Model.AllAuctionType.GuildAuctionShare
	for _, typ in pairs(GuildAuction_Model.AllAuctionType) do
		if typ ~= auction_base.GVE then	--通用拍卖不包含GVE
			if GuildAuction_Model.IsOpenAuctionByType(typ) then
				if typ == auction_base.World or typ == auction_base.Cross then
					return typ, 1
				else
					return typ
				end
			end
		end
	end
	
	return auctionTyp
end

function GuildAuction_Model.GetIsShowConfirmBox()
	return private.isShowConfirmBox
end

function GuildAuction_Model.DisableConfirmBox()
	private.isShowConfirmBox = false
end

function GuildAuction_Model.IsShowTypeDicChanged(auctionTypes)
	local isChange = false
	for i, type in pairs(GuildAuction_Model.AllAuctionType) do
		if private.showAuctionTypeDict and private.showAuctionTypeDict[type] and not table.containValue(auctionTypes, type) then
			isChange = true
		end
	end
	return isChange
end

function GuildAuction_Model.GetTownHomeBtnShowType()
	if GuildAuction_Model.IsOpenAuctionByType(auction_base.GuildWar)
			or GuildAuction_Model.IsOpenAuctionByType(auction_base.GuildBoss)
			or GuildAuction_Model.IsOpenAuctionByType(auction_base.Escort)
			or GuildAuction_Model.IsOpenAuctionByType(auction_base.FightThrone) then
		return GuildAuction_Model.TownHomeBtnState.Guild
	elseif GuildAuction_Model.IsOpenAuctionByType(auction_base.Cross) then
		return GuildAuction_Model.TownHomeBtnState.Cross
	elseif GuildAuction_Model.IsOpenAuctionByType(auction_base.World) then
		return GuildAuction_Model.TownHomeBtnState.World
	else
		return GuildAuction_Model.TownHomeBtnState.None
	end
end

function GuildAuction_Model.OnGuildQuit()
	EventSystem.Dispatch(EventID.UI_Guild_AuctionShareBonusRefresh)
	if private.showAuctionTypeDict == nil then
		private.curAuctionType = -1
		return
	end
	
	for _, v in ipairs(GuildAuction_Model.AuctionTypeOfGuild) do
		private.showAuctionTypeDict[v] = nil
	end
	private.curAuctionType = -1
end

-- 进入拍卖行
-- 网络情况较差时,5秒钟没有收到回复就再次发送请求
function GuildAuction_Model.RequestGuildAuctionItems(auctionType, worldAuctionType)
	private.curWorldAuctionType = worldAuctionType and worldAuctionType or private.curWorldAuctionType

	local msg = auction_operate.GetAuctionHouseReq()
	msg.typ = auctionType and auctionType or private.curAuctionType
	msg.auctionHouseVersion = private.requestItemsProtoVersion[msg.typ] or 0
	
	if private.requestCounter <= 0 then
		NetManager.SendMessage(MessageEnums.MessageGetAuctionHouse, msg)
		private.IncreRequestCounter()
	else
		private.IncreRequestCounter()
		if private.requestCounter == 6 then
			private.ResetRequestCounter()
			NetManager.SendMessage(MessageEnums.MessageGetAuctionHouse, msg)
		end
	end
end

-- 请求拍卖品数据发生变化则更新缓存
function private.UpdateRequestItemsProtoData(typ, versionNum, houseData, collectIds)
	local cacheVersionNum = private.requestItemsProtoVersion[typ] or 0
	if versionNum ~= cacheVersionNum then
		private.auctionHouseCache[typ] = houseData
		private.requestItemsProtoVersion[typ] = versionNum
	end
end

function private.ResponseGuildAuctionItems(msgResp)
	if msgResp.Resp.Code ~= 0 then
		return
	end
	private.ResetRequestCounter()
	private.curAuctionType = msgResp.typ
	-- 拍卖行resp 判断是否发生改变, 类型变化或者版本变化
	if msgResp.typ == auction_base.Collect then
		-- Collect类型拍品不进行优化版本判断
		private.HandleAuctionHouseStruct(msgResp.auctionHouse)
		private.HandleAuctionCollectDatas(msgResp.auctionIds)
	else
		-- 判断版本号并且更新缓存
		private.UpdateRequestItemsProtoData(msgResp.typ, msgResp.auctionHouseVersion, msgResp.auctionHouse, msgResp.auctionIds)
		private.HandleAuctionHouseStruct(private.auctionHouseCache[msgResp.typ])
	end
	private.HandleAuctionCollectDatas(msgResp.auctionIds)
	private.DispatchRefreshEvent()
end

function private.IncreRequestCounter()
	private.requestCounter = private.requestCounter + 1
end

function private.ResetRequestCounter()
	private.requestCounter = 0
end

-- 竞拍出价
function GuildAuction_Model.RequestAuction(auctionId, cfgId, curPrice)
	local msg = auction_operate.AuctionReq()
	msg.typ = auction_base.AuctionPrice
	msg.auctionId = auctionId
	msg.curPrice = curPrice
	msg.houseTyp = private.curAuctionType
	msg.cfgId = cfgId
	msg.isOwnerFixedPrice = false
    NetManager.SendMessage(MessageEnums.MessageAuction, msg)
end

-- 一口价
function GuildAuction_Model.RequestBuyImmediately(auctionId, cfgId, curPrice, isFixedPriceByMyself)
	local msg = auction_operate.AuctionReq()
	msg.typ = auction_base.FixedPrice
	msg.auctionId = auctionId
	msg.curPrice = curPrice
	msg.houseTyp = private.curAuctionType
	msg.cfgId = cfgId
	msg.isOwnerFixedPrice = isFixedPriceByMyself
    NetManager.SendMessage(MessageEnums.MessageAuction, msg)
end

function private.ResponseAuction(msgResp)
	if msgResp.Resp.Code == 0 then
		if msgResp.typ == auction_base.FixedPrice then
			CTL.Tips.AddTipsMsg(Const_IDS["IDS_Auction_BuySucceed"])
		elseif msgResp.typ == auction_base.AuctionPrice then
			CTL.Tips.AddTipsMsg(Const_IDS["IDS_Auction_BuddingSucceed"])
		end
	end
	GuildAuction_Model.RequestGuildAuctionItems()
end

-- 收藏
function GuildAuction_Model.RequestCollect(auctionId, typ)
	local msg = auction_operate.AddCollectReq()
	msg.auctionId = auctionId
	msg.typ = typ
	msg.isCancel = false
    NetManager.SendMessage(MessageEnums.MessageAddCollect, msg)
end

function GuildAuction_Model.RequestCancelCollect(auctionId)
	local msg = auction_operate.AddCollectReq()
	msg.auctionId = auctionId
	msg.typ = private.curAuctionType
	msg.isCancel = true
    NetManager.SendMessage(MessageEnums.MessageAddCollect, msg)
end

function private.ResponseCollect(msgResp)
	GuildAuction_Model.RequestGuildAuctionItems()
end

-- 获取竞拍历史
function GuildAuction_Model.RequestAuctionRecord(recordReqTyp)
	local msg = auction_operate.GetAuctionRecordReq()
	msg.typ = recordReqTyp or GuildAuction_Model.GetAuctionRecordReqTyp.Common
	NetManager.SendMessage(MessageEnums.MessageGetAuctionRecord, msg)
end

function private.ResponseAuctionRecord(msgResp)
	if msgResp.Resp.Code ~= 0 then
		return
	end
	EventSystem.Dispatch(EventID.UI_GuildAuctionRecord_RefreshPanel, msgResp.auctionRecords)
end
------------------------------------------------------------------------------------

-- 处理协议结构
function private.HandleAuctionHouseStruct(auctionHouse)
	private.bonus = (auctionHouse and auctionHouse.bonus) and auctionHouse.bonus or nil
	private.isBanAuction = auctionHouse.isBan
	private.auctionItems = (auctionHouse and auctionHouse.auctionItems) and auctionHouse.auctionItems or nil
	private.isForbid = auctionHouse.isBan
	private.isJoin = auctionHouse.isJoin
	private.zoneWarTypeInfos = (auctionHouse and auctionHouse.zoneWarTypeInfos) and auctionHouse.zoneWarTypeInfos or nil
	if private.auctionItems and #private.auctionItems > 0 then
		table.sort(private.auctionItems, private.SortAuctionItemsByQualityDesc)
	end
end

function private.HandleAuctionCollectDatas(collectIds)
	private.auctionCollection = nil
	private.worldAuctionItems = nil

	local collectIdDict = nil
	if collectIds and #collectIds > 0 then
		collectIdDict = {}
		for _, id in ipairs (collectIds) do
			collectIdDict[id] = true
		end
	end
	
	if private.auctionItems and #private.auctionItems > 0 then
		private.auctionCollection = {}
		for i, item in ipairs (private.auctionItems) do
			if item.auctionData == nil then
				local auctionData = GuildAuction_Model.GetGuildAuctionDataByID(item.cfgId)
				local itemData = auctionData and DataSheetManager.ItemData:GetDataByID(auctionData.ItemID) or nil
				local dataSplice = UTL.Item.GetItemDataSpliceByType(auctionData.ItemID)
				private.auctionItems[i] = setmetatable({itemName = UTL.Color.FormatQualityText(dataSplice.Name, itemData.Color), auctionData = auctionData, itemData = itemData, isCollect = false}, {__index = item})
			end

			item = private.auctionItems[i]
			if private.curAuctionType == auction_base.World or private.curAuctionType == auction_base.Cross then
				if not private.worldAuctionItems then
					private.worldAuctionItems = {}
				end
				if item.auctionData.TypeID == private.curWorldAuctionType then
					table.insert(private.worldAuctionItems, item)
				end
			end
			
			item.isCollect = collectIdDict and collectIdDict[item.auctionId] or false
			if private.curAuctionType == auction_base.Collect and item.isCollect then
				table.insert(private.auctionCollection, item)
			end
			private.UpdateCollectItemStatus(item)
		end
	end
end

function private.UpdateCollectItemStatus(item)
	private.collectsStatus = private.collectsStatus and private.collectsStatus or {}
	if private.collectsStatus[item.auctionId] and item.isFixedPrice == true then
		CTL.Tips.AddTipsMsg(Const_IDS.IDS_Auction_BoughtByOthers, item.itemName)
	end
	
	private.collectsStatus[item.auctionId] = (item.isCollect and item.isFixedPrice == false) and true or nil
end

function private.DispatchRefreshEvent()
	if private.curAuctionType == auction_base.Collect then
		EventSystem.Dispatch(EventID.UI_GuildAuctionMy_RefreshPanel)
	else
		EventSystem.Dispatch(EventID.UI_GuildAuctionBase_RefreshPanel, private.curAuctionType, private.curWorldAuctionType)
	end
end
--

-- 拍卖品相关
function GuildAuction_Model.IsValidAuctionItem(item)
	return item and item.auctionData and item.itemData
end

function GuildAuction_Model.IsSaleEnd(item)
	if item and item.isOnSale and UTL.Time.GetServerTimestamp() >= item.endTime then
		CTL.Tips.AddTipsMsg(Const_IDS["IDS_Auction_BiddingEnded"])
		return true
	end

	return false
end

function GuildAuction_Model.IsOpenAuctionByType(auctionType)
	if not MDL.Guild.IsHasGuild() and (auctionType == auction_base.GuildWar or auctionType == auction_base.GuildBoss 
		or auctionType == auction_base.Escort or auctionType == auction_base.FightThrone or auctionType == auction_base.GVE) then
		return false
	end
	return private.showAuctionTypeDict and private.showAuctionTypeDict[auctionType] or false
end

function GuildAuction_Model.GetAuctionItemsByType(auctionType)
	if not auctionType then return nil end
	if auctionType == auction_base.GuildWar or auctionType == auction_base.GuildBoss or auctionType == auction_base.Escort 
		or auctionType == auction_base.FightThrone or auctionType == auction_base.GVE then
		return private.auctionItems
	elseif auctionType == auction_base.World then
		return private.worldAuctionItems
	elseif auctionType == auction_base.Cross then
		if private.worldAuctionItems and #private.worldAuctionItems > 0 then
			table.sort(private.worldAuctionItems, private.SortAuctionItemsByServerAndQualityDesc)
		end
		return private.worldAuctionItems
	end

	return 0
end

function GuildAuction_Model.CalculationSpecialOfferInfo(highestPrice, specialOfferInfo, curHighestPrice)
	if specialOfferInfo > 0 then
		local oldHighestPrice = highestPrice / (1 - specialOfferInfo)
		if oldHighestPrice <= curHighestPrice then
			return 0
		else
			return math.floor((oldHighestPrice - curHighestPrice) / oldHighestPrice * 100) / 100 -- 保留两位小数
		end
	else
		return 0
	end
end

function GuildAuction_Model.GetItemPrices(auctionItem)
	if not auctionItem then
		return 0, 0, 0
	end
	local startPrice, highestPrice, pacePrice, specialOfferInfo
	local auctionData = auctionItem.auctionData
	
	-- 这里	起拍价会有 比例变化，如果没有配置起拍价 则初始为-1，比例变换后 判断是否小于0
	if auctionItem.houseType == auction_base.World then 
		startPrice = math.ceil(FP.tonumberV1(auctionData.StartPrice * WorldPriceRatio))
		highestPrice = math.ceil(FP.tonumberV1(auctionData.HighestPrice * WorldPriceRatio)) 
		pacePrice = math.ceil(FP.tonumberV1(auctionData.PerPrice * WorldPriceRatio))
	elseif auctionItem.houseType == auction_base.Cross then
		startPrice = math.ceil(FP.tonumberV1(auctionData.StartPrice * CrossPriceRatio))
		highestPrice = math.ceil(FP.tonumberV1(auctionData.HighestPrice * CrossPriceRatio))
		pacePrice = math.ceil(FP.tonumberV1(auctionData.PerPrice * CrossPriceRatio))
	else
		startPrice = auctionData.StartPrice
		highestPrice = auctionData.HighestPrice
		pacePrice = auctionData.PerPrice
	end
	-- 计算折扣
	specialOfferInfo = GuildAuction_Model.CalculationSpecialOfferInfo(auctionData.HighestPrice, auctionData.SpecialOfferInfo, highestPrice)
	return startPrice, highestPrice, pacePrice, specialOfferInfo
end

-- 收藏相关缓存(需剔除GVE的拍卖)
function GuildAuction_Model.GetAuctionCollectionItems()
	local auctionCollection = {}
	if private.auctionCollection then
		for index, auctionItem in ipairs(private.auctionCollection) do
			if auctionItem.houseType ~= auction_base.GVE then	
				table.insert(auctionCollection, auctionItem) 
			end
		end
	end
	return auctionCollection
end

-- GVE的拍卖记录
function GuildAuction_Model.GetGvEAuctionCollectionItems()
	local auctionCollection = {}
	if private.auctionCollection then
		for index, auctionItem in ipairs(private.auctionCollection) do
			if auctionItem.houseType == auction_base.GVE then	
				table.insert(auctionCollection, auctionItem) 
			end
		end
	end
	return auctionCollection
end

function GuildAuction_Model.GetAuctionCollectionItemByPos(pos)
	if not private.auctionCollection or private.auctionCollectionCount == 0 or not pos or pos < 0 or pos > private.auctionCollectionCount then
		return nil
	end

	return private.auctionCollection[pos]
end
--

-- 配置表相关
function GuildAuction_Model.GetGuildAuctionDataByID(id)
	if not id then return nil end
	return DataSheetManager.GuildAuction:GetDataByID(id)
end

function GuildAuction_Model.GetShowAuctionTabs()
	return private.showAuctionTabs
end

function GuildAuction_Model.GetWorldAuctionTypeById(id)
	return DataSheetManager.AuctionType:GetDataByID(id)
end

function GuildAuction_Model.InitShowAuctionTabs()
	table.clearArray(private.showAuctionTabs)
	
	-- 势力相关
	local guildWarNodeList = {
		private.CreateChildNode(Const_IDS["IDS_ActivityName_GuildWar"], {auction_base.GuildWar}),
		private.CreateChildNode(Const_IDS["IDS_ActivityName_GuildBoss"], {auction_base.GuildBoss}),
		private.CreateChildNode(Const_IDS["IDS_Escort_FunctionName"], {auction_base.Escort}),
		private.CreateChildNode(Const_IDS["IDS_ActivityName_FightThrone"], {auction_base.FightThrone}),
	}
	private.AddParentParam(guildWarNodeList, auction_base.GuildWar)
	table.insert(private.showAuctionTabs, private.CreateParentNode(Const_IDS["IDS_Activity_TypeTips_Union"], auction_base.GuildWar, guildWarNodeList))
	
	-- 跨服相关(势力战CrossServer，魔将来袭WarZone)
	if GuildAuction_Model.IsOpenAuctionByType(auction_base.Cross) or CTL.GuildWar.IsCrossServerSettled() or CTL.WarZone.IsWarZoneOpen() then
		local crossServerNodeList = LuaExt.CreateTable(DataSheetManager.AuctionType:GetDataCount())
		for i, v in DataSheetManager.AuctionType:GetEnumerator() do
			crossServerNodeList[i] = private.CreateChildNode(Const_IDS[v.SheetName], {auction_base.Cross, v.ID})
		end
		private.AddParentParam(crossServerNodeList, auction_base.Cross)
		table.insert(private.showAuctionTabs, private.CreateParentNode(Const_IDS["IDS_GuildWar_CrossServer"], auction_base.Cross, crossServerNodeList))
	end

	-- 世界相关介绍
	local worldNodeList = LuaExt.CreateTable(DataSheetManager.AuctionType:GetDataCount())
	for i, v in DataSheetManager.AuctionType:GetEnumerator() do
		worldNodeList[i] = private.CreateChildNode(Const_IDS[v.SheetName], {auction_base.World, v.ID})
	end
	private.AddParentParam(worldNodeList, auction_base.World)
	table.insert(private.showAuctionTabs, private.CreateParentNode(Const_IDS["IDS_CHAT_Name_1_World"], auction_base.World, worldNodeList))

	---- 分红
	local guildAuctionShareType = GuildAuction_Model.AllAuctionType.GuildAuctionShare
	local guildAuctionShareList = {
		private.CreateChildNode(Const_IDS["IDS_GuildAuction_BenefitTab"], {guildAuctionShareType})
	}
	private.AddParentParam(guildAuctionShareList, guildAuctionShareType)
	table.insert(private.showAuctionTabs,
			private.CreateParentNode(Const_IDS["IDS_GuildAuction_BenefitTab"], guildAuctionShareType, guildAuctionShareList)
	)
end

function private.AddParentParam(childNodes, parent)
	for _, v in ipairs(childNodes) do
		v.parent = parent
	end
end

function private.CreateParentNode(showNameIDS, params, childNodes)
	return private.CreateTabNode(true, false, showNameIDS, params, childNodes)
end

function private.CreateChildNode(showNameIDS, params)
	return private.CreateTabNode(false, false, showNameIDS, params)
end

function private.CreateTabNode(isParent, isExtend, showNameIDS, params, childNodes)
	local node = {
		isParent = isParent,
		isExtend = isExtend,
		showNameIDS = showNameIDS,
		params = params,
		childNodes = childNodes,
		showNodeCount = 0
	}

	return node
end

function GuildAuction_Model:GetAuctionTabs()
	return private.showAuctionTabs
end

function GuildAuction_Model.GetBonus()
	if private.bonus == nil then
		return
	end
	table.sort(private.bonus, private.SortAuctionBonusItemOrderById)
	return private.bonus
end

function GuildAuction_Model.GetAuctionLimit()
	return private.isForbid, private.isJoin
end

function GuildAuction_Model.ForceLockGuildWarAuction()
	if private.curAuctionType == auction_base.GuildWar then
		EventSystem.Dispatch(EventID.UI_GuildAuctionBase_RefreshPanel, private.curAuctionType, private.curWorldAuctionType, true)
	end
end

function GuildAuction_Model.GetServerListByAuctionZoneType(zoneType)
	if not zoneType then
		return {}
	end
	return private.zoneWarTypeInfos[zoneType] and private.zoneWarTypeInfos[zoneType].serverIds or {}
end

function private.SortAuctionItemsByServerAndQualityDesc(a, b)
	local aServerCount = #GuildAuction_Model.GetServerListByAuctionZoneType(a.zoneType)
	local bServerCount = #GuildAuction_Model.GetServerListByAuctionZoneType(b.zoneType)
	if aServerCount == bServerCount then
		return private.SortAuctionItemsByQualityDesc(a, b)
	end
	return aServerCount < bServerCount
end

function private.SortAuctionBonusItemOrderById(a, b)
	return a.itemType > b.itemType
end

function private.SortAuctionItemsByQualityDesc(a, b)
	local aAuctionCfg = GuildAuction_Model.GetGuildAuctionDataByID(a.cfgId)
	local bAuctionCfg = GuildAuction_Model.GetGuildAuctionDataByID(b.cfgId)
	if not aAuctionCfg or not bAuctionCfg then return false end

	if aAuctionCfg.Sort == bAuctionCfg.Sort then
		return a.auctionId > b.auctionId
	end
	return aAuctionCfg.Sort > bAuctionCfg.Sort
end

-- 获取指定拍卖奖励池对应奖励
-- id: AuctionReward 奖励池id, 返回数据默认带有isAuction = true
-- isRealNum: 显示实际数量
function GuildAuction_Model.GetAuctionRewardsShowList(id, activityType, isRealNum)
	local rewardsTb = {}
	if id == nil or id == 0 then
		return rewardsTb
	end
	
	local timeTb = DataSheetManager.AuctionReward:GetDataByID(id).Reward_Table
	local rewardPool
	local rewardPoolNum
	local serverDay = private.GetDayCountByActivityType(activityType)
	for i = #timeTb, 1, -1 do
		if CTL.GuildAuction.IsClientShowAfterTimeSpan(timeTb[i].TimeStart, serverDay) then
			rewardPool = timeTb[i].RewardPool
			rewardPoolNum = timeTb[i].RewardRandomPoolNum
			break
		end
	end
	
	if rewardPool ~= nil then
		for i, v in ipairs(rewardPool) do
			local guildWarRewardPool = DataSheetManager.GuildWarRewardPool:GetDataByID(v)
			local cfg = DataSheetManager.RewardClientShow:GetDataByClientShowID(guildWarRewardPool.RewardShow)
			local clientShowTb = DataSheetUtil.GetRewardClientShowItemTable(cfg)
			if isRealNum then
				--计算实际数量，策划确定这里取第一个计算即可
				local num = DataSheetManager.GuildAuction:GetDataByID(guildWarRewardPool.Item_Table[1].AuctionID).ItemNum
				local tb = {ItemNum = num * rewardPoolNum[i], ItemID = clientShowTb[1].ItemID, isAuction = true}
				table.insert(rewardsTb, tb)
			else
				for _, clientShow in ipairs(clientShowTb) do
					local tb = {ItemNum = clientShow.ItemNum, ItemID = clientShow.ItemID, isAuction = true}
					table.insert(rewardsTb, tb)
				end
			end
		end
	end
	
	return rewardsTb
end

function private.GetDayCountByActivityType(type)
	local selfServerDayCount = MDL.Player.GetServerDayCount()
	if type == LuaConst.ActivityType.GuildWar then
		if CTL.GuildWar.IsCrossServerSettled() and MDL.GuildWar.GetWarInfo().openTime then
			return UTL.Time.GetGameDiffDayCount(UTL.Time.GetServerTimestamp(), MDL.GuildWar.GetWarInfo().openTime)
		else
			return selfServerDayCount
		end
	else -- 战区玩法都走同样的时间，以上为大战区玩法
		if CTL.WarZone.IsWarZoneOpen() then
			return UTL.Time.GetGameDiffDayCount(UTL.Time.GetServerTimestamp(), MDL.WarZone.GetWarZoneLongestOpenTime())
		else
			return selfServerDayCount
		end
	end
end

return GuildAuction_Model