--[[
	势力红包 系统Model
--]]
local RedPacket_Model = {}
local EventSystem = require('Event/EventSystem')
local private = {}
local red_envelope_handle_pb = require("Proto/red_envelope_handle_pb")

RedPacket_Model.RightRequestForm = {
	AutomaticallySendContent  = red_envelope_handle_pb.AutomaticallySendContent,	-- 服务器自动决定发送内容。
 	RequestReceiveContent     = red_envelope_handle_pb.RequestReceiveContent,	-- 客户端请求红包领取界面。
 	RequestHistoryContent     = red_envelope_handle_pb.RequestHistoryContent, 	-- 客户端请求获取历史界面。
  	Unwanted                  = red_envelope_handle_pb.Unwanted,	-- 客户端并不需要右侧信息（只刷左栏）。
}

local ReceiveGuildRedEnvelopeFeedback = {
  ReceivedSuccessfully = 1, -- 领取红包成功。需要打开展示界面
  HasBeenCollected     = 2, -- 红包已被领完。需要打开展示界面
  HasExpired           = 3, -- 红包信息失效（已超出服务器记录上限的领完红包或超出策划配置上限被顶替红包）。不需要打开展示界面
  HasReceived		   = 4, -- 已领取过红包。需要打开展示界面
}

function RedPacket_Model.OnStartup()
	private.selfRedPacket = {}	-- 个人红包数据
	
	private.guildRedPakcet = {}	-- 军团红包数据
	private.canReceiveRedPakcetIdList = {}	-- 当前可领取的红包id数组
	
	private.redPakcetRecord = {}	-- 红包记录数据
	private.curShowRedPacketInfo = nil 	-- 当前正展示的领取红包数据
	private.redPacketReceiveTimes = 0 	-- 当天已经领取的红包数量
	private.hasNewRedEnvelope = false -- 当前是否有新红包
	private.redPacketMax = DataSheetManager.ConstData:GetDataByID("BangHongBaoGetMax").IntValue

	NetManager.RegisterMsgCB(MessageEnums.MessageGetGuildRedEnvelopeComponentInfo, private.GetGuildRedPacketInfoResponse)
	NetManager.RegisterMsgCB(MessageEnums.MessageReceiveGuildRedEnvelope, private.ReceiveGuildRedPacketResponse)
	NetManager.RegisterMsgCB(MessageEnums.MessageSeeRedEnvelope, private.SeeRedEnvelopeResponse)
	NetManager.RegisterMsgCB(MessageEnums.MessageIssueGuildRedEnvelope, private.SendGuildRedEnvelopeResponse)
	NetManager.RegisterMsgCB(MessageEnums.MessageClearRedEnvelopeRedPoint, private.ClearRedEnvelopeRedPointResponse)
	-- 推送
	NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushNewGuildRedEnvelope, private.SyncNewGuildRedPacket)
end

function RedPacket_Model.OnShutdown()
end

-- 多了一步 tab的判空
local function IpairsValue(tab, i)
	if not tab then return nil end

    i = i + 1
    local data = tab[i]
    if data then
        return i, data
    else
        return nil
    end
end

-- 排序（自身处于第一位，剩下的按照领取时间排）
local function SortReceiveRecord(a, b)
    if a.PlayerACID == BattleDataGetter.GetAcID() then
        return  true
    end
    if b.PlayerACID == BattleDataGetter.GetAcID() then
        return  false
    end
    return a.ReceiveTimeStamp < b.ReceiveTimeStamp
end

-- 设置最大金额、排序
local function DealwithReceiveRecords(tb)
	-- 这是最大领取金额
	local maxReceiveAmount = 0
	for i, v in ipairs(tb) do
		if v.ReceiveAmount > maxReceiveAmount then
			maxReceiveAmount = v.ReceiveAmount
		end
	end
	for i, v in ipairs(tb) do
		if v.ReceiveAmount >= maxReceiveAmount then
			rawset(v, "isMax", true)
		else
			rawset(v, "isMax", false)
		end
	end

	-- 排序
	table.sort(tb, SortReceiveRecord)
end

-- 排序(未发放 > 已发放未领取 > 已发放已领取,同级别下按照时间顺序排【时间大的在时间小的前面】)
local function SortSelfRedPacket(a, b)
	if a.isUse and not b.isUse then
		return false
	elseif b.isUse and not a.isUse then
		return true
	else
		local hasReceiveA = a.redPacketData.HasReceive
		local hasReceiveB = b.redPacketData.HasReceive
		if hasReceiveA and not hasReceiveB then
			return false
		elseif hasReceiveB and not hasReceiveA then
			return true
		else
			return a.redPacketData.TimeStamp > b.redPacketData.TimeStamp
		end
	end
