AchieveModel = AchieveModel or BaseClass(BaseVo)

AchieveModel.REQUEST_CCMD_EVENT = "AchieveModel.REQUEST_CCMD_EVENT" --请求协议
-- AchieveModel.GET_NEW_ACHV = "AchieveModel.GET_NEW_ACHV" --有新成就可以领取
AchieveModel.UPDATE_ACHV_OVER_STAR = "AchieveModel.UPDATE_ACHV_OVER_STAR" --更新成就总览星数
-- AchieveModel.REMOVE_TIPS_VIEW = "AchieveModel.REMOVE_TIPS_VIEW" --移除成就弹窗

AchieveModel.UPDATE_ACHV_COMPLELE = "AchieveModel.UPDATE_ACHV_COMPLELE" --成就完成度的刷新
AchieveModel.SHOW_GET_ALL_REDDOT = "AchieveModel.SHOW_GET_ALL_REDDOT" --刷新一键领取的红点
AchieveModel.JINGOODS_FLY_EFFECT = "AchieveModel.JINGOODS_FLY_EFFECT" --成就界面的  显示红钻获得时的动画

------明日新增
AchieveModel.UPDATE_MAIN_TYPE_PROGRESS = "AchieveModel.UPDATE_MAIN_TYPE_PROGRESS" -- 更新成就大类进度信息
-- AchieveModel.RECEIVE_CHAPTER_REWARD_SUCCEED = "AchieveModel.RECEIVE_CHAPTER_REWARD_SUCCEED" -- 成就章节奖励领取成功刷新事件
AchieveModel.UPDATE_ACHIEVE_DATA = "AchieveModel.UPDATE_ACHIEVE_DATA" -- 根据成就章节更新成就小类item
AchieveModel.OPEN_ACHIEVE_TIPS_VIEW = "AchieveModel.OPEN_ACHIEVE_TIPS_VIEW" -- 新版成就完成弹窗事件
AchieveModel.UPDATE_ACHIEVE_LV_DATA = "AchieveModel.UPDATE_ACHIEVE_LV_DATA" -- 更新成就等级经验数据
AchieveModel.UPDATE_PRIVILEGE_REWARD_STATUS = "AchieveModel.UPDATE_PRIVILEGE_REWARD_STATUS" -- 更新成就特权奖励状态
AchieveModel.UPDATE_ACHIEVE_RED = "AchieveModel.UPDATE_ACHIEVE_RED" -- 更新成就红点
-- AchieveModel.OPEN_ACHIEVE_MAIN_VIEW = "AchieveModel.OPEN_ACHIEVE_MAIN_VIEW" -- 打开成就主界面
AchieveModel.UPDATE_EXCHANGE_DATA = "AchieveModel.UPDATE_EXCHANGE_DATA" -- 更新特权交易券兑换情况数据
AchieveModel.OPEN_GUILD_SPEED_TIP_VIEW = "AchieveModel.OPEN_GUILD_SPEED_TIP_VIEW" -- 打开公会竞速称号变更tip界面
AchieveModel.OPEN_ACHIEVE_PRIVILEGE_VIEW = "AchieveModel.OPEN_ACHIEVE_PRIVILEGE_VIEW" -- 打开成就特权
AchieveModel.UPDATE_DAILY_RED = "AchieveModel.UPDATE_DAILY_RED" -- 通知刷新日常界面红点
AchieveModel.UPDATE_ACHIEVE_TASK = "AchieveModel.UPDATE_ACHIEVE_TASK" -- 通知刷新任务列表
AchieveModel.UPDATE_BASE_VIEW = "AchieveModel.UPDATE_BASE_VIEW" -- 通知成就界面


-- 成就小类排序权值，由成就的完成状态决定
AchieveModel.StatusSortWeight = {
	[0] = 2, -- 未完成
	[1] = 1, -- 可领取
	[2] = 3, -- 已领取
}

-- 成就红点类型
AchieveModelRedType = {
	-- MainType = 1, -- 章节已完成
	Achieve = 2, -- 成就已完成
	Privilege = 3, -- 特权奖励
	Weekly = 4, -- 特权每周奖励
	Exchange = 5, -- 交易券兑换红点
}

AchieveModel.AchieveMainType = {
    [1] = 1, -- 养成
    [2] = 2, -- 活跃
    [3] = 3, -- 挑战
    [4] = 4, -- 收集
}

AchieveModel.SpecialOpenFun = {
	[405] = true,
}

local table_insert = table.insert

