const BridgeClass = require( "bridge.class" );
var ElfinEvent = require("elfin_event")
var ElfinConst = require("elfin_const")
var ElfinHatchVo = require("elfin_hatch_vo")
var HeroConst = require("hero_const")
var BackPackConst = require("backpack_const")
var BackpackController = require("backpack_controller")
var RoleController = require("role_controller")

var ElfinModel = cc.Class({
    extends: BridgeClass,

	ctor: function () {

	},

	initConfig() {
		this.elfin_hatch_list = []  // 孵化器數據
		this.elfin_buy_info = {} 	// 今日購買精靈蛋和砸蛋道具的物品數量
		this.activated_elfin_list = {} // 已激活的精靈id（用於圖鑒）

		this.elfin_red_list = {} // 紅點數據
		this.elfin_tree_data = {} 	// 精靈古樹數據
		this.tree_attr_change_data = {} // 精靈古樹四個屬性值的變化緩存
		if( game.configs.sprite_data ){
			this.hatch_cfg = game.configs.sprite_data.data_hatch_data;
		}
		
		this.schemes = [];
	},

	// 設置今日購買數量信息
	setElfinBuyInfo(data) {
		this.elfin_buy_info = data || {}
	},

	// 更新某一個物品今日購買信息
	updateElfinBuyInfoByBid(bid, count) {
		let is_have = false
		for (let k in this.elfin_buy_info) {
			let v = this.elfin_buy_info[k]
			if (v.item_bid == bid) {
				is_have = true
				v.buy_num = count
				break
			}
		}
		if (!is_have) {
			let info = {}
			info.item_bid = bid
			info.buy_num = count
			this.elfin_buy_info[this.elfin_buy_info.length + 1] = info
			// table.insert(this.elfin_buy_info, info)
		}
	},

	// 根據bid獲取該物品今日購買數量
	getElfinBuyCountByBid(bid) {
		let buy_num = 0
		for (let k in this.elfin_buy_info) {
			let v = this.elfin_buy_info[k]
			if (v.item_bid == bid) {
				buy_num = v.buy_num
				break
			}
		}
		return buy_num
	},

	// 設置已經激活的精靈圖鑒
	setActivatedElfinList(data) {
		this.activated_elfin_list = data || {}
	},

	// 根據精靈id判斷是否已經激活
	checkElfinIsActivatedByBid(bid) {
		let is_activated = false
		for (let k in this.activated_elfin_list) {
			let v = this.activated_elfin_list[k]
			if (v.item_bid == bid) {
				is_activated = true
				break
			}
		}
		return is_activated
	},

	// 設置靈窩數據
	setElfinHatchList(data_list) {
		this.elfin_hatch_list = []
		for (let k in data_list) {
			let data = data_list[k]
			let elfin_hatch_vo = new ElfinHatchVo()
			elfin_hatch_vo.updateData(data)
			if (this.hatch_cfg && this.hatch_cfg[data.id]) {
				elfin_hatch_vo.sort = this.hatch_cfg[data.id].sort
			}
			this.elfin_hatch_list.push(elfin_hatch_vo)
		}

		// 檢測是否有孵化完成的靈窩
		this.calculateElfinHatchDoneRedStatus()
		this.calculateElfinHatchLvupRedStatus()
		this.calculateElfinHatchEggRedStatus()
	},

	// 更新靈窩數據
	updateElfinHatchData(data_list) {
		for (let k in data_list) {
			let data = data_list[k]
			let is_have = false
			for (let k in this.elfin_hatch_list) {
				let elfin_hatch_vo = this.elfin_hatch_list[k]
				if (elfin_hatch_vo.id == data.id) {
					elfin_hatch_vo.updateData(data)
					is_have = true
					break
				}
			}
			if (!is_have) {
				let elfin_hatch_vo = new ElfinHatchVo()
				elfin_hatch_vo.updateData(data)
				if (this.hatch_cfg && this.hatch_cfg[data.id]) {
					elfin_hatch_vo.sort = this.hatch_cfg[data.id].sort
				}
				this.elfin_hatch_list.push(elfin_hatch_vo)
			}
		}

		// 檢測是否有孵化完成的靈窩
		this.calculateElfinHatchDoneRedStatus()
		this.calculateElfinHatchLvupRedStatus()
		this.calculateElfinHatchEggRedStatus()
	},

	// 更新某一個靈窩的數據
	updateOneElfinHatchData(data) {
		for (let k in this.elfin_hatch_list) {
			let elfin_hatch_vo = this.elfin_hatch_list[k]
			if (elfin_hatch_vo.id == data.id) {
				elfin_hatch_vo.updateData(data)
				break
			}
		}
		this.calculateElfinHatchDoneRedStatus()
		this.calculateElfinHatchLvupRedStatus()
		this.calculateElfinHatchEggRedStatus()
	},

	// 獲取所有靈窩數據
	getElfinHatchList() {
		this.elfin_hatch_list.sort(  Utils.tableLowerSorter( [ "id" ] ) );

		return this.elfin_hatch_list;
	},

	// 根據靈窩id獲取數據
	getElfinHatchVoById(id) {
		for (let k in this.elfin_hatch_list) {
			let elfin_hatch_vo = this.elfin_hatch_list[k]
			if (elfin_hatch_vo.id == id) {
				return elfin_hatch_vo
			}
		}
	},

	// 精靈系統是否開啟
	checkElfinIsOpen(not_tips) {
		let is_open = false;
		let role_vo = RoleController.getInstance().getRoleVo();
		if( game.configs.sprite_data ){
			let open_cfg = game.configs.sprite_data.data_const["sprite_unlocked_lv"]
			if (open_cfg && role_vo && open_cfg.val <= role_vo.lev) {
				is_open = true;
			}
	
			if (!is_open && open_cfg && !not_tips) {
				nx.tbox(open_cfg.desc);
			}
		}
		return is_open;
	},

	// 設置精靈古樹數據
	setElfinTreeData(_data) {


		let data = _data.data;
		// 記錄一下{"atk", "hp_max", "def", "speed"}四個屬性值的變化
		this.tree_attr_change_data = {}

		// 记录当前的上阵僚机信息以及在方案中的僚机信息
		// this.formOn = [];
		//console.log( "服务端data " +  JSON.stringify( data ) );
		/*****
		 * {"lev":83,"break_lev":4,"atk":33350,"def_p":0,"def_s":0,
		 * "hp_max":133374,"speed":535,"hit_rate":9999,"dodge_rate":0,"crit_rate":2000,
		 * "crit_ratio":1200,"hit_magic":0,"dodge_magic":0,"def":1070,
		 * "sprites":[{"pos":4,"item_bid":0},{"pos":3,"item_bid":0},{"pos":2,"item_bid":0},{"pos":1,"item_bid":113407}],"power":159817}
		 */

		let defaults = this.getDedefaultElfinInfo();

		if (this.elfin_tree_data && Utils.next(this.elfin_tree_data) != null) {
			let key_list = ["atk", "hp_max", "def", "speed"]
			for (let i in key_list) {
				let attr_key = key_list[i]
				let old_val = this.elfin_tree_data[attr_key]
				let new_val = data[attr_key]
				if (new_val > old_val) {
					this.tree_attr_change_data[attr_key] = new_val - old_val
				}
			}

			// // 階級變化，彈出喚醒成功界面
			// if (this.elfin_tree_data.break_lev < data.break_lev) {
			// 	ElfinController.getInstance().openElfinTreeRouseWindow(true, this.elfin_tree_data, data)
			// }

		}

		this.elfin_tree_data = data || {}
		//記錄一下4咯位置對應
		this.dic_elfin_item_pos = {}
		let sprites = data.sprites || {}
		for (let i in data.sprites) {
			let v = data.sprites[i]
			this.dic_elfin_item_pos[v.pos] = v.item_bid
			if( nx.dt.arrMember( this.schemes, v ) ){
				this.schemes.splice( i, 1 );
				this.schemes.push( v );
			}
			// if( v.item_bid > 0 ){
			// 	this.formOn.push( v.item_bid );
			// }
			
			// "sprites":[{"pos":4,"item_bid":113408},{"pos":3,"item_bid":113407},{"pos":2,"item_bid":113406},{"pos":1,"item_bid":113405}]

		}

		// 記錄一下當前古樹升級、進階消耗的材料，用於監聽材料數量變化顯示紅點
		this.tree_cost_list = {}
		this.tree_step_lev = 0
		let level_cfg = game.configs.sprite_data.data_tree_up_lv[data.lev]
		let step_cfg = game.configs.sprite_data.data_tree_step[data.break_lev]
		if (level_cfg && step_cfg) {
			if (data.lev >= step_cfg.lev_max) { // 進階
				this.tree_cost_list = step_cfg.expend
				let temp_list = step_cfg.step_cond
				for (let k in temp_list) {
					let v = temp_list[k]
					if (v[1] == "role_lev") {
						this.tree_step_lev = v[2]
					}
				}
			} else { // 升級
				this.tree_cost_list = level_cfg.expend
			}
		}
		// this.calculateTreeUplvRedStatus()

		// 是否有可放置的精靈
		this.calculateTreePutElfinRedStatus();

		// 上陣的精靈是否可以合成
		this.calculateElfinCompoundRedStatus()

		// 上陣精靈中是否有同類型更高級的精靈
		this.calculateElfinHigherRedStatus()
		
		
	},

	getElfinTreeData() {
		return this.elfin_tree_data
	},

	// 獲取古樹的四個精靈bid(只有已經解鎖的精靈，解鎖未放置時bid為0)
	getElfinTreeElfinList() {
		if (!this.elfin_tree_data) { return {} }
		return this.elfin_tree_data.sprites || {}
	},

	//根據位置獲取精靈bid 如果 bid ==null 說明未解鎖
	getElfinItemByPos(pos) {
		if (this.dic_elfin_item_pos) {
			return this.dic_elfin_item_pos[pos]
		}
		return null
	},

	freshDefaultScheme : function( _scheme ){
	
		let scheme = this.getDedefaultElfinInfo();
		if( scheme && !nx.dt.arrEmpty( scheme )  ){
			
			scheme.sort( Utils.tableLowerSorter( [ "pos" ] ) );
		}
		if( _scheme.team_list.length > 0 ){
			let plan_id = _scheme.team_list[0].plan_id;
			if( plan_id == 0 ){
				let plan =  _scheme.team_list[0].sprites;
				plan.sort( Utils.tableLowerSorter( [ "pos" ] ) );
				let sprites = this.elfin_tree_data.sprites;
				if( sprites && !nx.dt.arrEmpty( sprites ) ){
					sprites.sort( Utils.tableLowerSorter( [ "pos" ] ) );
					for (let i = 0; i < plan.length; i++) {
						let item = plan[i];
						let sch = scheme[i];
						let sprite = sprites[i];
						if( item.pos == sprite.pos ){
							sprite.item_bid = item.item_bid;
						}
					}
				
				}
			}
		 	
			
		}
		
		
	},

	//獲取一個缺省空的精靈數據 默认方案配置
	getDedefaultElfinInfo() {

		this.defaultsprites = [];
		if (this.elfin_tree_data) {
			let sprites = [];
			let eflin_data = this.elfin_tree_data.sprites || {}
			for (let i in eflin_data) {
				let data = {};
				data.pos = eflin_data[i].pos;
				data.item_bid = eflin_data[i].item_bid || 0; 
				// table.insert(sprites, data)
				sprites.push( data ); 
			}

			sprites.sort( Utils.tableLowerSorter( [ "pos" ] ));
			return sprites
		}
		return [];
	},

	getElfinTreeByBid(bid) {
		if (this.dic_elfin_item_pos && bid && bid != 0) {
			for (let pos in this.dic_elfin_item_pos) {
				if (this.dic_elfin_item_pos[pos] == bid) {
					return pos
				}
			}
		}
		return null
	},

	getElfinTreeAttrChangeData() {
		return this.tree_attr_change_data
	},

	// 根據屬性名稱、突破等級計算出下一級的屬性值
	getElfinTreeNextAttrVal(attr_key, lev, break_lev) {
		let attr_val = 0
		let attr_base_cfg = game.configs.sprite_data.data_tree_attr[0]
		let step_cfg = game.configs.sprite_data.data_tree_step[break_lev]
		if (!attr_base_cfg || !step_cfg) { return attr_val }

		let add_attr_key = "add_" + attr_key // 成長屬性值
		if (attr_key == "hp_max") {
			add_attr_key = "add_hp"
		}

		let getStepAttrVal = function (key) {
			let val = 0
			for (let k in step_cfg.all_attr) {
				let v = step_cfg.all_attr[k]
				if (v[0] == key) {
					val = v[1] || 0
				}
			}
			return val
		}

		let base_val = attr_base_cfg[attr_key] || 0
		let step_val = getStepAttrVal(attr_key)
		let base_groud_val = attr_base_cfg[add_attr_key] || 0
		let step_groud_val = step_cfg[add_attr_key] || 0
		attr_val = base_val + step_val + (lev * base_groud_val * step_groud_val / 1000000)
		return Math.round(attr_val)
	},

	////////////////////////////////////-@ 紅點相關
	updateElfinRedStatus(bidV, statusV) {

		if (!this.checkElfinIsOpen(true)) { return }
		this.elfin_red_list[bidV] = statusV;
		nx.mTip.openTip( "partner.wing.assemble", this.elfin_red_list[ HeroConst.RedPointType.eElfin_empty_pos]   );
		nx.mTip.openTip( "partner.wing.scientific", this.elfin_red_list[ HeroConst.RedPointType.eElfin_hatch_egg ] || 
													this.elfin_red_list[ HeroConst.RedPointType.eElfin_hatch_done] || 
													this.elfin_red_list[ HeroConst.RedPointType.eElfin_hatch_open]  );
		gcore.GlobalEvent.fire(ElfinEvent.Update_Elfin_Red_Event, bidV, statusV);
	},

	// 計算靈窩孵化完成的紅點
	calculateElfinHatchDoneRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let hatch_done_red = false
		for (let k in this.elfin_hatch_list) {
			let hatch_vo = this.elfin_hatch_list[k]
			if (hatch_vo.state == ElfinConst.Hatch_Status.Over) {
				hatch_done_red = true
				break
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_hatch_done, hatch_done_red)
	},

	// 計算靈窩升級的紅點
	calculateElfinHatchLvupRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		// let hatch_vo = this.elfin_hatch_list[1]
		// if ((! this.not_calculate_hatch_flag && hatch_vo && game.configs.sprite_data.data_hatch_lev[hatch_vo.lev+1]){
		// 	let Utils.next_hatch_lev_cfg = game.configs.sprite_data.data_hatch_lev[hatch_vo.lev+1]
		// 	let role_vo = RoleController.getInstance().getRoleVo()
		// 	if (role_vo.vip_lev >= Utils.next_hatch_lev_cfg.limit_vip){
		// 		red_status = true
		// 		for (let i,v in iUtils.next_hatch_lev_cfg.expend) {
		// 	        let bid = v[1]
		// 	        let need_num = v[2]
		// 	        let have_num = BackpackController.getInstance().getModel().getItemNumByBid(bid)
		// 	        if (have_num < need_num){
		// 	        	red_status = false
		// 	        	break
		// 	        }
		// 	    }
		// 	}
		// }
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_hatch_lvup, red_status)
	},

	// 設置不再顯示靈窩升級的紅點標識
	setNotCalculateHatchLvupRedFlag() {
		if (this.getElfinRedStatusByRedBid(HeroConst.RedPointType.eElfin_hatch_lvup)) {
			this.not_calculate_hatch_flag = true
		}
	},

	// 設置打開過精靈孵化界面
	setOpenElfinHatchFlag(flag) {
		this.open_hatch_flag = flag
	},

	// 計算是否有可孵化的靈窩和蛋
	calculateElfinHatchEggRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		let have_empty_hatch = false
		for (let k in this.elfin_hatch_list) {
			let hatch_vo = this.elfin_hatch_list[k]
			if (hatch_vo.is_open == 1 && hatch_vo.state == ElfinConst.Hatch_Status.Open) {
				have_empty_hatch = true
				break
			}
		}
		if (have_empty_hatch) {
			let all_egg_list = BackpackController.getInstance().getModel().getBackPackItemListByType(BackPackConst.item_type.ELFIN_EGG)
			if (all_egg_list.length > 0) {
				red_status = true
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_hatch_egg, red_status)
	},

	// 計算是否有可解鎖的靈窩
	calculateElfinHatchOpenRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		for (let k in this.elfin_hatch_list) {
			let hatch_vo = this.elfin_hatch_list[k]
			if (hatch_vo.is_open == 2 && hatch_vo.state == ElfinConst.Hatch_Status.Open) {
				red_status = true
				break
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_hatch_open, red_status)
	},

	// 計算古樹紅點升級、進階紅點
	calculateTreeUplvRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		if (this.tree_cost_list && Utils.next(this.tree_cost_list) != null) {
			red_status = true
			for (let k in this.tree_cost_list) {
				let v = this.tree_cost_list[k]
				let bid = v[1]
				let need_num = v[2]
				let have_num = BackpackController.getInstance().getModel().getItemNumByBid(bid)
				if (have_num < need_num) {
					red_status = false
					break
				}
			}
			if (red_status == true && this.tree_step_lev && this.tree_step_lev > 0) {
				let role_vo = RoleController.getInstance().getRoleVo()
				if (role_vo && this.tree_step_lev > role_vo.lev) {
					red_status = false
				}
			}

		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_tree_lvup, red_status)
	},

	// 獲取古樹當前升級或進階消耗的物品bid
	getElfinTreeCostBidList() {
		let cost_bid_list = {}
		if (this.tree_cost_list && Utils.next(this.tree_cost_list) != null) {
			for (let k in this.tree_cost_list) {
				// table.insert(cost_bid_list, v[1])
				cost_bid_list[k] = this.tree_cost_list[k][1]
			}
		}
		return cost_bid_list
	},

	// 計算古樹當前是否有可放置精靈的位置的紅點
	calculateTreePutElfinRedStatus() {

		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
			let is_have_pos = false
			let have_type_list = {} // 所有已經放置的精靈的類型
			for (let k in this.elfin_tree_data.sprites) {
				let v = this.elfin_tree_data.sprites[k]
				if (v.item_bid == 0) {
					is_have_pos = true
				} else {
					let elfin_cfg = client.getDataKeyVal("sprite_data","data_elfin_data",v.item_bid) //game.configs.sprite_data.data_elfin_data[v.item_bid]
					if (elfin_cfg && elfin_cfg.sprite_type) {
						// table.insert(have_type_list, elfin_cfg.sprite_type)
						have_type_list[k] = elfin_cfg.sprite_type
					}
				}
			}

			if (is_have_pos == true) {
				// 有位置未放置精靈，還要判斷背包中是否有可放置的精靈
				let all_elfin_data = BackpackController.getInstance().getModel().getAllBackPackArray(BackPackConst.item_sub_type.ELFIN) || {}
				for (let k in all_elfin_data) {
					let v = all_elfin_data[k]
					let elfin_cfg = client.getDataKeyVal("sprite_data","data_elfin_data",v.base_id) //game.configs.sprite_data.data_elfin_data[v.base_id]
					if (elfin_cfg) {
						let is_same = false
						for (let i in have_type_list) {
							let e_type = have_type_list[i]
							if (elfin_cfg.sprite_type == e_type) {
								is_same = true
								break
							}
						}
						// 有非同類型可放置的精靈
						if (!is_same) {
							red_status = true
							break
						}
					}
				}
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_empty_pos, red_status)
	},

	// 計算上陣的精靈是否可合成
	calculateElfinCompoundRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		this.elfin_com_cost_list = {} // 記錄一下上陣中的精靈合成所需材料
		if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
			for (let k in this.elfin_tree_data.sprites) {
				let v = this.elfin_tree_data.sprites[k]
				let elfin_com_cfg = game.configs.sprite_data.data_elfin_com[v.item_bid]
				if (v.item_bid != 0 && elfin_com_cfg && elfin_com_cfg.expend && Utils.next(elfin_com_cfg.expend) != null) {
					let temp_status = true
					for (let i in elfin_com_cfg.expend) {
						let info = elfin_com_cfg.expend[i]
						// table.insert(this.elfin_com_cost_list, info)
						this.elfin_com_cost_list[i] = info
						if (red_status == false) {
							let need_num = info[2]
							let have_num = BackpackController.getInstance().getModel().getItemNumByBid(info[1])
							if (have_num < need_num) {
								temp_status = false
							}
						}
					}
					if (temp_status == true) {
						red_status = true
					}
				}
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_compound, red_status)
	},

	// 獲取上陣的精靈合成消耗的物品bid
	getElfinCompoundCostBidList() {
		let cost_bid_list = {}
		if (this.elfin_com_cost_list && Utils.next(this.elfin_com_cost_list) != null) {
			for (let k in this.elfin_com_cost_list) {
				// table.insert(cost_bid_list, this.elfin_com_cost_list[k][1])
				cost_bid_list[k] = this.elfin_com_cost_list[k][1]
			}
		}
		return cost_bid_list
	},

	// 計算上陣精靈中是否有同類型更高級的精靈
	calculateElfinHigherRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
			let have_type_list = {} // 所有已經放置的精靈的類型和階數
			for (let k in this.elfin_tree_data.sprites) {
				let v = this.elfin_tree_data.sprites[k]
				let elfin_cfg = client.getDataKeyVal("sprite_data","data_elfin_data",v.item_bid) //game.configs.sprite_data.data_elfin_data[v.item_bid]
				if (v.item_bid != 0 && elfin_cfg) {
					let object = {}
					object.step = elfin_cfg.step
					object.s_type = elfin_cfg.sprite_type
					// table.insert(have_type_list, object)
					have_type_list[k] = object
				}
			}
			let all_elfin_data = BackpackController.getInstance().getModel().getAllBackPackArray(BackPackConst.item_sub_type.ELFIN) || {}
			for (let k in all_elfin_data) {
				let v = all_elfin_data[k]
				let elfin_cfg = client.getDataKeyVal("sprite_data","data_elfin_data",v.base_id) //game.configs.sprite_data.data_elfin_data[v.base_id]
				if (elfin_cfg) {
					for (let k in have_type_list) {
						let object = have_type_list[k]
						if (elfin_cfg.sprite_type == object.s_type && elfin_cfg.step > object.step) {
							red_status = true
							break
						}
					}
				}
				if (red_status == true) {
					break
				}
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_higher_lv, red_status)
	},

	// 計算圖鑒紅點
	calculateElfinActivateRedStatus(activate_list) {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		// this.elfin_activate_red_data = this.elfin_activate_red_data || {}

		// for (let _,v in activate_list || {}) {
		// 	let elfin_cfg = game.configs.sprite_data.data_elfin_data(v.item_bid)
		// 	if (elfin_cfg){
		// 		this.elfin_activate_red_data[elfin_cfg.step] = this.elfin_activate_red_data[elfin_cfg.step] || {}
		// 		table.insert(this.elfin_activate_red_data[elfin_cfg.step], v.item_bid)
		// 	}
		// }
		// for (let k,list in this.elfin_activate_red_data) {
		// 	if (#list > 0){
		// 		red_status = true
		// 		break
		// 	}
		// }

		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_activate, red_status)
	},

	checkActivateTabBtnRedStatus(index) {
		if (this.elfin_activate_red_data && this.elfin_activate_red_data[index] && Utils.next(this.elfin_activate_red_data[index]) != null) {
			return true
		}
		return false
	},

	clearActivateDataByIndex(index) {
		if (this.elfin_activate_red_data) {
			this.elfin_activate_red_data[index] = {}
		}
		this.calculateElfinActivateRedStatus()
	},

	clearActivateRedData() {
		this.elfin_activate_red_data = {}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_activate, false)
	},

	clearActivateDataByBid(bid) {
		if (this.elfin_activate_red_data) {
			for (let i in this.elfin_activate_red_data) {
				let list = this.elfin_activate_red_data[i]
				let is_have = false
				for (let k in list) {
					let v = list[k]
					if (v == bid) {
						list[k] = null
						// table.remove(list, k)
						is_have = true
						break
					}
				}
				if (is_have) {
					break
				}
			}
		}
	},

	// 是否是新激活的精靈
	checkIsNewActivateByBid(bid) {
		let is_new = false
		for (let k in this.elfin_activate_red_data || {}) {
			let list = this.elfin_activate_red_data[k]
			for (let i in list) {
				if (list[i] == bid) {
					is_new = true
					break
				}
			}
			if (is_new) {
				break
			}
		}
		return is_new
	},

	getElfinRedStatus() {
		let red_status = false
		for (let bid in this.elfin_red_list) {
			if (this.elfin_red_list[bid] == true) {
				red_status = true
				break
			}
		}
		return red_status
	},

	// 獲取精靈紅點狀態
	getElfinRedStatusByRedBid(bid) {
		return this.elfin_red_list[bid] || false
	},

	// 計算是否有免費召喚和未許願
	calculateElfinSummonRedStatus() {
		if (!this.checkElfinIsOpen(true)) { return }
		let red_status = false
		let data = this.getElfinSummonData()
		if (data) {
			let cur_time = client.socket.getTime()
			if (data.free_time && data.free_time <= cur_time) {
				red_status = true
			}
			if (red_status == false && data.lucky_ids && data.lucky_ids.length <= 0) {
				red_status = true
			}
			if (red_status == false) {
				let award_config = game.configs.holiday_sprite_lottery_data.data_award[data.camp_id]
				if (award_config) {
					for (let i in award_config) {
						let _un_enabled = false
						for (let k in data.do_awards) {
							if (award_config[i].id == data.do_awards[k].award_id) {
								_un_enabled = true
								break
							}
						}

						if (_un_enabled == false && award_config[i].times <= data.times) {
							red_status = true
							break
						}
					}
				}
			}
		}
		this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_summon, red_status)
	},

	// 設置精靈召喚數據
	setElfinSummonData(data) {
		this.elfin_summon_data = data
	},

	// 獲取精靈召喚數據
	getElfinSummonData() {
		return this.elfin_summon_data
	},

	//精靈方案數據
	setPlanData(data) {
		if (!data) { return }
		
		if (this.elfin_plan_data == null) {
			this.elfin_plan_data = {}
		}
		
		/********
		 * [26559]:{"id":4,"name":"Scheme4","plan_sprites":[]}
		 * 	[26556]:{"plan_list":
		 * [{"id":7,"name":"Scheme7","plan_sprites":[]},
		 * {"id":6,"name":"Scheme6","plan_sprites":[]},
		 * {"id":5,"name":"Scheme5","plan_sprites":[]},
		 * {"id":4,"name":"Scheme4","plan_sprites":[]},
		 * {"id":1,"name":"4444","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
		 * {"id":2,"name":"grgrg","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
		 * {"id":3,"name":"Scheme3","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]}]}
		 * [26556]:{"plan_list":[{"id":7,"name":"Scheme7","plan_sprites":[]},
		 * {"id":6,"name":"Scheme6","plan_sprites":[]},
		 * {"id":5,"name":"Scheme5","plan_sprites":[]},
		 * {"id":4,"name":"Scheme4","plan_sprites":[]},
		 * {"id":1,"name":"5555","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
		 * {"id":2,"name":"grgrg","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
		 * {"id":3,"name":"Scheme3","plan_sprites":[{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]}]}
		 * 
		 */
		let defaultScheme = this.getDedefaultElfinInfo();
		let sprites = [];
		for (let i = 0; i < defaultScheme.length; i++) {
			sprites.push( nx.dt.objClone( defaultScheme[i] )  );
			
		}
		//  gcore.dt.deepClone( defaultScheme );
		// "plan_sprites":[{"pos":1,"item_bid":113008},{"pos":2,"item_bid":113007}]}
		sprites.forEach( _sprite => {
			if( _sprite.item_bid > 0 ){
				_sprite.item_bid = 0;
			}
		} )
		


		let plan_list = data.plan_list;
		if( plan_list ){
			if( data.plan_list.length == 1 ){
				let sdata = plan_list[0];
				let ids = [];
				this.schemes.forEach( _sche => {
					ids.push( _sche.id );
				} )
				if( nx.dt.arrMember(  ids, sdata.id )  ){
					for (let i = 0; i < this.schemes.length; i++) {
						let sche = this.schemes[i];
						if( sche.id == sdata.id ){
							if( nx.dt.arrEmpty( sdata.plan_sprites )  ){
								sdata.plan_sprites = sprites;
							}
							this.schemes.splice( i, 1 );
							this.schemes.push( sdata );
						}
						
						
					}
				}else{
					this.schemes.push( sdata );
				}
				
			}else{
				this.schemes = [];
				for (let i in data.plan_list) {
					let v = data.plan_list[i];
					if( nx.dt.arrEmpty( v.plan_sprites )  ){
						v.plan_sprites = sprites;
					}
					this.schemes.push( v );
		
					// if( !nx.dt.arrEmpty( v.plan_sprites ) ){
					// 	for (let j = 0; j < v.plan_sprites.length; j++) {
					// 		let sitem = v.plan_sprites[j];
					// 		if( sitem.item_bid > 0 ){
					// 			this.formOn.push( sitem.item_bid );
					// 		}
							
					// 	}
					// }

					if (this.elfin_plan_data[v.id] == null) {
						this.elfin_plan_data[v.id] = v
					} else {
						for (let key in v) {
							this.elfin_plan_data[v.id][key] = v[key]
						}
					}
				}
			}
		}
		this.schemes.sort( Utils.tableLowerSorter( [ "id" ] )  );
		
	},

	getPlanCount() {
		if (this.elfin_plan_data == null) {
			return 0
		}
		let count = 0
		for (let k in this.elfin_plan_data) {
			count = count + 1
		}
		return count
	},

	
	// 获取所有的方案信息
	getAllPlanData() {

		let schemes = [];
		for (let i = 0; i < this.schemes.length; i++) {
			schemes.push( nx.dt.objClone( this.schemes[i] )  );
		}

		let plan_count = game.configs.sprite_data.data_elfin_plan_length; 
		let schemeAdd = {};
		schemeAdd.id = 9;
		schemeAdd.name = "新增";
		schemeAdd.plan_sprites = [{"pos":5,"item_bid":0}];

		if( schemes.length >= 3 && schemes.length < plan_count ){
			schemes.push( schemeAdd );

			schemes.sort( Utils.tableLowerSorter( [ "id" ] )  );
		}

		return schemes;
	},

	getPlanData() {
		// let data = {}
		// for (let i=1,3 {
		// 	let d = {}
		// 	d.id = i
		// 	d.name = "測試"+i
		// 	d.plan_sprites = this.elfin_tree_data.sprites
		// 	table.insert(data, d)
		// }
		// return data
		return this.elfin_plan_data
	},

	// 存储当前的选择方案 方案id pos
	saveNowSelect: function( _args ){
		this.choice = _args;
	},

	// 存储当前的选择方案 方案id pos
	getNowSelect: function( _args ){
		return this.choice;

	},

	// 处理当前选择的方案相关的配置，用于在对应的选择点上显示对应的僚机信息
	setNowSelectScheme: function( _args ){
		// let scheme = {};
		// let defaultScheme = this.getDedefaultElfinInfo();
		// scheme = gcore.dt.deepClone( defaultScheme );

	},


	getFormOn: function(){

		return this.formOn;

	},


})
// [26559]:{"id":5,"name":"Scheme5","plan_sprites":[]}
/**[{"id":1,"name":"464646","plan_sprites":[{"pos":4,"item_bid":0},{"pos":3,"item_bid":0},{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
 * {"id":2,"name":"测试换名23","plan_sprites":[{"pos":4,"item_bid":0},{"pos":3,"item_bid":0},{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
 * {"id":3,"name":"3333","plan_sprites":[{"pos":4,"item_bid":0},{"pos":3,"item_bid":0},{"pos":2,"item_bid":0},{"pos":1,"item_bid":0}]},
 * {"id":4,"name":"Scheme4","plan_sprites":[]},
 * {"id":5,"name":"Scheme5","plan_sprites":[]}]**/