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

NatureModel.REQUEST_CCMD_EVENT = "NatureModel.REQUEST_CCMD_EVENT"
NatureModel.REPLACE_TAG = "NatureModel.REPLACE_TAG" -- 替换标签
NatureModel.UPDATE_CATEGORY_INFO = "NatureModel.UPDATE_CATEGORY_INFO" -- 替换标签
NatureModel.OPEN_UPGRADE_VIEW = "NatureModel.OPEN_UPGRADE_VIEW" -- 打开突破界面
NatureModel.SUCCESS_UPGRADE = "NatureModel.SUCCESS_UPGRADE" -- 成功突破
NatureModel.UPDATE_NATURE_REWARD_VIEW = "NatureModel.UPDATE_NATURE_REWARD_VIEW" -- 更新章节奖励界面
NatureModel.UPDATE_ADD_POINT_VIEW = "NatureModel.UPDATE_ADD_POINT_VIEW" -- 更新加点界面
NatureModel.UPDATE_TAG_VIEW = "NatureModel.UPDATE_ADD_POINT_VIEW" -- 更新标签界面
NatureModel.UPDATE_MAIN_VIEW = "NatureModel.UPDATE_MAIN_VIEW" -- 更新性格主界面
NatureModel.UPDATE_REWARD_RED_DOT = "NatureModel.UPDATE_REWARD_RED_DOT" -- 更新奖励红点
NatureModel.UPDATE_FREE_POINT_RED_DOT = "NatureModel.UPDATE_FREE_POINT_RED_DOT" -- 更新自由点数红点
NatureModel.UPDATE_UPGRADE_RED_DOT = "NatureModel.UPDATE_UPGRADE_RED_DOT" -- 性格突破红点
NatureModel.OPEN_AWARD_RESULT_VIEW = "NatureModel.OPEN_AWARD_RESULT_VIEW" -- 打开跑环奖励结算界面
NatureModel.OPEN_TAG_VIEW = "NatureModel.OPEN_TAG_VIEW" -- 打开tag界面
NatureModel.OPEN_ADD_POINT_VIEW = "NatureModel.OPEN_ADD_POINT_VIEW" -- 打开加点界面
NatureModel.OPEN_PRE_REWARD_VIEW = "NatureModel.OPEN_PRE_REWARD_VIEW" -- 打开奖励预览界面

NatureModel.CATEGORY_NAME = {
	[1] = "性格感知",
	[2] = "性格成长",
	[3] = "性格塑造",
}

NatureModel.RedDotTpye = {
	GET_REWRAD = "GET_REWRAD",
	FREE_POINT = "FREE_POINT",
}

-- 以下数据是固定的 不会变也不能变
local SPOT_COUNT = 4 -- 单个章节单个分支的节点数
local CATEGORY_COUNT = 3 -- 章节数
local NATURE_TYPE_COUNT = 3 -- 单章节分支数
local UPGRADRE_NEED_VALUE = Config.Naturebranch["1@1@1@1"].need_value -- 每一级升级所需的点数


function NatureModel:__init()
	NatureModel.Instance = self
end

function NatureModel:ResetData()
	self.nature_category_data = {}

	self.cur_nature_index_data = {}  -- 记录每个章节每个分支的最新进度
	--self:UpdateAllNatureIndex(  ) -- 先初始化一遍
	--self:InitNatureIndexData()

	self.free_value = 0 -- 自由点数
	self.total_nature_info = {}
	self.total_nature_level = 0	-- 当前等级
	self.pre_level = 0 -- 上一次的等级
	self.pre_overflow_value = 0 -- 上一次的经验
	self.overflow_value = 0	-- 当前经验
	self.category_reward_state = {} -- 章节奖励领取状态
	self.category_red_info = {} -- 记录了某个章节是否应该有红点

	self.category_light_times_data = {}
	self.has_tag_data = {}
	self.show_tag_data = {}
	self.point_lv_list = {} -- 记录了星空图的等级分布
	self:InitConfig()
	self:InitPointList()
	self:InitTaskNatureTextRange(  )
end

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