end

-- 排序(已发放未领取 > 已发放已领取 > 未发放,同级别下按照时间顺序排【时间大的在时间小的前面】)
local function SortGuildRedPacket(a, b)
	if a.isUse and not b.isUse then
		return true
	elseif b.isUse and not a.isUse then
		return false
	else
		local hasReceiveA = a.redPacketData.HasReceive
		local hasReceiveB = b.redPacketData.HasReceive
		if hasReceiveA and not hasReceiveB then
			return false
		elseif hasReceiveB and not hasReceiveA then
			return true
		else
			return a.redPacketData.TimeStamp > b.redPacketData.TimeStamp
		end
	end
end
---------- start 协议相关 start ----------
-- #region 势力红包界面
function RedPacket_Model.GetGuildRedPacketInfoRequest(needLeft, rightRequestForm)
	local msg = red_envelope_handle_pb.GetGuildRedEnvelopeComponentInfoReq()
	msg.NeedLeftSelfInfo = needLeft
	msg.RightRequestForm = rightRequestForm
	NetManager.SendMessage(MessageEnums.MessageGetGuildRedEnvelopeComponentInfo, msg)
end

function private.GetGuildRedPacketInfoResponse(msgResp) -- 此消息均为全量推送
	if msgResp.Resp.Code == 0 then

		if IsServerDataNotNil(msgResp.LeftSelfComponent) then -- 刷新自身拥有红包消息（发放中、未发放）
			local redPacketCount = 1
			-- 处理未发放的红包
			if IsServerDataNotNil(msgResp.LeftSelfComponent.UnissuedBriefInfosQueue) then
				for _, v in ipairs(msgResp.LeftSelfComponent.UnissuedBriefInfosQueue) do
					private.selfRedPacket[redPacketCount] = {redPacketData = v, isUse = false,}
					redPacketCount = redPacketCount + 1
				end
			end
			-- 处理发放中红包
			if IsServerDataNotNil(msgResp.LeftSelfComponent.IssuingBriefInfosQueue) then
				for _, v in ipairs(msgResp.LeftSelfComponent.IssuingBriefInfosQueue) do
					private.selfRedPacket[redPacketCount] = {redPacketData = v, isUse = true,}
					redPacketCount = redPacketCount + 1
				end
			end
			-- 处理多余的红包数据
			for i = #private.selfRedPacket, redPacketCount, -1 do
				table.remove(private.selfRedPacket, i)
			end
			table.sort(private.selfRedPacket, SortSelfRedPacket)
			EventSystem.Dispatch(EventID.UI_RedPacket_RefreshOwn)
		end

		if IsServerDataNotNil(msgResp.RightReceiveComponent) then -- 刷新发放中军团红包消息
			local redPacketCount = 1
			--处理发放中红包
			if IsServerDataNotNil(msgResp.RightReceiveComponent.IssuingBriefInfosQueue) then
				local redPacketCanReceiveCount = 1
				for _, v in ipairs(msgResp.RightReceiveComponent.IssuingBriefInfosQueue) do
					private.guildRedPakcet[redPacketCount] = {redPacketData = v, isUse = true}
					-- 处理可领取红包列表
					if not v.HasReceive then
						private.canReceiveRedPakcetIdList[redPacketCanReceiveCount] = v.ID
						redPacketCanReceiveCount = redPacketCanReceiveCount + 1
					end
					redPacketCount = redPacketCount + 1
				end
				-- 移除多余的可领取红包列表数据
				for i = #private.canReceiveRedPakcetIdList, redPacketCanReceiveCount, -1 do
					table.remove(private.canReceiveRedPakcetIdList, i)
				end
			end
			-- 处理未发放的红包
			if IsServerDataNotNil(msgResp.RightReceiveComponent.UnissuedBriefInfosQueue) then
				for _, v in ipairs(msgResp.RightReceiveComponent.UnissuedBriefInfosQueue) do
					private.guildRedPakcet[redPacketCount] = {redPacketData = v, isUse = false}
					redPacketCount = redPacketCount + 1				
				end
			end
			-- 处理多余的红包数据
			for i = #private.guildRedPakcet, redPacketCount, -1 do
				table.remove(private.guildRedPakcet, i)
			end
			table.sort(private.guildRedPakcet, SortGuildRedPacket)
			EventSystem.Dispatch(EventID.UI_RedPacket_RefreshReceivePanel)
			CTL.RedPacket.ShowOrHideRedPacket()
		end

		if IsServerDataNotNil(msgResp.RightHistoryComponent) then -- 刷新红包历史消息
			local msgCount = 1
			-- 处理历史记录
			if IsServerDataNotNil(msgResp.RightHistoryComponent.HistoryInfosQueue) then
				for _, v in ipairs(msgResp.RightHistoryComponent.HistoryInfosQueue) do
					private.redPakcetRecord[msgCount] = v
					msgCount = msgCount + 1
				end
			end
			-- 处理多余的历史记录
			for i = #private.redPakcetRecord, msgCount, -1 do
				table.remove(private.redPakcetRecord, i)
			end
			table.sort(private.redPakcetRecord, function(a, b) return a.ObtainTimeStamp > b.ObtainTimeStamp end)
			EventSystem.Dispatch(EventID.UI_RedPacket_RefreshRecordPanel)
		end

	end