function AchieveModel:__init()
	self.Instance = self

	self.delay_open_tips = false
	---------------------------------
	-- 配置缓存
	self.achieve_cfg_cache = nil -- 成就内容缓存
	self.achi_privilege_cache = nil -- 成就特权缓存
	-- 协议相关
	self.login_achi_req = false  -- 登录首次请求全体协议进度
	self.chapter_progress_data = {} -- 成就章节进度信息
	self.achieve_data = {} -- 成就列表
	self.tip_achieve_data = {}  --AchieveTipsView 的所有tip的信息
	self.achieve_lv_data = nil -- 成就等级经验数据
	self.privilege_reward_status = {} -- 成就特权对应的奖励的领取情况
	self.achieve_exchange_data = {} -- 成就特权交易券兑换情况
	self.achieve_weekly_reward_status = 0 -- 成就特权周奖励领取状态 0-未满足条件 1-可领取 2-已领取
	self.exchange_login_red = true -- 首次登录的交易券红点
	self.achv_exhcange_btn_red = false -- 成就交易券兑换按钮红点
	-- 红点相关
	self.achieve_red_cache = {} -- 成就红点缓存 格式 self.achieve_red_cache[red_type][index] = true/false,成就类index为章节，特权为特权对应的成就等级
	self.achieve_red_data = {}
	---------------------------------
	self.QUICK_GET_LEVEL = tonumber(Config.Achievementkv["auto_receive_lv"].value) -- 可以快捷领取的最大等级 小于等于这个等级可以直接领取 大于这个等级改为跳转
	self.total_achieve_cache_red = false -- 总红点缓存
	self.achieve_max_count_cache = {} -- 成就最大数目缓存
	self.achieve_finsh_cache = {} -- 记录所有已经完成的成就id
	self.achieve_can_get_list = {} -- 记录所有可以领奖励的成就id
	self.recommend_list = {} -- 记录推荐任务列表
	self:InitAchieveCache(  )
end

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

-- 创建成就节点缓存
function AchieveModel:InitAchieveCache(  )
	if not self.achieve_cfg_cache then
		self.achieve_cfg_cache = {}
		self.achieve_max_count_cache = {} -- 记录了大类的成就总数
		self.achieve_task_show_cache = {} -- 记录在任务栏显示的推荐成就
		for k, v in pairs(Config.Achievementid) do
			self.achieve_cfg_cache[v.type] = self.achieve_cfg_cache[v.type] or {}
			self.achieve_cfg_cache[v.type][v.sub_type] = self.achieve_cfg_cache[v.type][v.sub_type] or {}
			self.achieve_cfg_cache[v.type][v.sub_type][v.id] = v
			-- table_insert(self.achieve_cfg_cache[v.type][v.sub_type], v)
			-- 计总数
			self.achieve_max_count_cache[v.type] = self.achieve_max_count_cache[v.type] or 0
			self.achieve_max_count_cache[v.type] = self.achieve_max_count_cache[v.type] + 1
			-- 记录推荐任务
			if v.task_position ~= 0 then
				self.achieve_task_show_cache[v.task_position] = self.achieve_task_show_cache[v.task_position] or {}
				self.achieve_task_show_cache[v.task_position][v.task_sequence] = v
			end
		end
		-- 插入一个字段记录每个大类的每个小类的起始成就id
		for main_type, v in pairs(self.achieve_cfg_cache) do
			for sub_type, vv in pairs(v) do
				local little_id = 99999999
				for id, vvv in pairs(vv) do
					if little_id > vvv.id  then
						little_id = vvv.id
					end
				end
				vv.first_id = little_id
			end
		end
		-- 成就同类型排序
		-- for k,v in pairs(self.achieve_cfg_cache) do
		-- 	for kk,vv in pairs(v) do
		-- 		local sort_func = function ( a, b )
		-- 			return a.id < b.id
		-- 		end
		-- 		table.sort(vv, sort_func)
		-- 	end
		-- end
		-- PrintTable(self.achieve_task_show_cache)
	end
end

function AchieveModel:GetAchieveMaxCount( main_type )
	if not main_type then return end
	if not self.achieve_max_count_cache[main_type] then
		self:InitAchieveCache()
	end
	return self.achieve_max_count_cache[main_type]