-----------------------------配置相关---start-------------------------
function NatureModel:InitConfig(  )
	self.config_Naturekv = {} -- 常量配置
	self.config_Naturebranch = {} -- 分支配置
	--self.branch_kv_data = {} -- 分支顺序表 （用来快速取出上对应数据的上一条数据）

	self.nature_total_point_data = {} -- 用来存三个分支性格的分别总点数（常量）
	self.category_total_point_data = {} -- 用来存三个章节性格的分别总点数（常量）
	for k,v in pairs(Config.Naturekv) do
		local key = Trim(v.key)
		self.config_Naturekv[key] = v
	end
	self.point_lv_list = stringtotable(self:GetNatureKv("interval").constant)
	-- logWarn('=======Msh:NatureModel.lua[85]=======')
	-- PrintTable(self.point_lv_list)

	for category=1, 3 do
		self.config_Naturebranch[category] = {}
		--self.branch_kv_data[category] = {}
		self.category_total_point_data[category] = 0
		for nature_type=1, 3 do
			self.nature_total_point_data[nature_type] = self.nature_total_point_data[nature_type] or 0
			self.config_Naturebranch[category][nature_type] = {}
			--self.branch_kv_data[category][nature_type] = {}
			--local branch_kv_t = self.branch_kv_data[category][nature_type]
			local index = 1
			for spot=1,4 do
				self.config_Naturebranch[category][nature_type][spot] = {}
				local temp = self.config_Naturebranch[category][nature_type][spot]
				local light_times = 1
                while true do
                	local key = string.format("%s@%s@%s@%s", category, nature_type, spot, light_times)
                	local data = Config.Naturebranch[key]
                	if not data then
                		break
                	end
 					temp[light_times] = data
 					temp[light_times].reward_list = stringtotable(data.reward)
 					temp[light_times].new_attr_list = stringtotable(data.attr_list)
 					temp[light_times].order = index
 					light_times = light_times + 1
 					Config.Naturebranch[key].order = index
 					-- 累加性格点数
 					self.nature_total_point_data[nature_type] = self.nature_total_point_data[nature_type] + data.need_value
 					self.category_total_point_data[category] = self.category_total_point_data[category] + 1
 					-- 处理顺序表
 					--branch_kv_t[index] = {index = index, key = key}
 					index = index + 1
                end
			end
		end
	end
	--logWarn('=======Msh:NatureModel.lua[51]=======')
	-- PrintTable(self.config_Naturebranch)
	--PrintTable(self.branch_kv_data)
	--PrintTable(self.nature_total_point_data)
end

function NatureModel:InitPointList(  )
	
end

function NatureModel:InitTaskNatureTextRange(  )
	local i = 1
	self.task_range = {}
	while true do
		local kv = self:GetNatureKv( "daily_nature_range" .. i )
		if kv then
			local range = stringtotable(kv.constant)
			self.task_range[i] = {}
			self.task_range[i].min = tonumber(range[1])
			self.task_range[i].max = tonumber(range[2])
			self.task_range[i].des = Trim(kv.remark)
			i = i + 1
		else
			break
		end
	end
end

function NatureModel:GetBranchConifg( category )
	if category then
		return self.config_Naturebranch[category] or logWarn('=======Msh:NatureModel.lua[57]===error category====', category)
	else
		return self.config_Naturebranch
	end
end

function NatureModel:GetNatureKv( key )
	return self.config_Naturekv[key] or logWarn('=======Msh:NatureModel.lua[64]===error key====', key)
end

function NatureModel:GetPointLevelByIndex( index )
	return self.point_lv_list[index]
end
-----------------------------配置相关---end-------------------------

-----------------------------后端数据---start-------------------------
-- 设置拥有的标签列表
function NatureModel:SetHasTagData( data )
	for i,v in pairsByKeys(data) do
		self.has_tag_data[v.nature_type] = v.tips_list
		local sort_func = function ( a, b )
			return a.tip < b.tip
		end
		table.sort(self.has_tag_data[v.nature_type], sort_func)
	end
end

-- 设置展示用的标签列表
function NatureModel:SetShowTagData( data )
	self.show_tag_data = {}
	for i,v in pairs(data) do
		self.show_tag_data[v.show_pos] = v
	end
end

function NatureModel:GetHasTagData(  )
	return self.has_tag_data
end

