CapsuleEggModel = CapsuleEggModel or BaseClass(BaseVo, true)
local CapsuleEggModel = CapsuleEggModel

function CapsuleEggModel:__init()
	CapsuleEggModel.Instance = self
	self:Reset()
end

function CapsuleEggModel:Reset()
	self.stick_record_max_count = 0--1类记录最大条数（1、2档）
	self.normal_record_max_count = 0--2类记录最大条数（3档）
	self.max_record_count = 0--全服记录最大条数

	self.score_gtype_id = 100012--积分物品id

	self.ten_ticket_type_id = 102306

	self.is_show_warehouse_view = false --是否在临时仓库界面
	self.can_take_out_flag = false--物品tips是否展示取出按钮

	self.capsule_egg_kv_cfg = {}--扭蛋常量配置
	self.capsule_egg_reward_cfg = {}--扭蛋物品配置
	self.capsule_egg_score_shop_cfg = {}--扭蛋积分商城配置
	self.capsule_egg_time_reward_cfg = {}--扭蛋次数奖励配置

	self.capsule_egg_free_data = {}--免费抽奖信息
	self.capsule_egg_time_reward_data = false--次数抽奖信息

	self.normal_record_list = {}--普通记录
	self.stick_record_list = {}--置顶的两条极品记录
	self.all_record_list = {}--记录总表

	self.server_lucky = {}--全服幸运值列表

	self.score = 0--积分

	self.score_shop_data = {}--商城商品购买数据

	self.warehouse_data = {}--仓库物品数据

	self.now_reward_list = {}--当前抽奖的奖励列表

	self.now_choose_goods_id = nil--当前选中的仓库物品唯一id

	self.capsule_egg_red_dot_info = {}
	self.capsule_egg_timereward_red_dot_info = {}
	self.draw_btn_red_list = {}--pool_type|
	self.have_see_red_dot = false  --单抽券的红点，只显示一次

	self:InitCapsuleEggCfg()
end

function CapsuleEggModel:getInstance()
	if CapsuleEggModel.Instance == nil then
		CapsuleEggModel.Instance = CapsuleEggModel.New()
	end
	return CapsuleEggModel.Instance
end

-------配置相关--------------------S
--初始化配置信息
function CapsuleEggModel:InitCapsuleEggCfg(  )
	--常量配置
	for k,v in pairs(Config.Capsuleeggkv) do
		self.capsule_egg_kv_cfg[Trim(v.key)] = v
	end

	--奖品配置 奖池类型|奖品位置
	local t = {}
	for k,v in pairs(Config.Capsuleeggreward) do
		t[v.pool_type] = t[v.pool_type] or {}
		
		if v.client_pos ~= 0 then
			t[v.pool_type][v.client_pos] = v
		end
	end
	for i,v in ipairs(t) do
		self.capsule_egg_reward_cfg[i] = self.capsule_egg_reward_cfg[i] or {}
		for ii,vv in ipairs(v) do
			local reward_list = stringtotable(vv.reward) 
			for iii,vvv in ipairs(reward_list) do
				table.insert(self.capsule_egg_reward_cfg[i], vvv)
			end
		end
	end
	--附属奖励配置特殊处理
	if self.capsule_egg_reward_cfg[1] then
		local cfg = self.capsule_egg_kv_cfg["giving_reward"]
		if cfg then
			local reward = stringtotable(Trim(cfg.value))			
			table.insert(self.capsule_egg_reward_cfg[1], 2, reward[1])
		end
	end

	--积分商城配置
	for k,v in pairs(Config.Capsuleeggexchange) do
		self.capsule_egg_score_shop_cfg[v.id] = v
	end

	--次数奖励配置
	for k,v in pairs(Config.Capsuleeggtimesreward) do
		self.capsule_egg_time_reward_cfg[v.pool_type] = self.capsule_egg_time_reward_cfg[v.pool_type] or {}
		table.insert(self.capsule_egg_time_reward_cfg[v.pool_type], v)
	end
	for i,v in ipairs(self.capsule_egg_time_reward_cfg) do		
		table.sort( v, function( a, b)
			return a.draw_times < b.draw_times
		end )
	end

	self.stick_record_max_count = self.capsule_egg_kv_cfg["show_num_one"].value
	self.normal_record_max_count = self.capsule_egg_kv_cfg["show_num_two"].value
	self.max_record_count = self.stick_record_max_count + self.normal_record_max_count