end
-- 创建特权节点缓存
function AchieveModel:InitAchievePrivilegeCache(  )
	if not self.achi_privilege_cache then
		self.achi_privilege_cache = {}
		for k, v in pairs(Config.Achievementstageprivilege) do
			self.achi_privilege_cache[#self.achi_privilege_cache+1] = v
		end
	end
end

-- 设置成就大类后端数据
function AchieveModel:SetMainTypeProgress( list )
	if not list then return end
	self.type_progress_data = self.type_progress_data or {}
	for k, v in ipairs(list) do
		self.type_progress_data[v.type] = v
	end
	-- 填充一下空数据
	for k,v in pairs(AchieveModel.AchieveMainType) do
		if not self.type_progress_data[v] then
			self.type_progress_data[v] = {
				type = v,
				count = 0,
			}
		end
	end
	-- 如果是首次登录，则需要获取全体进度的协议信息（待优化，这个遍历发送请求真的是太蛋疼了）
	if not self.login_achi_req then
		local function delay_method(  )
			for k, v in pairs(AchieveModel.AchieveMainType) do
				self:Fire(AchieveModel.REQUEST_CCMD_EVENT, 40902, v)
			end
			self.login_achi_req = true
		end
		setTimeout(delay_method, 3)
	end
end

-- 获取大类进度数据
function AchieveModel:GetMainTypeProgressData()
	return self.type_progress_data or {}
end

-- -- 成就协议相关逻辑start
-- -- 缓存成就章节进度信息 40900
-- function AchieveModel:SetChapterProgress(vo)
-- 	if not vo then return end
-- 	self.chapter_progress_data = self.chapter_progress_data or {}
-- 	for k, v in ipairs(vo.detailed_list) do
-- 		self.chapter_progress_data[v.category] = v
-- 	end
-- 	-- 如果是首次登录，则需要获取全体进度的协议信息（待优化，这个遍历发送请求真的是太蛋疼了）
-- 	if not self.login_achi_req then
-- 		local function delay_method(  )
-- 			for k, v in pairs(Config.Achievementcategoryreward) do
-- 				self:Fire(AchieveModel.REQUEST_CCMD_EVENT, 40902, v.category)
-- 			end
-- 			self.login_achi_req = true
-- 		end
-- 		setTimeout(delay_method, 3)
-- 	end
-- end

--[[-- 获取成就界面页签展示所需的章节进度信息,避免跳章节的问题,同时需要对章节进行升序排序
function AchieveModel:GetChapterProgressTabData(add_total_tab)
	local tb = {}
	local category_progress
	for k, v in pairs(Config.Achievementcategoryreward) do
		-- cfg = DeepCopy(v)
		-- category_progress = self:GetTargetChapterProgress(v.category)
		-- cfg.cur_count = category_progress.count or 0
		-- cfg.status = category_progress.status or 0
		tb[#tb+1] = v
	end
	local sort_func = function ( a, b )
		return a.category < b.category
	end
	table.sort(tb, sort_func)
	-- 需要添加总览页签按钮
	if add_total_tab then
		local total_tab = {
			name = "成就总览"
		}
		table.insert(tb, 1, total_tab)
	end
	return tb
end--]]

-- -- 根据成就章节直接查找章节整体进度数据
-- function AchieveModel:GetTargetChapterProgress(category)
-- 	if category then
-- 		return self.chapter_progress_data[category] or {}
-- 	else
-- 		return self.chapter_progress_data
-- 	end
-- end

-- -- 领取成就章节奖励成功后，前端刷新奖励领取标识并刷新界面 40901
-- function AchieveModel:UpdateChapterRewardStatus(category)
-- 	if category and self.chapter_progress_data[category] then
-- 		self.chapter_progress_data[category].status = 2 -- 2为已领取
-- 	end
-- end

-- 获取成就列表 40902
function AchieveModel:SetAchieveData(vo)
	self.achieve_data[vo.type] = {}
	for k, v in ipairs(vo.list) do
		v.sort_weight = AchieveModel.StatusSortWeight[v.status]
		self.achieve_data[vo.type][v.sub_type] = v
		self.achieve_data[vo.type][v.sub_type].type = vo.type
		self:RecordAchieveFinsh(v)
	end
	self:UpdateRecommendAchiList( true )
end

function AchieveModel:GetAchieveData(main_type)
	return main_type and self.achieve_data[main_type] or nil
end

-- 通过大类获取成就信息
function AchieveModel:GetAchieveDataByMainType( main_type )
	if not main_type then return end
	local tb = {}
	if not self.achieve_cfg_cache then
		self:InitAchieveCache()
	end
	for k, v in pairs(self.achieve_cfg_cache[main_type]) do
		-- 拿一下后端数据
		local first_data = v[v.first_id] -- 这个成就的起始数据
		local achieve_data = self:GetTargetAchieveData(first_data.type, first_data.sub_type)

		-- 有后端数据就查进度
		if achieve_data and achieve_data.id then
			for kk, vv in pairs(v) do
				if kk ~= "first_id" and achieve_data.id == vv.id then
					local temp = vv
					-- local temp = DeepCopy(vv)
					temp.progress = achieve_data.progress or 0
					temp.status = achieve_data.status or 0
					temp.sort_weight = achieve_data.sort_weight or AchieveModel.StatusSortWeight[temp.status]
					tb[#tb+1] = temp
					break
				end
			end
		else
			local temp = first_data
			temp.progress = 0
			temp.status = 0
			temp.sort_weight = AchieveModel.StatusSortWeight[temp.status]
			tb[#tb+1] = temp
		end
	end
	self:SortAchieveData(tb)
	return tb
end

--[[-- 获取成就章节中的成就节点数据(等配置,改为读取配置形式)
function AchieveModel:GetAchieveDataByCategory(category)
	if not category then return nil end
	local tb = {}
	local achieve_data
	if not self.achieve_cfg_cache then
		self:InitAchieveCache()
	end
	for k, v in pairs(self.achieve_cfg_cache[category]) do
		if v.category == category then
			achieve_data = self:GetTargetAchieveData(v.category, v.sub_category)
			v.progress = achieve_data.progress or 0
			v.status = achieve_data.status or 0
			v.sort_weight = achieve_data.sort_weight or AchieveModel.StatusSortWeight[v.status]
			tb[#tb+1] = v
		end
	end
	self:SortAchieveData(tb)
	return tb
end--]]


-- 根据成就章节和小类直接查找成就进度
function AchieveModel:GetTargetAchieveData(main_type, sub_type)
	return self.achieve_data[main_type] and self.achieve_data[main_type][sub_type] or {}
end

-- 领取成就奖励后，更新成就状态 40903
function AchieveModel:UpdateAchieveStatus(vo)
	if not vo then return end
	self.achieve_data[vo.type] = self.achieve_data[vo.type] or {}
	self.achieve_data[vo.type][vo.sub_type] = self.achieve_data[vo.type][vo.sub_type] or {}
	local cfg = self.achieve_cfg_cache[vo.type][vo.sub_type][vo.id]
	local need_anim = false
	if cfg.next_id and cfg.next_id ~= 0 then -- 有下一个任务 后端会发04协议刷新 这里就不刷了
		self.achieve_data[vo.type][vo.sub_type] = {
			type = vo.type,
			sub_type = vo.sub_type,
			id = cfg.next_id,
			status = 0,
			progress = 0,
			sort_weight = AchieveModel.StatusSortWeight[0],
		}
	else -- 没下一个任务了 所以后端不会发04过来刷新 所以得刷新界面
		self.achieve_data[vo.type][vo.sub_type].status = 2
		self.achieve_data[vo.type][vo.sub_type].sort_weight = AchieveModel.StatusSortWeight[2]
		need_anim = true -- 如果有任务完成了全部系列 需要动画
		self:Fire(AchieveModel.UPDATE_ACHIEVE_DATA, vo.type, need_anim)
	end
	self:RecordAchieveFinsh(self.achieve_data[vo.type][vo.sub_type])
	self:UpdateRecommendAchiList( true )
end

-- 给成就章节中的成就小类排序
function AchieveModel:SortAchieveData(list)
	local sort_func = function ( a, b )
		if a.status == b.status then
			local a_seq_cfg = Config.Achievementseq[a.type .. "@" .. a.sub_type]
			local b_seq_cfg = Config.Achievementseq[b.type .. "@" .. b.sub_type]
			if a_seq_cfg and b_seq_cfg then -- 排序表有数据就按排序表 排序
				return a_seq_cfg.seq < b_seq_cfg.seq 
			else -- 否则按子类排
				return a.sub_type < b.sub_type 
			end
		else
			return a.sort_weight < b.sort_weight
		end
	end
	table.sort(list, sort_func)
end

-- 更新成就信息 40904
function AchieveModel:UpdateAchieveData(list)
	if not list then return end
	for k, v in ipairs(list) do
		self.achieve_data[v.type] = self.achieve_data[v.type] or {}
		self.achieve_data[v.type][v.sub_type] = self.achieve_data[v.type][v.sub_type] or {}

		self.achieve_data[v.type][v.sub_type].status = v.status
		self.achieve_data[v.type][v.sub_type].id = v.id
		self.achieve_data[v.type][v.sub_type].progress = v.progress
		self.achieve_data[v.type][v.sub_type].sort_weight = AchieveModel.StatusSortWeight[v.status]
		-- 更新已完成成就缓存
		self:RecordAchieveFinsh(self.achieve_data[v.type][v.sub_type])
	end
	self:UpdateRecommendAchiList(  )
end

-- 更新对获得新的成就的数据的存储,并根据情况弹出提示界面 is_chapter:是否是章节奖励 40904 40905
function AchieveModel:SetAchieveTipData(data_list, is_chapter)
	if not data_list then return end
	local need_tips_view = false
	for i, data in ipairs(data_list) do
		if data.status == 1 then -- 出现已完成的成就就弹出提示界面
			local vo = {data = data, is_chapter = is_chapter}
			table_insert(self.tip_achieve_data, vo)
			need_tips_view = true
		end
	end
	if need_tips_view then
		self:Fire(AchieveModel.OPEN_ACHIEVE_TIPS_VIEW, true)
	end
end

-- 直接从缓存中推出一个成就
function AchieveModel:GetAchieveTipData()
	if self.tip_achieve_data and self.tip_achieve_data[1] then
		return table.remove(self.tip_achieve_data, 1)
	else
		return false
	end
end

function AchieveModel:RemoveAchieveTipData(not_remove)
	if not not_remove and #self.tip_achieve_data > 0 then
		table.remove(self.tip_achieve_data, 1)
	end
end

-- -- 更新章节进度信息 40905
-- function AchieveModel:UpdateMainTypeProgress(list)
-- 	if not list then return end
-- 	for k, v in ipairs(list) do
-- 		self.chapter_progress_data[v.type] = v
-- 	end
-- end

-- 获得成就等级经验数据 40906
function AchieveModel:SetAchieveLvData(vo)
	self.achieve_lv_data = vo
end
function AchieveModel:GetAchieveLvData(  )
	return self.achieve_lv_data or {}
end

-- 设置成就等级特权信息 40907
function AchieveModel:SetAchievePrivilegeStatus(vo)
	if not vo then return end
	for k, v in ipairs(vo.detial_list) do
		-- 这里的键值用的每个特权对应的那个等级，方便在特权节点那边获取数据
		self.privilege_reward_status[v.lv] = v
	end
end
function AchieveModel:GetAchievePrivilegeStatus(privilege_lv)
	return self.privilege_reward_status[privilege_lv] or {}
end
-- 获取成就特权按钮数据(需等特权配置)
function AchieveModel:GetAchievePrivilegeTabData(  )
	if not self.achi_privilege_cache then
		self:InitAchievePrivilegeCache()
		local sort_func = function ( a, b )
			return a.stage < b.stage
		end
		table.sort(self.achi_privilege_cache, sort_func)
	end
	return self.achi_privilege_cache
end

-- 更新成就特权奖励领取状态 40908
function AchieveModel:UpdateAchievePrivilegeStatus(vo)
	if not vo then return end
	self.privilege_reward_status[vo.lv] = self.privilege_reward_status[vo.lv] or {}

	self.privilege_reward_status[vo.lv] = vo
end

-- 获取交易券兑换情况 40910 40911
function AchieveModel:SetAchieveExchangeData(vo)
	self.achieve_exchange_data.now_count = vo.now_count
	self.achieve_exchange_data.max_count = vo.max_count
end
function AchieveModel:GetAchieveExchangeData(  )
	return self.achieve_exchange_data
end

-- 获取/领取周固定奖励 40912
function AchieveModel:SetWeeklyPrivilegeRewardStatus(vo)
	self.achieve_weekly_reward_status = vo.status
end
function AchieveModel:GetWeeklyPrivilegeRewardStatus(  )
	return self.achieve_weekly_reward_status
end
-- 成就协议相关逻辑end

-- 成就红点相关逻辑start
-- 检查成就红点
function AchieveModel:CheckAchieveAllRed(  )
	local bool = false
	bool = bool or self:CheckAchieveChapterRed()
	bool = bool or self:CheckAchieveItemRed()
	bool = bool or self:CheckAchievePrivilegeRed()
	bool = bool or self:CheckAcheiveWeeklyRewardRed()
	bool = bool or self:CheckAchieveExchangeRed()
	NewMainRoleModel:getInstance():Fire(NewMainRoleModel.UPDATE_RED_DOT, NewMainRoleModel.TabId.ROLE)
end
-- 根据红点类型更新红点缓存
function AchieveModel:CheckAchieveRed(type, is_all, index)
	local bool
	-- if type == AchieveModelRedType.Chapter then -- 章节完成红点
	-- 	bool = self:CheckAchieveChapterRed(index)
	-- else
	if type == AchieveModelRedType.Achieve then -- 成就完成红点
		bool = self:CheckAchieveItemRed(index)
	elseif type == AchieveModelRedType.Privilege then -- 成就特权终生奖励
		bool = self:CheckAchievePrivilegeRed(index)
	elseif type == AchieveModelRedType.Weekly then -- 成就特权每周奖励
		bool = self:CheckAcheiveWeeklyRewardRed()
	elseif type == AchieveModelRedType.Exchange then -- 成就特权交易券红点(不要了这个功能)
		bool = false -- self:CheckAchieveExchangeRed()
	end
	self:Fire(AchieveModel.UPDATE_ACHIEVE_RED, type, index, bool)
	if is_all then
		-- -- 发送事件更新角色界面的成就红点
		-- NewMainRoleModel:getInstance():Fire(NewMainRoleModel.UPDATE_RED_DOT, NewMainRoleModel.TabId.ROLE)
		GlobalEventSystem:Fire(AchieveModel.UPDATE_DAILY_RED)
	end
	return bool
end
-- 获取成就系统的缓存红点
-- type 红点类型  index 成就页签(章节),子类(小类)传对应的main_type  特权传指定的特权对应打的成就等级
function AchieveModel:GetAchieveCacheRed(type, index)
	if not type then 
		return false
	elseif not index then
		if type == AchieveModelRedType.Weekly or type == AchieveModelRedType.Exchange then
			return self.achieve_red_cache[type] or false
		else
			return self.achieve_red_cache[type] or {}
		end
	else
		return self.achieve_red_cache[type] and self.achieve_red_cache[type][index] or false
	end
end

-- 更新角色界面的成就页签红点
function AchieveModel:CheckMainRoleInfoViewAchieveRed()
	local bool = false
	for red_type, type_data in pairs(self.achieve_red_cache) do
		if type(type_data) == "table" then
			for k, has_red in pairs(type_data) do
				bool = has_red or bool
			end
		else
			bool = type_data or bool
		end
	end
	self:SetAchieveTotalRedCache( bool )
	return bool
end

-- 设置成就总红点
function AchieveModel:SetAchieveTotalRedCache( bool )
	self.total_achieve_cache_red = bool
end

-- 获取成就总红点
function AchieveModel:GetAchieveTotalRedCache( bool )
	return self.total_achieve_cache_red
end


--[[-- 获取成就章节完成的红点 category:传入章节将获得章节页签的红点
function AchieveModel:CheckAchieveChapterRed(category)
	self.achieve_red_cache[AchieveModelRedType.Chapter] = self.achieve_red_cache[AchieveModelRedType.Chapter] or {}
	local bool = false
	-- 若传入了特定的成就章节，则只更新对应的红点
	if category then
		bool = self.chapter_progress_data[category] and self.chapter_progress_data[category].status == 1 or false
		self.achieve_red_cache[AchieveModelRedType.Chapter][category] = bool
	else
		for k, v in pairs(self.chapter_progress_data) do
			-- 存在章节已完成的情况返回true(这里不考虑成就完成情况)
			bool = bool or v.status == 1
			self.achieve_red_cache[AchieveModelRedType.Chapter][v.category] = v.status and v.status == 1 or false
		end
	end
	return bool
end--]]

-- 获取成就小类(item)的红点
function AchieveModel:CheckAchieveItemRed(main_type)
	self.achieve_red_cache[AchieveModelRedType.Achieve] = self.achieve_red_cache[AchieveModelRedType.Achieve] or {}
	local bool = false
	-- 若传入了特定的成就章节，则只更新对应的红点
	if main_type then
		self.achieve_data[main_type] = self.achieve_data[main_type] or {}
		self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] = false -- 初始是没有红点
		for k, v in pairs(self.achieve_data[main_type]) do
			bool = bool or v.status == 1
			self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] = 
				self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] or v.status == 1
		end
	else
		-- 清除缓存
		self.achieve_red_cache[AchieveModelRedType.Achieve] = {}
		for k, main_type_data in pairs(self.achieve_data) do
			self.achieve_red_cache[AchieveModelRedType.Achieve][k] = false -- 本来没有红点
			for k2, achieve in pairs(main_type_data) do
				bool = bool or achieve.status == 1
				self.achieve_red_cache[AchieveModelRedType.Achieve][k] = 
					self.achieve_red_cache[AchieveModelRedType.Achieve][k] or achieve.status == 1
			end
		end
	end
	return bool
end

-- 检查成就特权奖励领取红点
function AchieveModel:CheckAchievePrivilegeRed(  )
	self.achieve_red_cache[AchieveModelRedType.Privilege] = self.achieve_red_cache[AchieveModelRedType.Privilege] or {}
	local bool = false
	local privilege_cfg
	for k, v in pairs(self.privilege_reward_status) do
		privilege_cfg = Config.Achievementstageprivilege[v.lv]
		if privilege_cfg and privilege_cfg.icon ~= 3 and privilege_cfg.icon ~= 4 then -- 过滤掉两个特殊处理红点的特权
			bool = bool or v.status == 1
			self.achieve_red_cache[AchieveModelRedType.Privilege][v.lv] = v.status == 1
		end
	end
	return bool
end

-- 检查成就特权每周奖励红点
function AchieveModel:CheckAcheiveWeeklyRewardRed(  )
	local bool = self.achieve_weekly_reward_status == 1
	self.achieve_red_cache[AchieveModelRedType.Weekly] = bool
	return bool
end

-- 检查成就交易券兑换特权页签红点
function AchieveModel:CheckAchieveExchangeRed(  )
	local bool = false
	if self.exchange_login_red then 
		bool = self:CheckAchieveExchangeBtnRed()
	end
	self.achieve_red_cache[AchieveModelRedType.Exchange] = bool
	return bool
end
-- 检查成就交易券兑换按钮红点(与页签红点分开)
function AchieveModel:CheckAchieveExchangeBtnRed(  )
	self.achv_exhcange_btn_red = false
	local cur_ach_lv = self.achieve_lv_data and self.achieve_lv_data.lv or 0
	for k, v in pairs(Config.Achievementstageprivilege) do
		if v.icon == 4 then -- 先判断是否达到目标特权所需成就等级
			self.achv_exhcange_btn_red = cur_ach_lv >= v.stage
		end
	end
	if self.achv_exhcange_btn_red then
		-- 判断有无剩余次数
		local time_data = self:GetAchieveExchangeData()
		if time_data.now_count and time_data.max_count then
			-- now_count:已经兑换的次数
			self.achv_exhcange_btn_red = time_data.now_count < time_data.max_count
		end
	end
	return self.achv_exhcange_btn_red
end
function AchieveModel:GetAchieveExchangeBtnRed(  )
	return self.achv_exhcange_btn_red
end
-- 红点逻辑 end

-- 界面获取数据的逻辑汇总
-- 根据等级获取当前成就特权等级
function AchieveModel:GetAchievePrivilegeLv(lv)
	lv = lv or self.achieve_lv_data.lv or 0
	local privilge_lv = 0
	for k, v in pairs(Config.Achievementstageprivilege) do
		-- 如果配置等级不高于当前成就等级，特权等级+1
		if v.stage <= lv then
			privilge_lv = privilge_lv + 1
		end
	end
	return privilge_lv
end

-- 是否解锁了每日十环扫荡日常的特权
function AchieveModel:HasUnlockedFreeDailyTask(  )
	local unlocked = false
	local cur_ach_lv = self.achieve_lv_data and self.achieve_lv_data.lv or 0
	for k, v in pairs(Config.Achievementstageprivilege) do
		if v.icon == 5 then -- 先判断是否达到目标特权所需成就等级
			unlocked = cur_ach_lv >= v.stage
			break
		end
	end
	return unlocked
end

-- 检查是否可以快捷领取
function AchieveModel:CheckCanQuickGetReward(  )
	return  RoleManager.Instance.mainRoleInfo.level <= self.QUICK_GET_LEVEL
end

-- 获取当前特权数据
function AchieveModel:GetCurPrivilegeStage(  )
	local cur_achieve_lv = self:GetAchieveLvData().lv or 1
	local privilege_data = self:GetAchievePrivilegeTabData()
	local index = 1
    for k,v in ipairs(privilege_data) do
        if v.stage <= cur_achieve_lv then
            index = k
        end
    end
    return index
end

-- 主界面用（totalview） 获取第一个可领的index 或者是下一个将可领取的index
function AchieveModel:GetCanGetPrivilegeStage(  )
	local cur_achieve_lv = self:GetAchieveLvData().lv or 1
	local privilege_data = self:GetAchievePrivilegeTabData()
	local index = 0
    for k,v in ipairs(privilege_data) do
        if v.stage <= cur_achieve_lv then
            index = k
    		local status_data = self:GetAchievePrivilegeStatus(v.stage)
            if status_data.status and status_data.status == 1 then -- 如果有奖领 就返回了
            	return index
            end
        end
    end
    if index ~= #privilege_data then -- 下一个可领特权
    	index = index + 1
    end
    return index
end

-- 获取当前特权的数据缓存
function AchieveModel:GetCurPrivilegeData(  )
	local index = self:GetCurPrivilegeStage(  )
	local privilege_data = self:GetAchievePrivilegeTabData()
	return privilege_data[index]
end

----------推荐任务相关-start---------
-- 更新列表 02 03 04协议更新成就进度后都会刷一下
function AchieveModel:UpdateRecommendAchiList( for_update )
	local count = TableSize(self.recommend_list) or 0
	self.recommend_list = {}
	for pos, list in ipairs(self.achieve_task_show_cache) do
		for seq, cfg in pairsByKeys(list) do
			if not self:AchiIsFinish(cfg.id) then --找到第一个未领取奖励的成就
				local progress_data = self:GetTargetAchieveData(cfg.type, cfg.sub_type)
				if progress_data and progress_data.id and progress_data.id < cfg.id then -- 进度还没到的成就不进推荐
					break
				end
				if self.achieve_can_get_list[cfg.id] then -- 当前可领奖的不放在推荐任务这里
					break
				end
				self.recommend_list[pos] = cfg
				break
			end
		end
	end
	local new_count = TableSize(self.recommend_list) or 0
	local is_achi_count_change = new_count ~= count
	self:Fire(AchieveModel.UPDATE_ACHIEVE_TASK, is_achi_count_change or for_update)
end

-- 获取推荐成就列表
function AchieveModel:GetRecommendAchiList(  )
	return self.recommend_list
end

-- 获取当前可领奖的成就任务列表
function AchieveModel:GetCanGetAchiList(  )
	return self.achieve_can_get_list
end

-- 判断指定成就是否已经完成(指的是领完奖励)
function AchieveModel:AchiIsFinish( id )
	return self.achieve_finsh_cache[id] == true
end

-- 记录已经完成的任务(指的是领完奖励)
function AchieveModel:RecordAchieveFinsh( data )
	-- if data.status ~= 2 then return end -- 只记录已经领取的任务
	if not self.achieve_cfg_cache then
		self:InitAchieveCache()
	end
	if not data.type then return end
	local cfg = self.achieve_cfg_cache[data.type][data.sub_type]
	if not cfg then return end
	for k,v in self:PairsByKeys( cfg ) do
		if k ~= "first_id" and v.id < data.id then
			self.achieve_finsh_cache[v.id] = true
			self.achieve_can_get_list[v.id] = nil
		elseif data.status == 2 and v.id == data.id then
			self.achieve_finsh_cache[v.id] = true
			self.achieve_can_get_list[v.id] = nil
		elseif data.status == 1 and v.id == data.id then
			self.achieve_can_get_list[v.id] = v
		end
	end
end

function AchieveModel:SetOpenFunCache( main_type, sub_type )
	self.temp_open_fun_cache = {
		main_type = main_type, 
		sub_type = sub_type,
	}
end

function AchieveModel:GetOpenFunCache(  )
	return self.temp_open_fun_cache
end

function AchieveModel:DelOpenFunCache(  )
	self.temp_open_fun_cache = nil
end

-- 通用那个不能带有string 这里会排除string的干扰
function AchieveModel:PairsByKeys(t)
	local temp = {}
	for k in pairs(t) do
		if type(k) == "number" then
			temp[#temp+1] = k
		end
	end
	table.sort(temp)
	local i = 0
	return function()
		i = i+1
		return temp[i], t[temp[i]]
	end
end

-- 解析描述进度的condition 返回进度字符串（0/1）
function AchieveModel:ParseCondition( cfg_data )
	local achieve_cfg = cfg_data
	local progress_data = self:GetTargetAchieveData(cfg_data.type, cfg_data.sub_type)
	progress_data.progress = progress_data.progress or 0
	local str = ""
	if achieve_cfg then
		local condition = stringtotable(achieve_cfg.condition)[1] -- 将成就的需求总数固定存在条件的第一个中
        local percentage = 0
        if condition[1] == "arena_rank" then -- 竞技联赛不显示进度，改为追加显示当前排行
            percentage = progress_data.status == 0 and 0 or 1
            local my_info = PkRankModel:getInstance().my_info
            if progress_data.status ~= 0 then 
                str = ""
            elseif not my_info or not my_info.rank or my_info.rank == 0 then
                str = string.format("当前名次：%s", HtmlColorTxt("未上榜", ColorUtil.GREEN_DARK)) 
            else
                str = string.format("当前名次：%s", HtmlColorTxt( tostring(my_info.rank), ColorUtil.GREEN_DARK) )
            end
        elseif condition[1] == "uranium_skill" then -- 技能激活
            str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/" .. condition[3]
        elseif condition[1] == "stage" then -- 进阶
            str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/1"
        else
            str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/" .. condition[2]
        end
	end
	local str = str ~= "" and "(" .. str .. ")" or ""
	return str
end
----------推荐任务相关-end-----------
----------成就动画状态-start---------
function AchieveModel:SetAchieveItemAnimState( is_anim )
	self.achieve_item_is_animing = is_anim
end

function AchieveModel:AchieveItemIsAniming(  )
	return self.achieve_item_is_animing
end

function AchieveModel:SetSCMDWaitFlag( bool )
	self.wait_scmd40903 = bool
end

function AchieveModel:GetSCMDWaitFlag(  )
	return self.wait_scmd40903
end
----------成就动画状态-end-----------