function NatureModel:GetShowTagData( data )
	return self.show_tag_data
end
-- 性格总览
function NatureModel:SetTotalNatureInfo( data )
	self.total_nature_info = data.nature_list
	self:UpdateNatureLevel(data.level)
	self:UpdateOverflowValue(data.overflow_value)
	--self.now_value = data.now_value -- 当前等级性格点数
	self:SetFreePoint(data.free_value)
end

-- 更新等级 以及 上一次的等级
function NatureModel:UpdateNatureLevel( level )
	self.pre_level = self.total_nature_level
	self.total_nature_level = level
end

-- 更新当前经验以及 上一级的经验
function NatureModel:UpdateOverflowValue( value )
	self.pre_overflow_value = self.overflow_value
	self.overflow_value = value
	self:UpdateRedDot( NatureModel.RedDotTpye.FREE_POINT )
end

function NatureModel:GetCurOverflowValue(  )
	return self.overflow_value or 0
end

function NatureModel:GetPreOverflowValue(  )
	return self.pre_overflow_value
end

function NatureModel:GetCurNatureLevel(  )
	return self.total_nature_level or 0
end

-- 上次的等级
function NatureModel:GetPreLevel(  )
	return self.pre_level or 0
end

function NatureModel:GetCurRecycleValue(  )
	return self.overflow_value or 0
end

-- function NatureModel:GetCurNowValue(  )
-- 	return self.now_value or 0
-- end

-- 成功突破后 数据更新
function NatureModel:SetAfterUpgradeData( data )
	self:UpdateOverflowValue(data.overflow_value)
	self:UpdateNatureLevel(data.level)
end

-- 章节数据
function NatureModel:SetCategoryNatureInfo( data )
	local temp_list = {}

	for i,v1 in ipairs(data.branch_list) do
		temp_list[v1.nature_type] = temp_list[v1.nature_type] or {}
		for j, v2 in ipairs(v1.spot_list) do
			temp_list[v1.nature_type][v2.spot] = v2
			temp_list[v1.nature_type][v2.spot].nature_type = v1.nature_type
		end
	end

	self.nature_category_data[data.category] = temp_list
	self.category_reward_state[data.category] = data.category_reward_status
	self:UpdateTargetNatureIndex(data.category)
end

-- 更新章节奖励领取状态
function NatureModel:UpdateCategoryRewardState( category, state )
	self.category_reward_state[category] = state
end

-- 获取章节奖励状态 1 已经领取  0 未领取(还需要结合章节进度判断可领与否	)
function NatureModel:GetCategoryRewardState( category )
	return self.category_reward_state[category] or 1 --(没收到数据默认已经领取)
end

-- 更改章节数据的某一条
function NatureModel:SetSingleCategoryNatureInfo( category, nature_type, spot, reward_status )
	self.nature_category_data[category][nature_type][spot].reward_status = reward_status
end

-- 获取章节数据
function NatureModel:GetCategoryNatureInfo( category, nature_type, spot )
	if category and nature_type and spot and 
	  self.nature_category_data[category] and 
	  self.nature_category_data[category][nature_type] and 
	  self.nature_category_data[category][nature_type][spot]
	  then
	  	return self.nature_category_data[category][nature_type][spot]
	else
		local empty_data = {
			nature_type = nature_type,
			spot = spot,
			light_times = 0,
			reward_status = 0,
		}
		return empty_data
	end
end

-- 设置经验跑环获得的任务点数(仅作展示用)
function NatureModel:SetTaskNatureValue( scmd )
	self.task_nature_value = scmd.nature_value
	self.task_rand_value = scmd.rand_value
end

function NatureModel:GetTaskNatureValue(  )
	return self.task_nature_value or 0
end

function NatureModel:GetTaskRandValue(  )
	return self.task_rand_value or 0
end

function NatureModel:GetTaskNatureTxtStr(  )
	local nature_value = self:GetTaskNatureValue()
	for i,v in pairsByKeys(self.task_range) do
		if v.min <= nature_value and nature_value <= v.max then
			return v.des
		end
	end
	return ""
end
-----------------------------后端数据---end-------------------------

