"use strict";
cc._RF.push(module, 'dc1262X+ydDR6DUfHs8N8G5', 'elfin_model');
// Scripts/mod/partner/wings/elfin_model.js

"use strict";

var 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 ctor() {},
  initConfig: 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: function setElfinBuyInfo(data) {
    this.elfin_buy_info = data || {};
  },
  // 更新某一個物品今日購買信息
  updateElfinBuyInfoByBid: function updateElfinBuyInfoByBid(bid, count) {
    var is_have = false;
    for (var k in this.elfin_buy_info) {
      var v = this.elfin_buy_info[k];
      if (v.item_bid == bid) {
        is_have = true;
        v.buy_num = count;
        break;
      }
    }
    if (!is_have) {
      var 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: function getElfinBuyCountByBid(bid) {
    var buy_num = 0;
    for (var k in this.elfin_buy_info) {
      var v = this.elfin_buy_info[k];
      if (v.item_bid == bid) {
        buy_num = v.buy_num;
        break;
      }
    }
    return buy_num;
  },
  // 設置已經激活的精靈圖鑒
  setActivatedElfinList: function setActivatedElfinList(data) {
    this.activated_elfin_list = data || {};
  },
  // 根據精靈id判斷是否已經激活
  checkElfinIsActivatedByBid: function checkElfinIsActivatedByBid(bid) {
    var is_activated = false;
    for (var k in this.activated_elfin_list) {
      var v = this.activated_elfin_list[k];
      if (v.item_bid == bid) {
        is_activated = true;
        break;
      }
    }
    return is_activated;
  },
  // 設置靈窩數據
  setElfinHatchList: function setElfinHatchList(data_list) {
    this.elfin_hatch_list = [];
    for (var k in data_list) {
      var data = data_list[k];
      var 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: function updateElfinHatchData(data_list) {
    for (var k in data_list) {
      var data = data_list[k];
      var is_have = false;
      for (var _k in this.elfin_hatch_list) {
        var 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) {
        var _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: function updateOneElfinHatchData(data) {
    for (var k in this.elfin_hatch_list) {
      var 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: function getElfinHatchList() {
    this.elfin_hatch_list.sort(Utils.tableLowerSorter(["id"]));
    return this.elfin_hatch_list;
  },
  // 根據靈窩id獲取數據
  getElfinHatchVoById: function getElfinHatchVoById(id) {
    for (var k in this.elfin_hatch_list) {
      var elfin_hatch_vo = this.elfin_hatch_list[k];
      if (elfin_hatch_vo.id == id) {
        return elfin_hatch_vo;
      }
    }
  },
  // 精靈系統是否開啟
  checkElfinIsOpen: function checkElfinIsOpen(not_tips) {
    var is_open = false;
    var role_vo = RoleController.getInstance().getRoleVo();
    if (game.configs.sprite_data) {
      var 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: function setElfinTreeData(_data) {
    var 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}
     */

    var defaults = this.getDedefaultElfinInfo();
    if (this.elfin_tree_data && Utils.next(this.elfin_tree_data) != null) {
      var key_list = ["atk", "hp_max", "def", "speed"];
      for (var i in key_list) {
        var attr_key = key_list[i];
        var old_val = this.elfin_tree_data[attr_key];
        var 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 = {};
    var sprites = data.sprites || {};
    for (var _i in data.sprites) {
      var 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;
    var level_cfg = game.configs.sprite_data.data_tree_up_lv[data.lev];
    var 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;
        var temp_list = step_cfg.step_cond;
        for (var k in temp_list) {
          var _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: function getElfinTreeData() {
    return this.elfin_tree_data;
  },
  // 獲取古樹的四個精靈bid(只有已經解鎖的精靈，解鎖未放置時bid為0)
  getElfinTreeElfinList: function getElfinTreeElfinList() {
    if (!this.elfin_tree_data) {
      return {};
    }
    return this.elfin_tree_data.sprites || {};
  },
  //根據位置獲取精靈bid 如果 bid ==null 說明未解鎖
  getElfinItemByPos: function getElfinItemByPos(pos) {
    if (this.dic_elfin_item_pos) {
      return this.dic_elfin_item_pos[pos];
    }
    return null;
  },
  freshDefaultScheme: function freshDefaultScheme(_scheme) {
    var scheme = this.getDedefaultElfinInfo();
    if (scheme && !nx.dt.arrEmpty(scheme)) {
      scheme.sort(Utils.tableLowerSorter(["pos"]));
    }
    if (_scheme.team_list.length > 0) {
      var plan_id = _scheme.team_list[0].plan_id;
      if (plan_id == 0) {
        var plan = _scheme.team_list[0].sprites;
        plan.sort(Utils.tableLowerSorter(["pos"]));
        var sprites = this.elfin_tree_data.sprites;
        if (sprites && !nx.dt.arrEmpty(sprites)) {
          sprites.sort(Utils.tableLowerSorter(["pos"]));
          for (var i = 0; i < plan.length; i++) {
            var item = plan[i];
            var sch = scheme[i];
            var sprite = sprites[i];
            if (item.pos == sprite.pos) {
              sprite.item_bid = item.item_bid;
            }
          }
        }
      }
    }
  },
  //獲取一個缺省空的精靈數據 默认方案配置
  getDedefaultElfinInfo: function getDedefaultElfinInfo() {
    this.defaultsprites = [];
    if (this.elfin_tree_data) {
      var sprites = [];
      var eflin_data = this.elfin_tree_data.sprites || {};
      for (var i in eflin_data) {
        var 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: function getElfinTreeByBid(bid) {
    if (this.dic_elfin_item_pos && bid && bid != 0) {
      for (var pos in this.dic_elfin_item_pos) {
        if (this.dic_elfin_item_pos[pos] == bid) {
          return pos;
        }
      }
    }
    return null;
  },
  getElfinTreeAttrChangeData: function getElfinTreeAttrChangeData() {
    return this.tree_attr_change_data;
  },
  // 根據屬性名稱、突破等級計算出下一級的屬性值
  getElfinTreeNextAttrVal: function getElfinTreeNextAttrVal(attr_key, lev, break_lev) {
    var attr_val = 0;
    var attr_base_cfg = game.configs.sprite_data.data_tree_attr[0];
    var step_cfg = game.configs.sprite_data.data_tree_step[break_lev];
    if (!attr_base_cfg || !step_cfg) {
      return attr_val;
    }
    var add_attr_key = "add_" + attr_key; // 成長屬性值
    if (attr_key == "hp_max") {
      add_attr_key = "add_hp";
    }
    var getStepAttrVal = function getStepAttrVal(key) {
      var val = 0;
      for (var k in step_cfg.all_attr) {
        var v = step_cfg.all_attr[k];
        if (v[0] == key) {
          val = v[1] || 0;
        }
      }
      return val;
    };
    var base_val = attr_base_cfg[attr_key] || 0;
    var step_val = getStepAttrVal(attr_key);
    var base_groud_val = attr_base_cfg[add_attr_key] || 0;
    var 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: function 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: function calculateElfinHatchDoneRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var hatch_done_red = false;
    for (var k in this.elfin_hatch_list) {
      var 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: function calculateElfinHatchLvupRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var 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: function setNotCalculateHatchLvupRedFlag() {
    if (this.getElfinRedStatusByRedBid(HeroConst.RedPointType.eElfin_hatch_lvup)) {
      this.not_calculate_hatch_flag = true;
    }
  },
  // 設置打開過精靈孵化界面
  setOpenElfinHatchFlag: function setOpenElfinHatchFlag(flag) {
    this.open_hatch_flag = flag;
  },
  // 計算是否有可孵化的靈窩和蛋
  calculateElfinHatchEggRedStatus: function calculateElfinHatchEggRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    var have_empty_hatch = false;
    for (var k in this.elfin_hatch_list) {
      var 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) {
      var 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: function calculateElfinHatchOpenRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    for (var k in this.elfin_hatch_list) {
      var 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: function calculateTreeUplvRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    if (this.tree_cost_list && Utils.next(this.tree_cost_list) != null) {
      red_status = true;
      for (var k in this.tree_cost_list) {
        var v = this.tree_cost_list[k];
        var bid = v[1];
        var need_num = v[2];
        var 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) {
        var 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: function getElfinTreeCostBidList() {
    var cost_bid_list = {};
    if (this.tree_cost_list && Utils.next(this.tree_cost_list) != null) {
      for (var 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: function calculateTreePutElfinRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
      var is_have_pos = false;
      var have_type_list = {}; // 所有已經放置的精靈的類型
      for (var k in this.elfin_tree_data.sprites) {
        var v = this.elfin_tree_data.sprites[k];
        if (v.item_bid == 0) {
          is_have_pos = true;
        } else {
          var 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) {
        // 有位置未放置精靈，還要判斷背包中是否有可放置的精靈
        var all_elfin_data = BackpackController.getInstance().getModel().getAllBackPackArray(BackPackConst.item_sub_type.ELFIN) || {};
        for (var _k2 in all_elfin_data) {
          var _v2 = all_elfin_data[_k2];
          var _elfin_cfg = client.getDataKeyVal("sprite_data", "data_elfin_data", _v2.base_id); //game.configs.sprite_data.data_elfin_data[v.base_id]
          if (_elfin_cfg) {
            var is_same = false;
            for (var i in have_type_list) {
              var 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: function calculateElfinCompoundRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    this.elfin_com_cost_list = {}; // 記錄一下上陣中的精靈合成所需材料
    if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
      for (var k in this.elfin_tree_data.sprites) {
        var v = this.elfin_tree_data.sprites[k];
        var 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) {
          var temp_status = true;
          for (var i in elfin_com_cfg.expend) {
            var 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) {
              var need_num = info[2];
              var 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: function getElfinCompoundCostBidList() {
    var cost_bid_list = {};
    if (this.elfin_com_cost_list && Utils.next(this.elfin_com_cost_list) != null) {
      for (var 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: function calculateElfinHigherRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    if (this.elfin_tree_data.sprites && Utils.next(this.elfin_tree_data.sprites) != null) {
      var have_type_list = {}; // 所有已經放置的精靈的類型和階數
      for (var k in this.elfin_tree_data.sprites) {
        var v = this.elfin_tree_data.sprites[k];
        var 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) {
          var object = {};
          object.step = elfin_cfg.step;
          object.s_type = elfin_cfg.sprite_type;
          // table.insert(have_type_list, object)
          have_type_list[k] = object;
        }
      }
      var all_elfin_data = BackpackController.getInstance().getModel().getAllBackPackArray(BackPackConst.item_sub_type.ELFIN) || {};
      for (var _k3 in all_elfin_data) {
        var _v3 = all_elfin_data[_k3];
        var _elfin_cfg2 = client.getDataKeyVal("sprite_data", "data_elfin_data", _v3.base_id); //game.configs.sprite_data.data_elfin_data[v.base_id]
        if (_elfin_cfg2) {
          for (var _k4 in have_type_list) {
            var _object = have_type_list[_k4];
            if (_elfin_cfg2.sprite_type == _object.s_type && _elfin_cfg2.step > _object.step) {
              red_status = true;
              break;
            }
          }
        }
        if (red_status == true) {
          break;
        }
      }
    }
    this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_higher_lv, red_status);
  },
  // 計算圖鑒紅點
  calculateElfinActivateRedStatus: function calculateElfinActivateRedStatus(activate_list) {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var 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: function 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: function clearActivateDataByIndex(index) {
    if (this.elfin_activate_red_data) {
      this.elfin_activate_red_data[index] = {};
    }
    this.calculateElfinActivateRedStatus();
  },
  clearActivateRedData: function clearActivateRedData() {
    this.elfin_activate_red_data = {};
    this.updateElfinRedStatus(HeroConst.RedPointType.eElfin_activate, false);
  },
  clearActivateDataByBid: function clearActivateDataByBid(bid) {
    if (this.elfin_activate_red_data) {
      for (var i in this.elfin_activate_red_data) {
        var list = this.elfin_activate_red_data[i];
        var is_have = false;
        for (var k in list) {
          var v = list[k];
          if (v == bid) {
            list[k] = null;
            // table.remove(list, k)
            is_have = true;
            break;
          }
        }
        if (is_have) {
          break;
        }
      }
    }
  },
  // 是否是新激活的精靈
  checkIsNewActivateByBid: function checkIsNewActivateByBid(bid) {
    var is_new = false;
    for (var k in this.elfin_activate_red_data || {}) {
      var list = this.elfin_activate_red_data[k];
      for (var i in list) {
        if (list[i] == bid) {
          is_new = true;
          break;
        }
      }
      if (is_new) {
        break;
      }
    }
    return is_new;
  },
  getElfinRedStatus: function getElfinRedStatus() {
    var red_status = false;
    for (var bid in this.elfin_red_list) {
      if (this.elfin_red_list[bid] == true) {
        red_status = true;
        break;
      }
    }
    return red_status;
  },
  // 獲取精靈紅點狀態
  getElfinRedStatusByRedBid: function getElfinRedStatusByRedBid(bid) {
    return this.elfin_red_list[bid] || false;
  },
  // 計算是否有免費召喚和未許願
  calculateElfinSummonRedStatus: function calculateElfinSummonRedStatus() {
    if (!this.checkElfinIsOpen(true)) {
      return;
    }
    var red_status = false;
    var data = this.getElfinSummonData();
    if (data) {
      var 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) {
        var award_config = game.configs.holiday_sprite_lottery_data.data_award[data.camp_id];
        if (award_config) {
          for (var i in award_config) {
            var _un_enabled = false;
            for (var 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: function setElfinSummonData(data) {
    this.elfin_summon_data = data;
  },
  // 獲取精靈召喚數據
  getElfinSummonData: function getElfinSummonData() {
    return this.elfin_summon_data;
  },
  //精靈方案數據
  setPlanData: function 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}]}]}
     * 
     */
    var defaultScheme = this.getDedefaultElfinInfo();
    var sprites = [];
    for (var 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(function (_sprite) {
      if (_sprite.item_bid > 0) {
        _sprite.item_bid = 0;
      }
    });
    var plan_list = data.plan_list;
    if (plan_list) {
      if (data.plan_list.length == 1) {
        var sdata = plan_list[0];
        var ids = [];
        this.schemes.forEach(function (_sche) {
          ids.push(_sche.id);
        });
        if (nx.dt.arrMember(ids, sdata.id)) {
          for (var _i2 = 0; _i2 < this.schemes.length; _i2++) {
            var sche = this.schemes[_i2];
            if (sche.id == sdata.id) {
              if (nx.dt.arrEmpty(sdata.plan_sprites)) {
                sdata.plan_sprites = sprites;
              }
              this.schemes.splice(_i2, 1);
              this.schemes.push(sdata);
            }
          }
        } else {
          this.schemes.push(sdata);
        }
      } else {
        this.schemes = [];
        for (var _i3 in data.plan_list) {
          var v = data.plan_list[_i3];
          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 (var key in v) {
              this.elfin_plan_data[v.id][key] = v[key];
            }
          }
        }
      }
    }
    this.schemes.sort(Utils.tableLowerSorter(["id"]));
  },
  getPlanCount: function getPlanCount() {
    if (this.elfin_plan_data == null) {
      return 0;
    }
    var count = 0;
    for (var k in this.elfin_plan_data) {
      count = count + 1;
    }
    return count;
  },
  // 获取所有的方案信息
  getAllPlanData: function getAllPlanData() {
    var schemes = [];
    for (var i = 0; i < this.schemes.length; i++) {
      schemes.push(nx.dt.objClone(this.schemes[i]));
    }
    var plan_count = game.configs.sprite_data.data_elfin_plan_length;
    var 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: function 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 saveNowSelect(_args) {
    this.choice = _args;
  },
  // 存储当前的选择方案 方案id pos
  getNowSelect: function getNowSelect(_args) {
    return this.choice;
  },
  // 处理当前选择的方案相关的配置，用于在对应的选择点上显示对应的僚机信息
  setNowSelectScheme: function setNowSelectScheme(_args) {
    // let scheme = {};
    // let defaultScheme = this.getDedefaultElfinInfo();
    // scheme = gcore.dt.deepClone( defaultScheme );
  },
  getFormOn: function getFormOn() {
    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":[]}]**/

cc._RF.pop();