end
-- #endregion

-- #region 玩家领取势力红包
-- redPacketId : 如果不传则将全部列表发送给服务器，服务器会自动判断
function RedPacket_Model.ReceiveGuildRedPacketRequest(redPacketId)
	local msg = red_envelope_handle_pb.ReceiveGuildRedEnvelopeReq()
	if redPacketId then
    	table.insert(msg.IDs, redPacketId)
    	for i = #private.canReceiveRedPakcetIdList, 1, -1 do
    		if private.canReceiveRedPakcetIdList[i] == redPacketId then
				table.remove(private.canReceiveRedPakcetIdList, i)
    		end
    	end
	else
		if RedPacket_Model.CanReveiveRedPacketIsEmpty() then return end -- 如果可领取红包列表为空，则直接返回
		-- 将现有可领取红包全部发送给服务器，在回复的时候 服务会将仍然可领取的回复回来
		for i = #private.canReceiveRedPakcetIdList, 1, -1 do
			table.insert(msg.IDs, private.canReceiveRedPakcetIdList[i])	
			table.remove(private.canReceiveRedPakcetIdList, i)
		end
	end
	NetManager.SendMessage(MessageEnums.MessageReceiveGuildRedEnvelope, msg)
end

function private.ReceiveGuildRedPacketResponse(msgResp)
	if msgResp.Resp.Code ~= 0 then return end

	if msgResp.Feedback ~= ReceiveGuildRedEnvelopeFeedback.HasExpired then
		DealwithReceiveRecords(msgResp.ReceiveRecords)
		private.curShowRedPacketInfo = msgResp
		UIManager.CloseView(Const_UI_Lua.UIEnum.UIRewardGainPanel)
		CTL.RedPacket.OpenRedPacketInfo()
		if msgResp.Feedback == ReceiveGuildRedEnvelopeFeedback.ReceivedSuccessfully then
			CTL.Sound.PlayGameSound("UI_red_open")
		end
	end

	-- 根据返回值 弹出提示框
	if msgResp.Feedback == ReceiveGuildRedEnvelopeFeedback.HasBeenCollected then
		CTL.Tips.AddTipsMsg(Const_IDS.IDS_HongBao_Finished1)
	elseif msgResp.Feedback == ReceiveGuildRedEnvelopeFeedback.HasExpired then
		CTL.Tips.AddTipsMsg(Const_IDS.IDS_HongBao_HongBaoFailure)
	elseif msgResp.Feedback == ReceiveGuildRedEnvelopeFeedback.HasReceived then
		CTL.Tips.AddTipsMsg(Const_IDS.IDS_HongBao_GotTheHongBao)
	end

	-- 处理仍然可领取红包
	for _, v in ipairs(msgResp.StillCanReceiveIDs) do
		table.insert(private.canReceiveRedPakcetIdList, v)
	end

	-- 刷新红包列表
	RedPacket_Model.GetGuildRedPacketInfoRequest(true, RedPacket_Model.RightRequestForm.RequestReceiveContent)
	-- 刷新红点
	CTL.RedPacket.RefreshRedPoint()
end
-- #endregion

-- #region 玩家查看势力红包
function RedPacket_Model.SeeRedEnvelopeRequest(redPacketId)
	local msg = red_envelope_handle_pb.SeeRedEnvelopeReq()
	msg.ID = redPacketId
	NetManager.SendMessage(MessageEnums.MessageSeeRedEnvelope, msg)
end