-- -- 获得上一个数据的值
-- function NatureModel:GetLastOrderData( category, nature_type , order )
-- 	--print('Msh:NatureModel.lua[111] data', category, nature_type , order)
-- 	local kv_data = self.branch_kv_data[category][nature_type][order - 1]
-- 	if not kv_data then return end
-- 	return Config.Naturebranch[kv_data.key]
-- end

-- function NatureModel:GetOrderData( category, nature_type, order )
-- 	local kv_data = self.branch_kv_data[category][nature_type][order]
-- 	if not kv_data then return end
-- 	return Config.Naturebranch[kv_data.key]
-- end

-- 求两个属性列表的差值
function NatureModel:GetChangeAttrList( old_list, new_list )
	local res = {}
	for i,v in ipairs(new_list) do
		for i2,v2 in ipairs(old_list) do
			if v[1] == v2[1] then
				table.insert(res, {v[1], v[2] - v2[2]})
				break
			end
		end
	end
	-- logWarn('=======Msh:NatureModel.lua[128]=======')
	-- PrintTable(res)
	return res
end

-- 设置自由点数
function NatureModel:SetFreePoint( count )
	self.free_value = count
	self:UpdateRedDot( NatureModel.RedDotTpye.FREE_POINT )
end

function NatureModel:GetFreePoint(  )
	local is_finish = self:GetTotalHasUseNaturePoint() >= self:GetTotalNaturePoint()
	-- print('Msh:NatureModel.lua[364] data', self.overflow_value)
	-- print('Msh:NatureModel.lua[364] data', self.free_value)
	if is_finish then -- 如果已经完成 自由点将读取溢出点
		return self.overflow_value or 0
	else
		return self.free_value or 0
	end
end

-- 有自由点数可以用(用于加点分支) 
function NatureModel:HasFreePointCanUse(  )
	-- 总使用情况
	local is_finish = self:GetTotalHasUseNaturePoint() >= self:GetTotalNaturePoint()
	if is_finish then -- 如果已经完成 自由点没用了
		return false
	else
		return self.free_value > 0
	end
end

-- 获取某一分支的总点数
function NatureModel:GetNatureTypeTotalPoint( nature_type )
	return self.nature_total_point_data[nature_type]
end

-- 获取所有分支总点数
function NatureModel:GetTotalNaturePoint(  )
	local res = 0
	for i,v in ipairs(self.nature_total_point_data) do
		res = res + v
	end
	return res
end

-- 获取已经使用性格的总点数
function NatureModel:GetTotalHasUseNaturePoint(  )
	local res = 0
	for i,v in pairs(self.total_nature_info) do
		res = res + v.nature_value
	end
	return res
end

-- 获取已经使用性格的总点数
function NatureModel:GetHasUseNaturePoint( nature_type )
	if not self.total_nature_info[nature_type] then
		return 0
	end
	return self.total_nature_info[nature_type].nature_value
end

-- 获取章节已经加的点数
function NatureModel:GetHasUsePointInCategory( category )
	local res = 0
	if not self.nature_category_data[category] then return 0 end -- 判空
	for nature_type,v1 in pairs(self.nature_category_data[category]) do
		for spot, data in pairs(v1) do
			res = res + data.light_times
		end
	end
	return res
end

-- 获取章节可以加的总点数
function NatureModel:GetCategoryTotalPoint( category )
	return self.category_total_point_data[category]
end

-- 更新记录每个章节每个分支的最新进度
function NatureModel:UpdateAllNatureIndex(  )
	local t = self.cur_nature_index_data
	for category, v1 in pairsByKeys(self.nature_category_data) do
		self:UpdateTargetNatureIndex(category)
	end
end

-- -- 更新某章节的进度
-- function NatureModel:UpdateTargetNatureIndex( category )
-- 	for i=1, CATEGORY_COUNT do
-- 		for j=1, NATURE_TYPE_COUNT do
-- 			if  then
			
-- 			end
-- 		end
-- 	end
-- end

