// --------------------------------------------------------------------
// @author: xxx@syg.com(必填, 创建模块的人员)
// @description:
//      这里填写详细说明,主要填写该模块的功能简要
// <br/>Create: {DATE}
// --------------------------------------------------------------------
var HeroConst = require("hero_const");
var PartnerConst = require("partner_const");
var HeroEvent = require("hero_event");
var PartnerCalculate = require("partner_calculate");
var HeroCalculate = require("hero_calculate");
var HeroController = require("hero_controller")
var BackpackController = require("backpack_controller")
var HeroModel = cc.Class({
	extends: BaseClass,
	ctor: function () {
		this.ctrl = arguments[0];
	},

	properties: {
	},

	initConfig: function () {
		// 伙伴数据列表 (id :英雄唯一标识)
		// 结构 this.hero_list[id] = hero_vo
		this.hero_list = {};
		//  伙伴bid列表的  
		// 结构 this.hero_bid_list[bid] = {hero_vo1,hero_vo2}
		this.hero_bid_list = {};
		// 伙伴数据数组形式存储，便于排序
		this.hero_array = [];

		// 标志第一次初始
		this.is_init = true;

		// 英雄上限
		this.hero_max_count = 0;
		// 英雄已激活上限次数 
		this.buy_num = 0;

		//皮肤数据  结构: self.hero_skin_list[皮肤id] = 皮肤结束时间   (如果时间 == 0 表永久)
		this.hero_skin_list = null;

		// 英雄图书馆信息
		this.dic_pokedex_info = null;
		// 英雄图书馆信息 [bid] = 数据
		this.dic_pokedex_bid = {};

		// 熔炼祭坛的列表
		this.dic_fuse_info = null;

		// 已拥过有英雄id [bid] = 1
		this.dic_had_hero_info = {};

		// 布阵站位信息 this.pos_list[布阵类型][pos] = id
		this.pos_list = {};

		this.expedit_list = null;
		// 阵法类型
		this.use_formation_type = 1;
		// 使用的圣器id
		this.use_hallows_id = 0;

		// 装备红点背包已更新 记录
		this.is_equip_redpoint_bag_update = true;
		// 装备红点英雄已更新 记录
		this.is_equip_redpoint_hero_update = true;

		// 是否延迟红点更新中 例子:this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp] = true
		// 目前只有升级红点用
		this.is_delay_redpoint_update = {};

		// 进阶和升星材料消耗 只能写死 如果策划改了.跟着改吧
		this.upgrade_star_cost_id = 10001;

		// 升星红点背包已更新 记录
		this.is_upgradestar_redpoint_bag_update = true;
		// 升星红点英雄已更新 记录
		this.is_upgradestar_redpoint_hero_update = true;

		// 阵法 红点 (一次性的)
		this.is_redpoint_form = false;
		// 圣器 红点 (一次性的)
		this.is_redpoint_hallows = false;

		// 记录登陆时候角色的等级 判断阵法是否新解锁用
		this.record_login_lev = 0;

		// 符文解锁条件信息
		// var artifact_one        = Config.partner_data.data_partner_const["artifact_one"].val; 
		// var artifact_two        = Config.partner_data.data_partner_const["artifact_two"].val;
		// this.artifact_lock_list = {"1":artifact_one, "2":artifact_two};
		this.artifact_lucky = 0; // 符文祝福值
		this.artifact_lucky_red = false; // 祝福值红点

		// 英雄信息界面 升星页签的参数  6星才限时页签(后面策划要求熔炼祭坛的也加入)
		this.hero_info_upgrade_star_param = 6;

		this.hero_info_upgrade_star_param2 = 10;		
		this.hero_info_upgrade_star_param3 = 11;

		// --英雄信息界面 天赋页签的参数  6星才限时页签
		this.hero_info_talent_skill_param =  Config.partner_skill_data.data_partner_skill_const["skill_slot"].val   
		
		// --天赋技能升星的材料
		this.talent_skill_cost_id = 10450
		// --天赋技能可学习的列表 用于红点 结构 self.dic_hero_talent_skill_learn_redpoint[skill_id] = 1
		this.dic_hero_talent_skill_learn_redpoint  = {}
	
		this.is_need_update_talent_redpoint = true
	},

	setHeroMaxCount: function (max_count) {
		if (typeof max_count == "number") {
			this.hero_max_count = max_count;
		}
	},

	// 获取英雄上上限
	getHeroMaxCount: function () {
		var max_count = this.hero_max_count || 0;
		var have_coutn = this.hero_array.length;
		return { max_count: max_count, have_coutn: have_coutn };
	},

	setHeroBuyNum: function (buy_num) {
		this.buy_num = Number(buy_num);
	},

	getHeroBuyNum: function () {
		return this.buy_num || 0;
	},

	/**
	 * 更新英雄列表
	 * @author zhanghuxing 2019-01-24
	 * @param  {[type]}  not_show_power 不显示战力变化提示
	 */
	updateHeroList: function (hero_list, is_add, not_show_power) {
		if (!hero_list) return;
		for (var hero_i in hero_list) {
			this.updateHeroVo(hero_list[hero_i], not_show_power);
		}

		// 熔炼祭坛的红点 新增需要重新算红点
		if (is_add) {
	        HeroCalculate.getInstance().clearAllStarFuseRedpointRecord();
			gcore.GlobalEvent.fire(HeroEvent.Hero_Data_Add, hero_list);
		}

		this.is_init = false;
	},

	/**
	 * 更新单个英雄信息，如果没有则是新增；
	 */
	updateHeroVo: function (info, not_show_power) {
		if (!info) return;
		info.id = info.partner_id;
		var bid = info.partner_bid || info.bid;
		if (!bid && this.hero_list[info.id])
			bid = this.hero_list[info.id].bid;

		var par_cfg = Config.partner_data.data_partner_base[bid];
		if (!par_cfg) return;

		var is_add = false;
		var hero_vo = this.hero_list[info.id];
		if (!hero_vo) {
			is_add = true;
			var HeroVo = require("hero_vo");
			hero_vo = this.hero_list[info.id] = new HeroVo();

			for (var config_k in par_cfg) {
				if (config_k !== "skills")
					info[config_k] = par_cfg[config_k];
			}

			// 设置角色id
			var RoleController = require("role_controller");
			var role_vo = RoleController.getInstance().getRoleVo();
			if (role_vo) {
				info.rid = role_vo.rid;
				info.srv_id = role_vo.srv_id;
			}
		}

		// 旧数据
		var old_vo = null;
		var open_type = 0
		if (!is_add) {
			// 处理战力提升特效
			if (!not_show_power && hero_vo.power < info.power) {
				GlobalMessageMgr.getInstance().showPowerMove(info.power - hero_vo.power, null, hero_vo.power);
			}

			// 处理升星、进阶
			if (info.star && hero_vo.star < info.star) {                           // 升星
				open_type = 1;
				old_vo = Utils.deepCopy(hero_vo);
				if(hero_vo.star == this.hero_info_talent_skill_param[1] - 1){
					hero_vo.is_open_talent = true;
				}
			} else if (info.break_lev && hero_vo.break_lev < info.break_lev) {     // 进阶
				open_type = 2;
				old_vo = Utils.deepCopy(hero_vo);
			}
		} else {

		}

		// 更新最大星级
		var cur_star = info.star || par_cfg.init_star;
		if (this.dic_had_hero_info[bid]) {
			if (this.dic_had_hero_info[bid] < cur_star)
				this.dic_had_hero_info[bid] = cur_star;
		} else {
			this.dic_had_hero_info[bid] = cur_star;
		}
		hero_vo.updateHeroVo(info);
		if (is_add) {
			this.hero_array.push(hero_vo);
			if(!this.hero_bid_list[hero_vo.bid]){
				this.hero_bid_list[hero_vo.bid] = []
			}
			this.hero_bid_list[hero_vo.bid].push(hero_vo)
		} else {
			if (open_type == 1 && old_vo) {          // 打开升星成功界面
				this.ctrl.openHeroUpgradeStarExhibitionPanel(true, old_vo, hero_vo);
				HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPStar)
			} else if (open_type == 2 && old_vo) {   // 打开进阶成功界面
				this.ctrl.openBreakExhibitionWindow(true, old_vo, hero_vo);
			}
			gcore.GlobalEvent.fire(HeroEvent.Hero_Data_Update, hero_vo);
		}
		HeroCalculate.getInstance().checkHeroRedPointByRedPointType(HeroConst.RedPointType.eRPLevelUp)
		cc.log("updateHeroVo")
	},

	// 获取单个伙伴数据,id
	// @id 是英雄唯一标识id 
	getHeroById: function (partner_id) {
		if (!this.hero_list) return;
		if (!partner_id || typeof partner_id != "number") return;
		return this.hero_list[partner_id] || {}
	},

	// 删除英雄 
	delHeroDataList: function (list) {
		if (!list) return;
		cc.log("delHeroDataList")
		for (var hero_i in list) {
			let v = list[hero_i]
			let temp_bid = this.hero_list[v.partner_id].bid
			delete this.hero_list[list[hero_i].partner_id]
			// --同时从bid英雄列表删除该英雄记录
			let bidlist = this.hero_bid_list[temp_bid]
			if(bidlist){
				for(let i=0;i<bidlist.length;++i){
					let hero_vo = bidlist[i]
					if(hero_vo.partner_id == v.partner_id){
						bidlist.splice(i,1)
					}
				}
			}
		}
		
		this.hero_array = [];
		for (var hero_i in this.hero_list) {
			this.hero_array.push(this.hero_list[hero_i]);
		}

	    // 消除熔炼祭坛的红点 删除也要重新算
	    HeroCalculate.getInstance().clearAllStarFuseRedpointRecord();

	    // 升星红点
	    this.is_upgradestar_redpoint_hero_update = true
	    this.checkUpgradeStarRedPointUpdate()

		gcore.GlobalEvent.fire(HeroEvent.Del_Hero_Event, list);
	},
	// --更新天赋信息
	updateHeroVoTalent(data_list, is_not_check){
		let is_team = false
		var self = this
		for(let i=0;i<data_list.length;++i){
			let v = data_list[i]
			if(self.hero_list[v.partner_id]){
				self.hero_list[v.partner_id].updateSkill(v.dower_skill)
				if(!is_team){
					if(self.hero_list[v.partner_id].isFormDrama()){
						is_team = true
					}
				}
			}
		}
		if(is_team && !is_not_check){
			// --如果有剧情阵容的英雄..需要检查红点
			// --检测红点
			HeroCalculate.getInstance().checkAllHeroRedPoint()    
		}
	},
	getHeroList: function () {
		return this.hero_list || {}
	},

	getAllHeroArray: function () {
		return this.hero_array;
	},

	// 根据阵容获取英雄列表
	getHeroListByCamp: function (camp) {
		if (typeof camp !== "number") return;
		var hero_list = [];

		for (var hero_i in this.hero_array) {
			if (camp === HeroConst.CampType.eNone || camp === this.hero_array[hero_i].camp_type) {
				// hero_list.push(Utils.deepCopy(this.hero_array[hero_i]));
				hero_list.push(this.hero_array[hero_i]);
			}
		}

		var hero_sort = this.getHeroSortFunc();
		return hero_list.sort(hero_sort);
	},

	// 根据阵容获取英雄列表
	getDeepHeroListByCamp: function (camp) {
		if (typeof camp !== "number") return;
		var hero_list = [];

		for (var hero_i in this.hero_array) {
			if (camp === HeroConst.CampType.eNone || camp === this.hero_array[hero_i].camp_type) {
				// hero_list.push(Utils.deepCopy(this.hero_array[hero_i]));
				hero_list.push(this.hero_array[hero_i]);
			}
		}

		var hero_sort = this.getHeroSortFunc();
		return Utils.deepCopy(hero_list.sort(hero_sort));
	},

	getRestHeroListByCamp: function (camp) {
		if (typeof camp !== "number") return;
		var hero_list = [];
		for (var hero_i in this.hero_array) {
			if (camp === HeroConst.CampType.eNone || camp === this.hero_array[hero_i].camp_type) {
				hero_list.push(this.hero_array[hero_i]);
			}
		}

		var rest_hero_list = Utils.deepCopy(hero_list);
		for (var hero_i in rest_hero_list) {
			var hero_vo = rest_hero_list[hero_i];
			if (hero_vo.is_in_form > 0 || hero_vo.is_lock) {
				hero_vo.is_ui_lock = true;
			}
		}

		var hero_sort = function (role_vo1, role_vo2) {
			if ((!role_vo1.is_ui_lock && !role_vo2.is_ui_lock) || (role_vo1.is_ui_lock && role_vo2.is_ui_lock)) {
				if (role_vo1.star === role_vo2.star) {
					if (role_vo1.power == role_vo2.power) {
						if (role_vo1.lev == role_vo2.lev) {
							return role_vo2.sort_order - role_vo1.sort_order;
						} else {
							return role_vo1.lev - role_vo2.lev;
						}
					} else {
						return role_vo1.power - role_vo2.power;
					}
				} else {
					return role_vo1.star - role_vo2.star;
				}
			} else {
				if (role_vo1.is_ui_lock)
					return 1;
				return -1;
			}
		}

		return rest_hero_list.sort(hero_sort);
	},

	setHadHeroInfo: function (list) {
		if (!list) return;
		for (var hero_i in list)
			this.dic_had_hero_info[list[hero_i].partner_id] = list[hero_i].max_star;
	},

	// 初始化图鉴数据
	getHeroPokedexList: function (camp) {
		if (!this.dic_pokedex_info) {
			this.dic_pokedex_info = {};
			for (var camp_i in HeroConst.CampType) {
				if (camp_i !== "eNone")
					this.dic_pokedex_info[HeroConst.CampType[camp_i]] = [];
			}
			var pokedex_cfg = Config.partner_data.data_partner_pokedex;
			if (pokedex_cfg) {
				for (var bid in pokedex_cfg) {
					var par_cfg = Config.partner_data.data_partner_base[bid];
					for (var star_i in pokedex_cfg[bid]) {
						var star = pokedex_cfg[bid][star_i].star;
						var key = bid + "_" + star;
						var info = this.getHeroPokedexByBid(key);
						if (info) {
							this.dic_pokedex_info[info.camp_type].push(info);
						}
					}
				}
			}

			var sort_function = function (dic_pokedex_1, dic_pokedex_2) {
				if (dic_pokedex_1.star === dic_pokedex_2.star) {
					return dic_pokedex_1.bid - dic_pokedex_2.bid;
				} else {
					return dic_pokedex_1.star - dic_pokedex_2.star;
				}
			}
			// 排序
			for (var dic_pokedex_i in this.dic_pokedex_info) {
				this.dic_pokedex_info[dic_pokedex_i].sort(sort_function);
			}
		}

		return this.dic_pokedex_info[camp]
	},

	getHeroPokedexByBid: function (key) {
		if (this.dic_pokedex_bid[key]) return this.dic_pokedex_bid[key];

		var par_show_cfg = gdata("partner_data", "data_partner_show", key);
		if (!par_show_cfg) {
			return null
		}

		var par_base_cfg = Config.partner_data.data_partner_base[par_show_cfg.bid];
		if (par_base_cfg) {
			var break_lev = this.getHeroMaxBreakCountByInitStar(par_show_cfg.star);
			par_show_cfg.hp_max = par_show_cfg.hp                               // 为了计算战力用的 
			par_show_cfg.power = PartnerCalculate.calculatePower(par_show_cfg);
			par_show_cfg.camp_type = par_base_cfg.camp_type;
			par_show_cfg.name = par_base_cfg.name;
			par_show_cfg.init_star = par_base_cfg.init_star;
			par_show_cfg.type = par_base_cfg.type;
			par_show_cfg.break_id = par_base_cfg.break_id;
			par_show_cfg.break_lev = break_lev;
			par_show_cfg.partner_id = par_show_cfg.bid * 10 + par_show_cfg.star;          // 定义一个唯一id	  
			par_show_cfg.is_pokedex = true;  // 是不是图鉴  	
			this.dic_pokedex_bid[key] = par_show_cfg;
			return this.dic_pokedex_bid[key];
		}
		return null
	},

	// 根据初始星级 或者对应英雄最大进阶次数
	getHeroMaxBreakCountByInitStar: function (init_star) {
		if (!this.dic_max_break) {
			var val = Config.partner_data.data_partner_const.advanced_limit.val
			this.dic_max_break = {}
			for (var val_i in val) {
				this.dic_max_break[val[val_i][0]] = val[val_i][1];
			}
		}
		return this.dic_max_break[init_star] || 0
	},

	// 根据品质获取默认头像
	getRandomHeroHeadByQuality: function (quality) {
		if (!this.dic_random_hero_head) {
			var val = Config.partner_data.data_partner_const.random_hero_icon.val;
			this.dic_random_hero_head = {}
			for (var val_i in val) {
				var item_config = gdata("item_data", "data_unit5", val[val_i][1]);
				if (item_config)
					this.dic_random_hero_head[val[val_i][0]] = item_config.icon;
			}
		}

		var quality = quality || 0;
		if (quality > 5)
			quality = 5;
		return this.dic_random_hero_head[quality]
	},

	getHadHeroInfo: function () {
		return this.dic_had_hero_info || {}
	},

	getHadHeroStarBybid: function (bid) {
		if (this.dic_had_hero_info && this.dic_had_hero_info[bid]) {
			return this.dic_had_hero_info[bid]
		}
		return null
	},


	isOpenTanlentByHerovo(hero_vo){
		if(hero_vo[this.hero_info_talent_skill_param[0]]){
			if(hero_vo[this.hero_info_talent_skill_param[0]] >= this.hero_info_talent_skill_param[1]){
				return true
			}
		}
		return false
	},
	/************阵法相关************/
	setFormList: function (data) {
		var form_type = data.type >= 0 ? data.type : PartnerConst.Fun_Form.Drama;
		if (this.pos_list[form_type]) {
		    for (var form_i in this.pos_list[form_type]) {
		        var vo = this.getHeroById(this.pos_list[form_type][form_i].id)
		        if (vo && vo.updateFormPos) {
		            vo.updateFormPos(0, form_type)
		        }
		    }
		}

		this.pos_list[form_type] = {}
		for (var pos_i in data.pos_info) {
			this.pos_list[form_type][data.pos_info[pos_i].pos] = data.pos_info[pos_i];
			var vo = this.getHeroById(data.pos_info[pos_i].id)
			// 容错处理  bugly出现说  updateFormPos 这个是 (a nil value)
			if (vo && vo.updateFormPos)
				vo.updateFormPos(data.pos_info[pos_i].pos, form_type);
		}

		// 剧情阵法逻辑
		if (form_type == PartnerConst.Fun_Form.Drama) {
			this.form_power = data.power || 0;
			// 阵法类型
			this.use_formation_type = data.formation_type;
			// 使用的圣器id
			this.use_hallows_id = data.hallows_id;

			// GlobalEvent:getInstance():Fire(HeroEvent.Form_Drama_Event,data)
			var calculate = HeroCalculate.getInstance();
			RedMgr.getInstance().addCalHandler(calculate.checkAllHeroRedPoint.bind(calculate), RedIds.HeroAll);

			// 检测红点
			// HeroCalculate.getInstance().checkAllHeroRedPoint();
			let list = []
			for(let k in this.pos_list[form_type]){
				let v = this.pos_list[form_type][k]
				list.push({partner_id : v.id})
			}
			// --请求天赋的
			HeroController.getInstance().sender11099(list)
		}
	},

	// 获取最高战力的英雄战力
	getMaxFight: function () {
		if (this.hero_array) {
			this.hero_array.sort(Utils.tableUpperSorter(["power"]));
			var hero_vo = this.hero_array[0];
			if (hero_vo) {
				return hero_vo.power
			}
		}
		return 0
	},
	//通过bid获取等级最高的英雄信息
	getTopLevHeroInfoByBid(bid){
		if (!bid) return ;
		let list = this.hero_bid_list[bid]
		if (list){
			list.sort(Utils.tableUpperSorter(["lev", "power"]))
			return list[0]
		}
		return null
	},
	//雇佣的
	getExpeditHeroData: function () {
		var hero_list = this.getAllHeroArray();
		var list = [];
		for (var i = 0; i < hero_list.length; i++) {
			var tab = {}
			tab.power = hero_list[i].power;
			tab.name = hero_list[i].name;
			tab.bid = hero_list[i].bid;
			tab.index = i;

			tab.rid = hero_list[i].rid;
			tab.srv_id = hero_list[i].srv_id;
			tab.id = hero_list[i].id;
			tab.star = hero_list[i].star;
			tab.lev = hero_list[i].lev;
			tab.use_skin = hero_list[i].use_skin;
			
			list.push(tab);
		}
		list.sort(function (a, b) {
			return b.power < a.power;
		});
		return list
	},

	// 获取自己的队伍阵法站位
	getMyPosList: function () {
		return this.pos_list[PartnerConst.Fun_Form.Drama] || {}
	},

	getHeroSortFunc: function () {
		var hero_sort = function (role_vo1, role_vo2) {
			if (role_vo1.star === role_vo2.star) {
				if (role_vo1.power == role_vo2.power) {
					if (role_vo1.lev == role_vo2.lev) {
						return role_vo1.sort_order - role_vo2.sort_order;
					} else {
						return role_vo2.lev - role_vo1.lev
					}
				} else {
					return role_vo2.power - role_vo1.power
				}
			} else {
				return role_vo2.star - role_vo1.star
			}
		}
		return hero_sort
	},

	isMaxStarHero: function (bid, star) {
		if (!bid || !star) return false;
		var max_star = Config.partner_data.data_partner_max_star[bid];
		if (max_star && star >= max_star) {
			return true
		}
		if (star >= this.hero_info_upgrade_star_param){
			if(star == this.hero_info_upgrade_star_param2){
            	// --10级升11有世界等级要求
				return !this.checkOpenStar11()
			}
		}
		return false;
	},

	getStarFuseList: function (camp_type) {
		camp_type = camp_type || 0;
		var camp_fuse_list = [];
		var fuse_cfg = Config.partner_data.data_partner_fuse_star;
		if (!fuse_cfg) return
		for (var cfg_i in fuse_cfg) {
			var fuse_cfg_item = fuse_cfg[cfg_i];
			var base_config = Config.partner_data.data_partner_base[cfg_i];
			for (var item_i in fuse_cfg_item) {
				var star = fuse_cfg_item[item_i].star;
				var key = cfg_i + "_" + star;
				var star_config = gdata("partner_data", "data_partner_star", key);
				// Config.partner_data.data_partner_star[key];

				if (base_config && (base_config.camp_type == camp_type || camp_type === 0)) {
					if (base_config && star_config && star_config.expend1.length > 0) {
						var fuse_data = {};
						fuse_data.base_config = base_config;
						fuse_data.star_config = star_config;
						fuse_data.camp_type = base_config.camp_type;
						fuse_data.bid = cfg_i;
						fuse_data.star = star;
						camp_fuse_list.push(fuse_data);
					}
				}
			}
		}

		return camp_fuse_list
	},

	// --根据bid 获取一个模拟herovo对象..属性都是1级的
	getMockHeroVoByBid(bid) {
		let base_config = Config.partner_data.data_partner_base[bid]
		let attr_config = Config.partner_data.data_partner_attr[bid]
		if (!base_config || !attr_config) {
			return
		}

		let hero_vo = Utils.deepCopy(base_config)
		hero_vo.star = base_config.init_star //--默认星数
		hero_vo.break_lev = 0 //--默认进阶
		for (let k in attr_config) { // k,v in pairs(attr_config) do
			let v = attr_config[k]
			if (!hero_vo[k]) {
				hero_vo[k] = v
			}
		}
		hero_vo.hp = attr_config.hp_max //--血量等于最大血量
		hero_vo.power = PartnerCalculate.calculatePower(hero_vo)
		return hero_vo
	},
	/****************装备相关******************/
	updateHeroEquipList: function (data) {
		var partner_id = data.partner_id;
		if (partner_id && this.hero_list[partner_id]) {
			var hero_vo = this.hero_list[partner_id];
			if (hero_vo.power < data.power)
				GlobalMessageMgr.getInstance().showPowerMove(data.power - hero_vo.power, null, hero_vo.power);
			// 判断战力变化
			this.hero_list[partner_id].updateHeroVo(data);
		}
	},

	getHeroEquipList: function (parener_id) {
		if (this.hero_list[parener_id]) {
			return this.hero_list[parener_id].eqm_list;
		}
	},


	//----------------------------符文锻造相关------------------------


	//获取符文祝福红点状态
	getArtifactLuckyRedStatus: function () {
		return this.artifact_lucky_red
	},

	//符文祝福值
	setArtifactLucky: function (value) {
		this.artifact_lucky = value;
		RedMgr.getInstance().addCalHandler(this.updateArtifactLuckyRed.bind(this))
	},

	getArtifactLucky: function () {
		return this.artifact_lucky || 0
	},

	//祝福值红点
	updateArtifactLuckyRed: function () {
		var max_lucky = 0;
		var lucky_cfg = Config.partner_artifact_data.data_artifact_const["change_condition"];
		if (lucky_cfg && lucky_cfg.val != null) {
			max_lucky = lucky_cfg.val;
		}
		if (this.artifact_lucky >= max_lucky) {
			this.artifact_lucky_red = true;
		} else {
			this.artifact_lucky_red = false;
		}
		gcore.GlobalEvent.fire(HeroEvent.Artifact_Lucky_Red_Event);
		var SceneConst = require("scene_const");
		require("mainscene_controller").getInstance().setBuildRedStatus(SceneConst.CenterSceneBuild.mall, this.artifact_lucky_red)
	},

	updatePartnerArtifactList: function (data) {
		var id = data.partner_id || 0;
		if (this.hero_list[id]) {
			var hero_vo = this.hero_list[id];
			if (hero_vo) {
				if (hero_vo.power < data.power) {
					GlobalMessageMgr.getInstance().showPowerMove(data.power-hero_vo.power ,null,hero_vo.power)
				}
				this.hero_list[id].updateHeroVo(data);
				gcore.GlobalEvent.fire(HeroEvent.Artifact_Update_Event, hero_vo);
		        // let is_artifact =  PartnerCalculate.getIsCanClothArtifact(hero_vo.bid);				
				// hero_vo.updateRedPoint(PartnerConst.Vo_Red_Type.Artifact,false)
			}
		}
	},

	getPartnerArtifactList: function (id) {
		if (this.hero_list[id]) {
			return this.hero_list[id].artifact_list || []
		}
		return []
	},

	//---------------------------符文锻造相关end-------------------------

	setLockByPartnerid: function (partner_id, is_lock) {
		if (this.hero_list[partner_id]) {
			this.hero_list[partner_id].is_lock = is_lock || 0;
		}
	},

	// 活动英雄列表 根据匹配信息 熔炼祭坛用
	// @dic_the_conditions 指定匹配 dic_the_conditions[bid][star] = 数量
	// @dic_random_conditions 随机阵容匹配 dic_the_conditions[camp][star] = 数量
	// @dic_hero_id 标志已用
	// return
	// @ count 拥有不重复英雄总数量
	getHeroListByMatchInfo: function (dic_the_conditions, dic_random_conditions, dic_hero_id) {
		// 找不重复的数量
		var count = 0;
		var dic_hero_id = dic_hero_id || {};
		var dic_count = {};

		var _setDicCount = function (partner_id, str, max) {
			// 判断是否重复
			if (!dic_hero_id[partner_id]) {
				if (!dic_count[str])
					dic_count[str] = 0;
				if (dic_count[str] < max) {
					dic_count[str] = dic_count[str] + 1;
					count = count + 1;
					dic_hero_id[partner_id] = 1;
				}
			}
		}

		for (var hero_i in this.hero_list) {
			var hero = this.hero_list[hero_i];
			if (dic_the_conditions && dic_the_conditions[hero.bid] && dic_the_conditions[hero.bid][hero.star]) {
				var str = cc.js.formatStr("%s%s", hero.bid, hero.star);
				_setDicCount(hero.partner_id, str, dic_the_conditions[hero.bid][hero.star]);
			}

			if (dic_random_conditions) {
				// 0表示所有阵营的合适
				if (dic_random_conditions[0] && dic_random_conditions[0][hero.star]) {
					// if (dic_random_conditions[0][hero.star]) {
						var str = cc.js.formatStr("_%s%s", 0, hero.star)
						_setDicCount(hero.partner_id, str, dic_random_conditions[0][hero.star]);
					// }
				} else {
					if (dic_random_conditions[hero.camp_type] && dic_random_conditions[hero.camp_type][hero.star]) {
						var str = cc.js.formatStr("_%s%s", hero.camp_type, hero.star);
						_setDicCount(hero.partner_id, str, dic_random_conditions[hero.camp_type][hero.star]);
					}
				}
			}
		}

		return count
	},

	/***********************************红点检查********************************/



	// 检测升级红点更新
	checkLevelRedPointUpdate: function() {
	    // GlobalEvent:getInstance():Fire(HeroEvent.Level_RedPoint_Event) 

	    // if (this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp])
	    //     return

	    // this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp] = true;
	    // 清除升级红点记录
	    HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPLevelUp, true)
	},

	// 检查阵法解锁 
	checkUnlockFormRedPoint: function() {

	},

	// 设置更新equip红点的记录
	setEquipUpdateRecord: function (bool) {
		this.is_equip_redpoint_bag_update = bool;
		this.is_equip_redpoint_hero_update = bool;
	},

	// 检查装备红点 
	checkEquipRedPointUpdate: function() {
	    // 需要 背包 返回 和 英雄更新返回 才处理红点计算
	    if (this.is_equip_redpoint_bag_update && this.is_equip_redpoint_hero_update) {
	        //清除装备红点记录
	        HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPEquip);
	        gcore.GlobalEvent.fire(HeroEvent.Equip_RedPoint_Event);
	    }
	},

	// 设置更新升星红点的记录
	setUpgradeStarUpdateRecord: function(bool) {
	    this.is_upgradestar_redpoint_bag_update = bool;
	    this.is_upgradestar_redpoint_hero_update = bool;
	},

	// 升星红点检查
	checkUpgradeStarRedPointUpdate: function() {
		// 需要 背包 返回 和 英雄更新返回 才处理红点计算
		if (this.is_upgradestar_redpoint_bag_update && this.is_upgradestar_redpoint_hero_update) {
	        HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPStar);
		} 
	},

	// 检查圣器解锁
	checkUnlockHallowsRedPoint: function() {

	},

	checkOpenStar11: function() {
		let config = Config.partner_data.data_partner_const.staropen11_world_lev
		if(config){
			if(config.val[0] == "world_lev"){
				var RoleController = require("role_controller");
				let world_lev = RoleController.getInstance().getModel().getWorldLev() || 0
				if(world_lev < config.val[1]){
					return false
				}
			}
		}
	
		return true
	},
	//---------------------天赋技能---------------------------
	// --设置更新天赋红点
	setUpdateTalentRedpoint(){
    	this.is_need_update_talent_redpoint = true
	},
	getTalentRedpointRecord(){
		var self = this
		if(self.is_need_update_talent_redpoint){
			let dic_config = Config.partner_skill_data.data_partner_skill_learn
			if(dic_config){
				let is_enough
				for(let k in dic_config){
					let config = dic_config[k]
					self.dic_hero_talent_skill_learn_redpoint[config.id] = null
					is_enough = true
					for(let i=0;i<config.expend.length;++i){
						let v = config.expend[i]
						let count = BackpackController.getInstance().getModel().getItemNumByBid(v[0])
						if(count < v[1]){
							is_enough = false
							break
						}
					}
					if(is_enough){
						self.dic_hero_talent_skill_learn_redpoint[config.id] = config.id
					}
				}
			}
		}
		self.is_need_update_talent_redpoint = false
		if(!Utils.next(self.dic_hero_talent_skill_learn_redpoint)){
			self.dic_hero_talent_skill_learn_redpoint = {}
		}
		return self.dic_hero_talent_skill_learn_redpoint
	},
	// --检测天赋红点更新
	checkTalentRedPointUpdate(){ 
		if(this.is_delay_redpoint_update[HeroConst.RedPointType.eRPTalent]){
			return
		}
		this.is_delay_redpoint_update[HeroConst.RedPointType.eRPTalent] = true
		// --清除天赋红点记录
		HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPTalent, true)
		
	},
	// --增加详细信息
	updateHeroVoDetailedInfo(info){
		if(!info)return
		if(this.hero_list[info.partner_id]){
			cc.log(this.hero_list[info.partner_id],info)
			for(let k in info){
				let v = info[k]
				this.hero_list[info.partner_id][k] = v
			}
			this.hero_list[info.partner_id].is_had_detailed = true
			gcore.GlobalEvent.fire(HeroEvent.Hero_Vo_Detailed_info, this.hero_list[info.partner_id])
		}
	},


	//初始化皮肤 信息英雄皮肤 
	initHeroSkin:function(data){
		if(!data) return
		//判定是否要显示卡片展示界面
		if(this.hero_skin_list){
			let show_skin_id = null;
			for(let i in data.partner_skins){
				let v = data.partner_skins[i];
				if(this.hero_skin_list[v.id] == null){
					show_skin_id = v.id;
					break
				}
			}
			if(show_skin_id){
				//显示
				let skin_config = Config.partner_skin_data.data_skin_info[show_skin_id];
				if(skin_config){
					let setting = {};
					setting.partner_bid = skin_config.bid;
					setting.is_chips = 1;
					setting.init_star = 5;
					setting.status = 1;
					setting.show_type = require("partnersummon_const").Gain_Show_Type.Skin_show;
					setting.skin_id = show_skin_id;
					require("partnersummon_controller").getInstance().openSummonGainShowWindow(true, [setting],null, 2)
				}
			}
		}

		this.hero_skin_list = {};

		for(let i in data.partner_skins){
			let v = data.partner_skins[i];
			this.hero_skin_list[v.id] = v.end_time;
		}

		gcore.GlobalEvent.fire(HeroEvent.Hero_Skin_Info_Event, data);
	},

	//根据皮肤id 返回皮肤数据  
	//@return 皮肤有效时间点..  如果永久返回 0 如果返回nil 表示 没有解锁该皮肤
	getHeroSkinInfoBySkinID:function(skin_id){
		if(this.hero_skin_list && this.hero_skin_list[skin_id] != null){
			return this.hero_skin_list[skin_id]
		}
	},

	//--是否解锁该皮肤
	//is_check_time:判断是否过期
	isUnlockHeroSkin:function(skin_id, is_check_time){
		if(this.hero_skin_list && this.hero_skin_list[skin_id] != null){
			if(is_check_time){
				if(this.hero_skin_list[skin_id] > 0){
					return false
				}
			}
			return true
		}
		return false
	},

});