function private.SeeRedEnvelopeResponse(msgResp)
	if IsServerDataNotNil(msgResp.BriefInfo) and IsServerDataNotNil(msgResp.ReceiveRecords) then
		DealwithReceiveRecords(msgResp.ReceiveRecords)
		private.curShowRedPacketInfo = msgResp
		CTL.RedPacket.OpenRedPacketInfo()
	else -- 如果查看失败则需要重新刷新（服务器会在固定时间将红包自动发放）
		RedPacket_Model.GetGuildRedPacketInfoRequest(true, RedPacket_Model.RightRequestForm.RequestReceiveContent)
	end
end
-- #endregion

-- #region 玩家发放势力红包
function RedPacket_Model.SendGuildRedEnvelopeRequest(redPacketId)
	local msg = red_envelope_handle_pb.IssueGuildRedEnvelopeReq()
	msg.ID = redPacketId
	NetManager.SendMessage(MessageEnums.MessageIssueGuildRedEnvelope, msg)
end

function private.SendGuildRedEnvelopeResponse(msgResp)
	-- 无论成功与否 都要刷新一遍界面
	RedPacket_Model.GetGuildRedPacketInfoRequest(true, RedPacket_Model.RightRequestForm.RequestReceiveContent)
end
-- #endregion

-- #region 玩家清理红包红点
function RedPacket_Model.ClearRedEnvelopeRedPointRequest()
	local msg = red_envelope_handle_pb.ClearRedEnvelopeRedPointReq()
	NetManager.SendMessage(MessageEnums.MessageClearRedEnvelopeRedPoint, msg)
end

function private.ClearRedEnvelopeRedPointResponse(msgResp)
end
-- #endregion

-- #region 新势力红包推送
function private.SyncNewGuildRedPacket(msg)
	for i, v in ipairs(msg.ID) do
		table.insert(private.canReceiveRedPakcetIdList, v)
	end
	CTL.RedPacket.ShowOrHideRedPacket()
	-- 刷新红点
	CTL.RedPacket.RefreshRedPoint()
end
-- #endregion

-- #region 玩家红包状态
function RedPacket_Model.SyncRedPacketReceiveTimesAndRedPoint(msg)
	private.redPacketReceiveTimes = msg.RedEnvelopeReceiveTimes
	EventSystem.Dispatch(EventID.UI_RedPacket_ReceiveTimes)

	private.hasNewRedEnvelope = msg.HasNewRedEnvelope
	-- 刷新红点
	CTL.RedPacket.RefreshRedPoint()
end
-- #endregion
---------- end 协议相关 end ----------

---------- start 数据获取相关 start ----------
-- #region 自身红包
function RedPacket_Model.SelfRedPacketIsEmpty()
	return #private.selfRedPacket == 0
end

function RedPacket_Model.GetSelfRedPacketIterator()
	return ipairs(private.selfRedPacket)
end
-- #endregion

-- #region 军团红包
function RedPacket_Model.GuildRedPakcetIsEmpty()
	return #private.guildRedPakcet == 0
end

function RedPacket_Model.GetGuildRedPacketIterator()
	return ipairs(private.guildRedPakcet)
end
-- #endregion

-- #region 红包记录
function RedPacket_Model.RedPakcetRecordIsEmpty()
	return #private.redPakcetRecord == 0
end

function RedPacket_Model.GetRedPakcetRecordIterator()
	return ipairs(private.redPakcetRecord)
end
-- #endregion

-- #region 当前红包
function RedPacket_Model.GetCurShowRedPacketBriefInfo()
	if private.curShowRedPacketInfo then
		return private.curShowRedPacketInfo.BriefInfo
	else
		return nil
	end
end

function RedPacket_Model.GetCurShowRedPacketReceiveRecordsIterator()
	return IpairsValue, private.curShowRedPacketInfo.ReceiveRecords, 0
end

-- 已经排过序，第一个是自身
function RedPacket_Model.GetSelfRedPacketReceiveRecords()
	if private.curShowRedPacketInfo then
		local data = private.curShowRedPacketInfo.ReceiveRecords[1]
		if data.PlayerACID == BattleDataGetter.GetAcID() then
			return data
		else
			return nil
		end
	else
		return nil
	end
end
-- #endregion

-- #region 获取最后一个可领取的红包ID
function RedPacket_Model.CanReveiveRedPacketIsEmpty()
	return #private.canReceiveRedPakcetIdList == 0
end
-- #endregion

-- #region 获取今日领取红包数量
function RedPacket_Model.GetRedPacketReceiveTimes()
	return private.redPacketReceiveTimes
end
-- #endregion

-- #region 当前是否有新红包
function RedPacket_Model.GetNotHasNewRedEnvelope()
	return not private.hasNewRedEnvelope
end
-- #endregion
---------- end 数据获取相关 end ----------

return RedPacket_Model