-- 更新某章节的进度 利用遍历顺序表得到当前进度
function NatureModel:UpdateTargetNatureIndex( category )
	local data = self.nature_category_data[category]
	-- logWarn('=======Msh:NatureModel.lua[347]=======')
	-- PrintTable(data)
	self.cur_nature_index_data[category] = self.cur_nature_index_data[category] or {}
	for nature_type, v2 in pairsByKeys(data) do
		self.cur_nature_index_data[category][nature_type] = self.cur_nature_index_data[category][nature_type] or false
		--local d = self.cur_nature_index_data[category][nature_type]
		for spot, v3 in pairsByKeys(v2) do
			local cur_config = self.config_Naturebranch[category][nature_type][spot][v3.light_times]
			self.category_light_times_data[category] = self.category_light_times_data[category] or 0
			self.category_light_times_data[category] = self.category_light_times_data[category] + v3.light_times
			self.cur_nature_index_data[category][nature_type] = cur_config
		end
	end
end

-- 获取性格系统的总加成属性列表
-- 这种是策划 配表 每个章节的每个分支是独立配属性的 3 * 3
function NatureModel:GetTotalAttr(  )
	local arr_list = {}
	-- logWarn('=======Msh:NatureModel.lua[349]=======')
	-- PrintTable(self.cur_nature_index_data)
	-- 先把三个章节共9个分支的属性全部累加
	for category, v1 in pairsByKeys(self.cur_nature_index_data) do
		for nature_type, data in pairsByKeys(v1) do
			if data.attr_list then
				for i, v in pairs(stringtotable(data.attr_list)) do
					arr_list[v[1]] = arr_list[v[1]] or 0
					arr_list[v[1]] = arr_list[v[1]] + v[2]
				end
			end
		end
	end
	-- logWarn('=======Msh:NatureModel.lua[461]=======')
	-- PrintTable(arr_list)
	-- PrintTable(self.cur_nature_index_data)
	-- 再加一波突破的属性
	local lv_cfg = Config.Naturelevel[self:GetCurNatureLevel()]
	for i,v in pairs(stringtotable(lv_cfg.add_attr)) do
		arr_list[v[1]] = arr_list[v[1]] or 0
		arr_list[v[1]] = arr_list[v[1]] + v[2]
	end

	-- 最后处理一下格式
	local res = {}
	for k,v in pairsByKeys(arr_list) do
		table.insert(res, {k, v})
	end
	-- logWarn('=======Msh:NatureModel.lua[474]=======')
	-- PrintTable(res)
	return res
end

-- 这种是策划 配表 每个节点是独立配属性的 3 * 3 * 4 
function NatureModel:GetTotalAttr2(  )
	local arr_list = {}
	-- 以下代码说明：
	-- 1-3层遍历 章节-性格分支-节点 
	-- 4层 遍历要加的属性值
	-- 遍历过程中会判断 self.cur_nature_index_data 是否有该数据，如果没有说明还没解锁，就不往下走了
	-- 主逻辑在第3层  对比是否为最新节点 小于最新取节点最大LV 等于取最新节点LV 大于不管
	local add_arr = function ( arr_data )
		for i,v in pairs(arr_data) do
			arr_list[v[1]] = arr_list[v[1]] or 0
			arr_list[v[1]] = arr_list[v[1]] + v[2]
		end
	end
	for category=1, CATEGORY_COUNT do
		if self.cur_nature_index_data[category] then
			for nature_type=1, NATURE_TYPE_COUNT do
				if self.cur_nature_index_data[category][nature_type] then
					local cur_data = self.cur_nature_index_data[category][nature_type]
					for spot=1, SPOT_COUNT do
						local data
						if cur_data.spot == spot then
							add_arr( cur_data.new_attr_list )
							break
						else
							local max_cfg = self:GetSpotMaxLvCfg( category, nature_type, spot )
							add_arr( max_cfg.new_attr_list )
						end
					end
				end
			end
		end
	end

	local lv_cfg = Config.Naturelevel[self:GetCurNatureLevel()]
	add_arr(stringtotable(lv_cfg.add_attr))

	-- 最后处理一下格式
	local res = {}
	for k,v in pairsByKeys(arr_list) do
		table.insert(res, {k, v})
	end
	-- logWarn('=======Msh:NatureModel.lua[524]=======')
	-- PrintTable(res)
	return res
end

function NatureModel:GetSpotMaxLvCfg( category, nature_type, spot )
	local max_lv = #self.config_Naturebranch[category][nature_type][spot]
	local cfg = self.config_Naturebranch[category][nature_type][spot][max_lv]
	return cfg