end

--根据池子类型和抽的次数获取代币券id
function CapsuleEggModel:GetCostTicketGTypeId(pool_type,nums)
	local id = 0
	if nums == 1 then
		id = self:GetOneCostData(pool_type)
	elseif nums == 10 then
		id = self:GetTenCostData(pool_type)
	elseif nums == 50 then
		id = self:GetFiftyCostData(pool_type)
	end
	return id
end

--获取代币券数量列表
function CapsuleEggModel:GetCostTicketNumList(  )
	local ticket_num_list = {}
	for i=1,3 do
		ticket_num_list[i] = ticket_num_list[i] or {}
		ticket_num_list[i][1] = GoodsModel:getInstance():GetGoodsNumFromType(0,self:GetCostTicketGTypeId(i,1))
		ticket_num_list[i][2] = GoodsModel:getInstance():GetGoodsNumFromType(0,self:GetCostTicketGTypeId(i,10))
		ticket_num_list[i][3] = GoodsModel:getInstance():GetGoodsNumFromType(0,self:GetCostTicketGTypeId(i,50))
	end
	return ticket_num_list
end

--获取单抽的消耗
function CapsuleEggModel:GetOneCostData(pool_type)
	if pool_type == 1 then
		return stringtotable(self.capsule_egg_kv_cfg["long_one_cost_ticket"].value)[1][2]
	elseif pool_type == 2 then
		return stringtotable(self.capsule_egg_kv_cfg["xuan_one_cost_ticket"].value)[1][2]
	elseif pool_type == 3 then
		return stringtotable(self.capsule_egg_kv_cfg["hua_one_cost_ticket"].value)[1][2]
	end
end

--获取十连的消耗
function CapsuleEggModel:GetTenCostData(pool_type)
	if pool_type == 1 then
		return stringtotable(self.capsule_egg_kv_cfg["long_ten_cost_ticket"].value)[1][2]
	elseif pool_type == 2 then
		return stringtotable(self.capsule_egg_kv_cfg["xuan_ten_cost_ticket"].value)[1][2]
	elseif pool_type == 3 then
		return stringtotable(self.capsule_egg_kv_cfg["hua_ten_cost_ticket"].value)[1][2]
	end
end

--获取五十连的消耗
function CapsuleEggModel:GetFiftyCostData(pool_type)
	if pool_type == 1 then
		return stringtotable(self.capsule_egg_kv_cfg["long_fifty_cost_ticket"].value)[1][2]
	elseif pool_type == 2 then
		return stringtotable(self.capsule_egg_kv_cfg["xuan_fifty_cost_ticket"].value)[1][2]
	elseif pool_type == 3 then
		return stringtotable(self.capsule_egg_kv_cfg["hua_fifty_cost_ticket"].value)[1][2]
	end
end

--根据奖品配置id获取其配置
function CapsuleEggModel:GetCfgByRewardCfgId(reward_cfg_id)
	if Config.Capsuleeggreward[reward_cfg_id] then
		return Config.Capsuleeggreward[reward_cfg_id]
	else
		return nil
	end
end

--获取pooltype类型奖池的奖品配置
function CapsuleEggModel:GetRewardCfg(pool_type)
	if self.capsule_egg_reward_cfg[pool_type] then
		return self.capsule_egg_reward_cfg[pool_type]
	else
		return nil
	end
end

--获取pooltype类型奖池的次数奖励配置
function CapsuleEggModel:GetTimeRewardCfg(pool_type)
	if self.capsule_egg_time_reward_cfg[pool_type] then
		return self.capsule_egg_time_reward_cfg[pool_type]
	else
		return nil
	end
end

--获取pooltype类型奖池的次数奖励展示配置
function CapsuleEggModel:GetShowTimeRewardCfg()
	local cfg = self.capsule_egg_kv_cfg["show_reward"]
	local reward_list = {}
	if cfg then
		reward_list = stringtotable(Trim(cfg.value))
	end
	return reward_list