end

-- 获取升级消耗的点数 upgrade_level-升几级 cur_light_times-当前的点亮等级
function NatureModel:GetUpgradeCostFreeValue( category, nature_type, spot, cur_light_times, upgrade_level )
	local cfg = self.config_Naturebranch[category][nature_type][spot]
	local cost = 0
	for light_times = cur_light_times + 1, cur_light_times + upgrade_level do
		cost = cost + cfg[light_times].need_value
	end
	return cost
end

--初始化记录点亮进度的index表 
function NatureModel:InitNatureIndexData(  )
	for i=1, CATEGORY_COUNT do
		self.cur_nature_index_data[i] = {}
		for j=1, NATURE_TYPE_COUNT do
			self.cur_nature_index_data[i][j] = {}
		end
	end
end

-- -- 获取某章节的总点亮数
-- function NatureModel:GetCategoryTotalLightTimes( category )
-- 	local total_times = 0
-- 	if category and self.cur_nature_index_data[category] then
-- 		for i,v in ipairs(self.cur_nature_index_data[category]) do
-- 			if v.order then
-- 				total_times = total_times + v.order
-- 			end
-- 		end
-- 	else
-- 		return total_times
-- 	end
-- 	return total_times
-- end

-- 判断章节是否已经解锁
function NatureModel:CategoryIsUnLock( category )
	if category == 1 then -- 默认解锁第一章
		return true
	elseif category == 2 or category == 3 then
		return self:GetHasUsePointInCategory( category - 1 ) >= self:GetNatureKv("unlock").constant or -- 点亮点数大于指定值 
			self:HasMaxNatureType( category - 1 ) -- 或者点满了一个分支
	end
end

-- 检查指定章节是否有满分支的
function NatureModel:HasMaxNatureType( category )
	for i=1, NATURE_TYPE_COUNT do
		if self.cur_nature_index_data and self.cur_nature_index_data[category] and self.cur_nature_index_data[category][i] then
			local data = self.cur_nature_index_data[category][i]
			local cfg = self:GetSpotMaxLvCfg( category, i, SPOT_COUNT )
			if data.spot == SPOT_COUNT and cfg.light_times == data.light_times then
				return true
			end
		end
	end
	return  false
end

-- 检查当前节点是否已经解锁
function NatureModel:SpotIsUnLock( category, nature_type, spot )
	local latest_data
	--print('Msh:NatureModel.lua[470] data', category, nature_type, spot, self.cur_nature_index_data )
	if self.cur_nature_index_data and
	self.cur_nature_index_data[category] and
	self.cur_nature_index_data[category][nature_type] then
		latest_data = self.cur_nature_index_data[category][nature_type]
	end

	 -- 先章节解锁
	if not self:CategoryIsUnLock(category) then
		return false
	end
	-- 节点对比
	if not latest_data then -- 没有点亮过这章节这个分支
		return spot == 1 -- 如果是第一个节点则可以解锁
	else
		if latest_data.spot >= spot  then -- 如果当前节点就是最新节点 或 当前节点在最新节点之前
			return true -- 已解锁

		elseif latest_data.spot < spot and spot - latest_data.spot == 1 then -- 当前节点在最新节点之后一个节点
			local cur_spot_config = self:GetBranchConifg(category)[nature_type][latest_data.spot]
			if latest_data.light_times == #cur_spot_config then -- 当前最新的节点点亮数已达上限
				return true
			else
				return false
			end
		else
			return false
		end
	end
end

-- 获取当前需要展示的标签的字符串列表（包含颜色html标签）
function NatureModel:GetCurShowTagStrList(  )
	local str_list = {}
	for i,v in ipairs(self.show_tag_data) do
		local cfg = Config.Naturetips[v.nature_type .. "@" .. v.tip]
		local str = HtmlColorTxt(Trim(cfg.desc), ColorUtil:GetColor(cfg.color))
		table.insert(str_list, str)
	end
	return str_list
end

-- 将传入的标签数据 转化为代颜色标签的字符串
function NatureModel:TagToTagStrList( tag_data )
	local sort_func = function ( a, b )
		return a.show_pos < b.show_pos
	end
	table.sort(tag_data, sort_func)
	local str_list = {}
	for i,v in ipairs(tag_data) do
		local cfg = Config.Naturetips[v.nature_type .. "@" .. v.tip]
		local str = HtmlColorTxt(Trim(cfg.desc), ColorUtil:GetColor(cfg.color))
		table.insert(str_list, str)
	end
	return str_list
end

-- 整理别人的数据
function NatureModel:DealTagData( tag_data )
	local sort_func = function ( a, b )
		return a.show_pos < b.show_pos
	end
	table.sort(tag_data, sort_func)
	local list = {}
	for i,v in ipairs(tag_data) do
		local cfg = Config.Naturetips[v.nature_type .. "@" .. v.tip]
		local str = Trim(cfg.desc)
		table.insert(list, {str = str, color = cfg.color, nature_type = v.nature_type, tip = v.tip})
	end
	return list
end

-- 获取最新章节的加点最多的分支的最新加点节点
function NatureModel:GetCurLatestSpot(  )
	-- 没任何节点时 选中第一章第一分支第一节点
	-- logWarn('=======Msh:NatureModel.lua[505]=======')
	-- PrintTable(self.cur_nature_index_data)
	local select_category, select_nature_type, select_spot = 1, 1, 1

	-- 检测是否满足解锁新章节 
	for i=2, CATEGORY_COUNT do
		if self:CategoryIsUnLock( i ) then
			select_category = i
		else
			break
		end
	end
	-- 对比记录中的最新数据
	for category,v1 in pairsByKeys(self.cur_nature_index_data) do
		for nature_type, data in pairsByKeys(v1) do
			if category > select_category then
				select_category = category
				select_nature_type = nature_type
				select_spot = data.spot
			elseif category == select_category and select_spot == data.spot then
				select_category = category
				select_nature_type = nature_type
				select_spot = data.spot
			elseif category == select_category and select_spot < data.spot then
				select_category = category
				select_nature_type = nature_type
				select_spot = data.spot
			end
		end
	end
	local config_spot_max_lv = #self:GetBranchConifg(select_category)[select_nature_type][select_spot]
	-- print('Msh:NatureModel.lua[504] data', TableSize(self.cur_nature_index_data), select_category, select_nature_type)
	--PrintTable(self.cur_nature_index_data)
	if self.cur_nature_index_data and
	self.cur_nature_index_data[select_category] and
	self.cur_nature_index_data[select_category][select_nature_type] then
		local cur_spot_lv = self.cur_nature_index_data[select_category][select_nature_type].light_times or 0
		-- PrintTable(self.cur_nature_index_data[select_category][select_nature_type])
		-- print('Msh:NatureModel.lua[505] data', config_spot_max_lv, cur_spot_lv, select_spot)
		if config_spot_max_lv == cur_spot_lv and select_spot ~= 4 then -- 当前节点满 且 不是最后一个节点 切到后一个节点上
			select_spot = select_spot + 1
		end
	end
	--PrintTable(self.cur_nature_index_data)
	--print('Msh:NatureModel.lua[561] data', select_category, select_nature_type, select_spot)
	return select_category, select_nature_type, select_spot
end

-- 红点
function NatureModel:UpdateRedDot( id )
	if id == NatureModel.RedDotTpye.GET_REWRAD then -- 领奖状态刷新
		self:Fire(NatureModel.UPDATE_REWARD_RED_DOT)
	elseif id == NatureModel.RedDotTpye.FREE_POINT then -- 自由点数刷新
		self:Fire(NatureModel.UPDATE_FREE_POINT_RED_DOT)
	elseif id == NatureModel.UPDATE_UPGRADE_RED_DOT then  -- 突破状态刷新
		self:Fire(NatureModel.UPDATE_UPGRADE_RED_DOT)
	else
		self:Fire(NatureModel.UPDATE_FREE_POINT_RED_DOT)
		self:Fire(NatureModel.UPDATE_REWARD_RED_DOT)
		self:Fire(NatureModel.UPDATE_UPGRADE_RED_DOT)
	end
	NewMainRoleModel:getInstance():Fire(NewMainRoleModel.ANS_UPDATE_RED_DOT)