end

--获取pooltype类型奖池的pos位置的奖品配置
function CapsuleEggModel:GetRewardCfgByPos(pool_type,pos)
	if self.capsule_egg_reward_cfg[pool_type] and self.capsule_egg_reward_cfg[pool_type][pos] then
		return self.capsule_egg_reward_cfg[pool_type][pos]
	else
		return nil
	end
end

--获取积分商城配置
function CapsuleEggModel:GetScoreShopCfg(  )
	return self.capsule_egg_score_shop_cfg
end
-------配置相关--------------------E


--设置扭蛋免费信息 17000\17003
function CapsuleEggModel:SetCapsuleEggFreeDrawData(vo)
	-- print('Cat:CapsuleEggModel.lua[217] SetCapsuleEggFreeDrawData')
	-- PrintTable(vo)
	self.capsule_egg_free_data[vo.pool_type] = {}
	self.capsule_egg_free_data[vo.pool_type].pool_type = vo.pool_type
	self.capsule_egg_free_data[vo.pool_type].free_times = vo.free_times
	self.capsule_egg_free_data[vo.pool_type].next_free_draw = vo.next_free_draw
	self.capsule_egg_free_data[vo.pool_type].sum_draw_times = vo.sum_draw_times
	self:CountDownFreeTime(vo.pool_type)
	self:UpdateTimeRewardRedDot(vo.pool_type)
	self:Fire(CapsuleEggConst.UPDATE_CAPSULE_EGG_FREE_COUNT_DOWN,vo.pool_type)

	self:Fire(CapsuleEggConst.UPDATE_RED_DOT, vo.pool_type)
end

--获取免费抽奖次数
function CapsuleEggModel:GetFreeDrawTimesByPoolType(pool_type)
	if self.capsule_egg_free_data[pool_type] then
		return self.capsule_egg_free_data[pool_type].free_times
	else
		return 0
	end
end

--获取下一次抽奖的时间戳
function CapsuleEggModel:GetNextFreeDrawTimeByPoolType(pool_type)
	if self.capsule_egg_free_data[pool_type] then
		return self.capsule_egg_free_data[pool_type].next_free_draw
	else
		return 0
	end
end

--获取抽奖次数
function CapsuleEggModel:GetSumDrawTimesByPoolType(pool_type)
	if self.capsule_egg_free_data[pool_type] then
		return self.capsule_egg_free_data[pool_type].sum_draw_times
	else
		return 0
	end
end

--判断该记录是否是需要置顶的|2档以上
function CapsuleEggModel:IsRecordNeedStick(reward_cfg_id)
	return self:GetCfgByRewardCfgId(reward_cfg_id).color <= 2
end

--判断该记录是否需要筛选掉 4档的记录前端不需要，但是需要通过17002协议来刷新全服幸运值
function CapsuleEggModel:IsRecordNeedIgnore(reward_cfg_id)
	return self:GetCfgByRewardCfgId(reward_cfg_id).color >= 4
end

--设置全服记录 17001
function CapsuleEggModel:SetRecord(vo)--1|龙神扭蛋 2|炫武扭蛋 3|华裳扭蛋
	--记录全服幸运值
	self:SetServerlucky(vo.pool_type,vo.server_lucky)

	self.normal_record_list[vo.pool_type] = {}
	self.stick_record_list[vo.pool_type] = {}
	self.all_record_list[vo.pool_type] = {}
	--分类记录
	for k,v in pairs(vo.draw_log) do
		v.pool_type = vo.pool_type
		if v.is_stick == 1 then
			table.insert(self.stick_record_list[vo.pool_type],v)
		else
			table.insert(self.normal_record_list[vo.pool_type],v)
		end
		table.insert(self.all_record_list[vo.pool_type],v)
	end
    --排序记录
    local function sort(a, b)
   		return a.record_time < b.record_time
  	end
    table.sort(self.stick_record_list[vo.pool_type], sort)
    table.sort(self.normal_record_list[vo.pool_type], sort)
    table.sort(self.all_record_list[vo.pool_type], sort)
end