end

function NatureModel:GetNatureAllRed( check_new )
	if check_new then
		self:CheckCategoryRed(  )
		self.red_has_point = self:HasFreePointCanUse()
		self.red_reward_can_get = self:CheckRewawrdCanGet()
		self.red_nature_upgrade = self:CanUpgradeNature()
	end
	--print('Msh:NatureModel.lua[732] data', self.red_has_point ,self.red_reward_can_get , self.red_nature_upgrade )
	-- print('Msh:NatureModel.lua[763] data', self.red_has_point , self.red_reward_can_get, self.red_nature_upgrade)
	return self.red_has_point or self.red_reward_can_get or self.red_nature_upgrade
end

-- 检查整个系统是否有奖励可领取
function NatureModel:CheckRewawrdCanGet(  )
	local has_reward_can_get = false
	-- 普通节点奖励
	for category, v1 in pairs(self.nature_category_data) do
		for nature_type, v2 in pairs(v1) do
			for spot, data in pairs(v2) do
				-- 约定好了 取第一条数据
				local tip = self.config_Naturebranch[category][nature_type][spot][1].tip 
				if data.reward_status == 1 and tip ~= 0 then -- 可领奖 且 该节点是有奖励的节点
					return true
				end
			end
		end
	end
	-- 总的章节奖励
	for category, v in pairs(self.category_reward_state) do
		if self:CanGetCategoryReward( category ) then
			return true
		end
	end
	return false
end

-- 检测章节奖励是否可领
function NatureModel:CanGetCategoryReward( category )
	--print('Msh:NatureModel.lua[630] data', self:GetHasUsePointInCategory(category), self:GetCategoryTotalPoint(category), self:GetCategoryRewardState(category))
	local rate = self:GetHasUsePointInCategory(category) / self:GetCategoryTotalPoint(category)
	return rate >= 1 and self:GetCategoryRewardState(category) == 0
end

--检测是否可以突破
function NatureModel:CanUpgradeNature(  )
	local cur_over_flow = self:GetCurOverflowValue(  )
	local cur_lv = self:GetCurNatureLevel(  )
	local cfg = Config.Naturelevel[cur_lv]
	if not cfg then return false end
	local upgrade_need_over_flow = cfg.cost_value
	return upgrade_need_over_flow <= cur_over_flow
end

-- 获取指定几个章节的红点数据 
function NatureModel:GetCategoryRed( start_index, end_index )
	local bool = false
	for i = start_index, end_index do
		if self.category_red_info[i] then
			bool = true
		end
	end
	return bool
end

-- 检查章节红点(某个章节是否有奖励可领或有节点可以加)
function NatureModel:CheckCategoryRed(  )
	self.category_red_info = {}
	local has_free_point = self:HasFreePointCanUse()
	-- 遍历节点
	for category = 1, CATEGORY_COUNT do
		for nature_type = 1, CATEGORY_COUNT do
			for spot = 1, CATEGORY_COUNT do
				-- 约定好了 取第一条数据
				local cfg = self.config_Naturebranch[category][nature_type][spot] -- 配置
				local data = self:GetCategoryNatureInfo( category, nature_type, spot ) -- 后端数据
				local is_unlock = self:SpotIsUnLock(category, nature_type, spot) -- 节点是否解锁

				-- (可领奖 且 该节点是有奖励的节点) 或 （节点未点满 且 已解锁 且 有点数可用）
				if (data.reward_status == 1 and cfg[1].tip ~= 0) or 
				   (data.light_times < #cfg and is_unlock and has_free_point) then
					self.category_red_info[category] = true
					break
				end
			end
		end
	end

	-- 总的章节奖励
	for category, v in pairs(self.category_reward_state) do
		if self:CanGetCategoryReward( category ) then
			self.category_red_info[category] = true
			break
		end
	end
end

----------升级特效标志-start---------
function NatureModel:SetEffectFlag(  )
	self.need_upgrade_effect = true
end

function NatureModel:InitEffectFlag(  )
	self.need_upgrade_effect = false
end

function NatureModel:IsNeedEffect(  )
	return self.need_upgrade_effect
end
----------升级特效标志-end-----------