--添加全服记录 17002
function CapsuleEggModel:AddRecord(vo)
	--记录全服幸运值
	self:SetServerlucky(vo.pool_type,vo.server_lucky)

	self.normal_record_list[vo.pool_type] = self.normal_record_list[vo.pool_type] or {}
	self.stick_record_list[vo.pool_type] = self.stick_record_list[vo.pool_type] or {}
	
	if vo.is_stick == 1 then
		table.insert(self.stick_record_list[vo.pool_type], vo)
		if #self.stick_record_list[vo.pool_type] > self.stick_record_max_count then
			table.remove(self.stick_record_list[vo.pool_type], 1)
	    end
	else
		table.insert(self.normal_record_list[vo.pool_type], vo)
		if #self.normal_record_list[vo.pool_type] > self.normal_record_max_count then
			table.remove(self.normal_record_list[vo.pool_type], 1)
	    end
	end

	self.all_record_list[vo.pool_type] = {}
	for i,v in ipairs(self.stick_record_list[vo.pool_type]) do
		self.all_record_list[vo.pool_type][#self.all_record_list[vo.pool_type]+1] = v
	end
	for i,v in ipairs(self.normal_record_list[vo.pool_type]) do
		self.all_record_list[vo.pool_type][#self.all_record_list[vo.pool_type]+1] = v
	end
	local function sort(a, b)
   		return a.record_time < b.record_time
  	end
    table.sort(self.all_record_list[vo.pool_type], sort)
end

--获取置顶记录列表
function CapsuleEggModel:GetStickRecordList(pool_type)
	return self.stick_record_list[pool_type] and self.stick_record_list[pool_type] or {}
end

--获取普通记录列表
function CapsuleEggModel:GetNormalRecordList(pool_type)
	return self.normal_record_list[pool_type] and self.normal_record_list[pool_type] or {}
end

--获取全服记录总列表
function CapsuleEggModel:GetAllRecordList(pool_type)
	return self.all_record_list[pool_type] or {}
end

--设置全服幸运值 17001\17002\17010
function CapsuleEggModel:SetServerlucky(pool_type,lucky)
	self.server_lucky[pool_type] = lucky
	self:Fire(CapsuleEggConst.UPDATE_CAPSULE_SERVER_LUCKY)
end

--获取全服幸运值
function CapsuleEggModel:GetServerlucky(pool_type)
	return self.server_lucky[pool_type] and self.server_lucky[pool_type] or 0
end

--设置积分 17004
function CapsuleEggModel:SetCapsuleEggScore(score)
	self.score = score
	self:Fire(CapsuleEggConst.UPDATE_CAPSULE_EGG_SCORE)
end

--获取积分
function CapsuleEggModel:GetCapsuleEggScore(  )
	return self.score
end

--设置商城商品购买信息 17005   |pos:商品位置|gtype_id:商品类型Id|type:兑换类型|num:剩余兑换的次数
function CapsuleEggModel:SetCapsuleEggScoreShopData(vo)
	for k,v in pairs(vo.goods_list) do
		self.score_shop_data[v.pos] = {}
		self.score_shop_data[v.pos].pos = v.pos
		self.score_shop_data[v.pos].gtype_id = v.gtype_id
		self.score_shop_data[v.pos].num = v.num
	end
end

--兑换商品后刷新数据 17006
function CapsuleEggModel:UpdateCapsuleEggScoreShopData(vo)
	self.score_shop_data[vo.pos] = {}
	self.score_shop_data[vo.pos].pos = vo.pos
	self.score_shop_data[vo.pos].gtype_id = vo.gtype_id
	self.score_shop_data[vo.pos].num = vo.num
end

--根据pos位置获取商品购买信息
function CapsuleEggModel:GetCapsuleEggScoreShopDataByPos(pos)
	return self.score_shop_data[pos] and self.score_shop_data[pos] or nil
end

--设置仓库物品数据 17007
function CapsuleEggModel:SetWarehouseData(vo)
	self.warehouse_data = {}
	for k,v in pairs(vo.goods_list) do
		table.insert(self.warehouse_data,v)
	end
	local function sort(a, b)
   		return a.create_time < b.create_time
  	end
    table.sort(self.warehouse_data, sort)
    self:SetWarehouseRed(#self.warehouse_data > 0)
end

--获取仓库物品列表
function CapsuleEggModel:GetWarehouseData(  )
	return self.warehouse_data
end

--清空仓库物品列表
function CapsuleEggModel:ClearWarehouseData(  )
	self.warehouse_data = {}
	self:SetWarehouseRed(false)
end

--物品tips是否展示“取出”按钮
function CapsuleEggModel:IsShowCapsuleEggTakeOutBtn(  )
	return self.is_show_warehouse_view and self.can_take_out_flag
end

--获取当前选中的仓库物品唯一id
function CapsuleEggModel:GetWarehouseNowSelectedGoodsId(  )
	return self.now_choose_goods_id
end

--重置选中的仓库物品唯一id
function CapsuleEggModel:ResetWarehouseNowSelectedGoodsId(  )
	self.now_choose_goods_id = nil
	self.can_take_out_flag = false
end

--返回奖励列表中的最高档位
function CapsuleEggModel:GetRewardMaxGear(reward_list)
	local max_gear = 4
	local reward_cfg = {}
	for k,v in pairs(reward_list) do
		reward_cfg = self:GetCfgByRewardCfgId(v.reward_cfg_id)
		if reward_cfg.color < max_gear then
			max_gear = reward_cfg.color
		end
	end
	return max_gear
end

--保存当前抽奖的奖励列表
function CapsuleEggModel:SetNowRewardList(reward_list)
	self.now_reward_list = reward_list
	self:SetWarehouseRed(#self.now_reward_list > 0)
end

--获取当前抽奖的奖励列表
function CapsuleEggModel:GetNowRewardList()
	return self.now_reward_list
end

--是否能免费单抽
function CapsuleEggModel:CanFreeDraw(pool_type)
	return self:GetFreeDrawTimesByPoolType(pool_type) > 0
end

--免费单抽倒计时
function CapsuleEggModel:CountDownFreeTime(pool_type)
	self:CancelTimer(pool_type)
	local timer_func = function()
		self:CancelTimer(pool_type)
		self:Fire(CapsuleEggConst.REQUEST_CCMD_EVENT,17000,pool_type)
	end
	if self:GetNextFreeDrawTimeByPoolType(pool_type) ~= 0 then
		self["timer_id"..pool_type] = GlobalTimerQuest:AddPeriodQuest(timer_func, self:GetNextFreeDrawTimeByPoolType(pool_type)+1)
	end
end

function CapsuleEggModel:CancelTimer(pool_type)
    if self["timer_id"..pool_type] then
        GlobalTimerQuest:CancelQuest(self["timer_id"..pool_type])
        self["timer_id"..pool_type] = nil
    end
end

--该奖池是否开放
function CapsuleEggModel:IsPoolOpen(pool_type)
	-- if not GetModuleIsOpen(170) then 
	-- 	return false 
	-- else
	-- 	if pool_type == 1 then
	-- 		return true
	-- 	elseif pool_type == 2 then
	-- 		return RoleManager.Instance.mainRoleInfo.level >= self.capsule_egg_kv_cfg["open_lv"].value
	-- 	elseif pool_type == 3 then
	-- 		return ServerTimeModel:getInstance():GetOpenServerDay() >= self.capsule_egg_kv_cfg["open_day"].value
	-- 	end
	-- 	-- return GetModuleIsOpen(170,pool_type)
	-- end
	local is_open = GetModuleIsOpen(170,pool_type)
	return is_open
end

--红点
function CapsuleEggModel:IsNeedRedAll(  )
	for k,v in pairs(CapsuleEggConst.RedType) do
		self:IsNeedRed(v)
	end
end

function CapsuleEggModel:IsNeedRed( tab_id )
	local bool = false
	if tab_id == CapsuleEggConst.RedType.Dragon then
		bool = self:CheckCapsuleEggRed(1)
	elseif tab_id == CapsuleEggConst.RedType.Weapon then
		bool = self:CheckCapsuleEggRed(2)
	elseif tab_id == CapsuleEggConst.RedType.Clothes then
		bool = self:CheckCapsuleEggRed(3)
	-- elseif tab_id == CapsuleEggConst.RedType.Warehouse then
	-- 	bool = self:CheckWarehouseRed()
	end
	self.capsule_egg_red_dot_info[tab_id] = bool
	self:Fire(CapsuleEggConst.ANS_UPDATE_RED_DOT,tab_id,bool)
end

function CapsuleEggModel:GetAllRedDot(  )
	return self.capsule_egg_red_dot_info
end

function CapsuleEggModel:CheckCapsuleEggRed(pool_type)
	if not self:IsPoolOpen(pool_type) then return false end
	local cost_ticket_num_list = self:GetCostTicketNumList()
	local is_ticket_enough = false

	for i,v in ipairs(cost_ticket_num_list[pool_type]) do
		self.draw_btn_red_list[pool_type] = self.draw_btn_red_list[pool_type] or {}
		self.draw_btn_red_list[pool_type][i] = false
		--优化文档需求：如果是单抽券 大于6张或以上给红点，如果是十连五十连券 大于1张或以上就给红点
		if i == 1 then
			if v >= 6 then
				is_ticket_enough = true
				self.draw_btn_red_list[pool_type][i] = true
			end
		elseif i == 3 then--50连屏蔽
			self.draw_btn_red_list[pool_type][i] = false
		else
			if v > 0 then
				is_ticket_enough = true
				self.draw_btn_red_list[pool_type][i] = true
			end
		end
	end

	local can_free = self:GetFreeDrawTimesByPoolType(pool_type) > 0

	return can_free or is_ticket_enough
end

--获取抽奖按钮红点 btn_type:  1|单抽  2|十连  3|五十连
function CapsuleEggModel:GetDrawBtnRed(pool_type,btn_type)
	if not self:IsPoolOpen(pool_type) then return false end
	if self.draw_btn_red_list[pool_type] then
		return self.draw_btn_red_list[pool_type][btn_type]
	else
		return false
	end 
end

function CapsuleEggModel:SetWarehouseRed(bool)
	self.warehouse_red = bool
	self:Fire(CapsuleEggConst.UPDATE_RED_DOT,CapsuleEggConst.RedType.Warehouse)
end

function CapsuleEggModel:CheckWarehouseRed(  )
	return self.warehouse_red
end

function CapsuleEggModel:GetRedByRedType(RedType)
	return self.capsule_egg_red_dot_info[RedType] or false
end

--代币券数量刷新
function CapsuleEggModel:UpdateCostTicketNum(  )
	self:Fire(CapsuleEggConst.UPDATE_CPASULE_EGG_GOODS_NUM)
	-- self:Fire(CapsuleEggConst.UPDATE_RED_DOT,CapsuleEggConst.RedType.Dragon)
	-- self:Fire(CapsuleEggConst.UPDATE_RED_DOT,CapsuleEggConst.RedType.Weapon)
	-- self:Fire(CapsuleEggConst.UPDATE_RED_DOT,CapsuleEggConst.RedType.Clothes)
	self:Fire(CapsuleEggConst.UPDATE_RED_DOT)
end

--设置次数奖励信息
function CapsuleEggModel:SetTimesRewardInfo(vo)
	self.capsule_egg_time_reward_data = self.capsule_egg_time_reward_data or {}	
	self.capsule_egg_time_reward_data[vo.pool_type] = vo.reward_status_list
	self:UpdateTimeRewardRedDot(vo.pool_type)
	self:Fire(CapsuleEggConst.OPEN_CAPSULE_EGG_REWARD_UPDATE, vo.pool_type)
	self:Fire(CapsuleEggConst.UPDATE_RED_DOT)
end

--更新次数奖励红点
function CapsuleEggModel:UpdateTimeRewardRedDot(pool_type)
	local cfg = self:GetTimeRewardCfg(pool_type)	
	if cfg then
		local draw_times =  self:GetSumDrawTimesByPoolType(pool_type)
		self.capsule_egg_timereward_red_dot_info[pool_type] = {}
		for k,v in pairs(cfg) do
			local status = self:GetTimesRewardStatusByTimes(pool_type, v.draw_times)
			if status == false and draw_times >= v.draw_times then
				self.capsule_egg_timereward_red_dot_info[pool_type] = true
				break
			end
		end
	end		
end

--获取次数奖励红点
function CapsuleEggModel:GetTimeRewardRedDot()
	local b = false
	for k,v in pairs(self.capsule_egg_timereward_red_dot_info) do
		if v == true then
			b = true
			break
		end
	end
	return b
end

--获取次数奖励状态
function CapsuleEggModel:GetTimesRewardStatusByTimes(pool_type, times)
	local b = false
	if not self.capsule_egg_time_reward_data then
		b = nil
	else
		if self.capsule_egg_time_reward_data[pool_type] then
			for k,v in pairs(self.capsule_egg_time_reward_data[pool_type]) do
				if times == v.times then
					b = v.status == 1
				end
			end
		end
	end

	return b
end

--获取次数奖励时间戳
function CapsuleEggModel:GetTimesRewarResetTime()
	local openDay = ServerTimeModel:getInstance():GetOpenServerDay()
	local current_week = tonumber(TimeUtil:GetCurrentWeekDay()) 
	current_week = current_week == 0 and 7 or current_week
	local next_monday = 7 - current_week + 1	
	--如果开服是 周 5，6,7则下周1才算奖励
	if openDay <= 3 then
		local week = tonumber(TimeUtil:GetWeekStrByOpenDay(1))
		if week and week >= 5 and next_monday < 7 then
			next_monday = next_monday + 7
		end
	end
	local next_monday_time_stamp = TimeUtil:GetFutureZeroStampServer(next_monday)
	return next_monday_time_stamp
end

--单抽券的红点，只显示一次
function CapsuleEggModel:CheckHaveSeeRedDot()
	self.have_see_red_dot = true
	self:Fire(CapsuleEggConst.UPDATE_RED_DOT)
end

--获取列表中需要展示的ssr，usr，大奖附赠列表
function CapsuleEggModel:GetBigRewardList(reward_list)

	-- reward_list = {
	-- 	[1] = {gtype_id = 330902},
	-- 	[2] = {gtype_id = 330903},
	-- 	[3] = {gtype_id = 330213},
	-- 	[4] = {gtype_id = 330309},
	-- 	[5] = {gtype_id = 330310},
	-- 	[6] = {gtype_id = 330107},
	-- 	[7] = {gtype_id = 330107},
	-- 	[8] = {gtype_id = 330107},
	-- 	[9] = {gtype_id = 330107},
	-- 	[10] = {gtype_id = 330107},
	-- }

	-- gtype_id = 330310	
	-- goods_num = 1	
	-- reward_cfg_id = 43	
	local show_reward_list = {}
	-- local dragon_reward_cfg = self:GetRewardCfgByPos(1,1)[2]
	local dragon_reward_type_id = self:GetRewardCfgByPos(1,1)[2]
	for k,v in pairs(reward_list) do
		local war_soul_cfg = WarSoulModel:getInstance():GetWarSoulCfg(v.gtype_id)
		if war_soul_cfg and war_soul_cfg.color >= 4 and war_soul_cfg.type ~= 999 then
			local temp_data = {}
			temp_data.gtype_id = v.gtype_id
			temp_data.cfg_war_soul = war_soul_cfg
			if dragon_reward_type_id == v.gtype_id then--获得了超级大奖
				temp_data.sort_id = 2
				temp_data.is_war_soul = 1
				table.insert(show_reward_list,temp_data)
				local dargon_temp_data = {
					gtype_id = stringtotable(Config.Capsuleeggkv[29].value)[1][2],
					sort_id = 2,
					is_war_soul = 2,
					cfg_war_soul = nil,
				}
				table.insert(show_reward_list,dargon_temp_data)
			else--其他的战魂
				if war_soul_cfg.color >= 5 then
					temp_data.sort_id = 3
					temp_data.is_war_soul = 1
				else
					temp_data.sort_id = 1
					temp_data.is_war_soul = 1
				end
				table.insert(show_reward_list,temp_data)
			end
		end
	end

	local arg = {"sort_id","is_war_soul"}
    local condition = {Array.UPPER,Array.UPPER}
    SortTools.MoreKeysSorter(show_reward_list, arg, condition)

    return show_reward_list
end