"use strict";
cc._RF.push(module, 'fed28/jWWZHV7IQYugib1vH', 'guildskill_model');
// Scripts/mod/guild/talent/guildskill_model.js

"use strict";

var _cc$Class;
// --------------------------------------------------------------------
// @author: xxx@syg.com(必填, 创建模块的人员)
// @description:
//      这里填写详细说明,主要填写该模块的功能简要
// <br/>Create: 2019-01-19 17:37:33
// --------------------------------------------------------------------
var BridgeClass = require("bridge.class");
var GuildskillConst = require("guildskill_const");
var GuildskillEvent = require("guildskill_event");
var BackpackController = require("backpack_controller");
var GuildConst = require("guild_const");
var GuildEvent = require("guild_event");
var GuildskillModel = cc.Class((_cc$Class = {
  "extends": BridgeClass,
  ctor: function ctor() {
    this.ctrl = require("guildskill_controller").getInstance();
    this.initConfig();
  },
  properties: {},
  initConfig: function initConfig() {
    this.career_skill_list = {};
    this.skill_wait_upgrade_list = {};
    this.skill_upgrade_cost_list = {};
    this.skill_red_status_list = {};
    this.pvp_skill_red_status_list = {}; // 職業技能紅點狀態

    // --pvp的職業信息
    this.pvp_career_skill_list = null;
    this.had_send_mainui = false;
    this.had_close_mainui = false;
  },
  clearGuildCareerSkill: function clearGuildCareerSkill() {
    this.career_skill_list = {};
    this.skill_wait_upgrade_list = {};
    this.skill_upgrade_cost_list = {};
    this.skill_red_status_list = {};
  },
  initGuildCareerSkill: function initGuildCareerSkill(data) {
    if (data == null || data.group_id == null) return;
    var config = game.configs.guild_skill_data.data_info_group[data.group_id];
    if (config == null) {
      cc.log("公会技能配置数据有问题，技能组id为：", data.group_id);
    } else {
      var object = {};
      object.career = data.career; // 当前职业
      object.group_id = data.group_id; // 当前激活的技能组
      object.group_ids = data.group_ids; // 已经激活的技能组
      object.skill_ids = []; // 当前技能组的技能状态

      for (var i in config) {
        var v = config[i];
        object.skill_ids.push({
          id: v.id,
          index: v.seq,
          status: GuildskillConst.status.un_activity
        });
      }
      for (var i in data.skill_ids) {
        var v = data.skill_ids[i];
        for (var n in object.skill_ids) {
          var item = object.skill_ids[n];
          if (v.skill_id == item.id) {
            item.status = GuildskillConst.status.activity;
            break;
          }
        }
      }

      //对技能顺序做一个排序吧，主要是担心策划配置不是按照正常顺序来
      if (Utils.next(object.skill_ids)) {
        object.skill_ids.sort(function (a, b) {
          return a.index < b.index;
        });
      }
      this.career_skill_list[data.career] = object;
      gcore.GlobalEvent.fire(GuildskillEvent.UpdateGuildSkillEvent, data.career);
    }
  },
  //获取指定职业的技能信息
  getCareerSkillInfo: function getCareerSkillInfo(career) {
    return this.career_skill_list[career];
  },
  //激活指定职业的技能信息
  updateGuildCareerSkill: function updateGuildCareerSkill(career, skill_id) {
    if (career == null || skill_id == null) return;
    var object = this.career_skill_list[career];
    if (object && object.skill_ids) {
      for (var i in object.skill_ids) {
        var item = object.skill_ids[i];
        if (item.id == skill_id) {
          item.status = GuildskillConst.status.activity;
          break;
        }
      }
      //升级之后，这边做一次保存当前待升级的技能id
      var red_skill_id = 0;
      for (var k in object.skill_ids) {
        var v = object.skill_ids[k];
        if (v.status == GuildskillConst.status.un_activity) {
          red_skill_id = v.id;
          break;
        }
      }
      this.updateGuildSkillStatus(career, red_skill_id);
      gcore.GlobalEvent.fire(GuildskillEvent.UpdateSkillStatusEvent, career, skill_id);
    }
  },
  //升级指定职业的技能组，这个时候默认该技能组技能都未激活
  upgradeGuildCareerSkill: function upgradeGuildCareerSkill(career, group_id) {
    if (career == null || group_id == null) return;
    var object = this.career_skill_list[career];
    if (object == null) {
      object = {};
      object.group_ids = [];
      this.career_skill_list[career] = object;
    }
    if (object.group_ids) {
      object.group_ids.push({
        group_id: object.group_id
      });
    }
    object.career = career;
    if (object.group_id != group_id) {
      object.group_id = group_id;
      object.skill_ids = [];
      var config = game.configs.guild_skill_data.data_info_group[group_id];
      if (config == null) {
        cc.log("更新技能组出错，配置数据有问题，技能组id为：", group_id);
        return;
      }
      for (var i in config) {
        var v = config[i];
        object.skill_ids.push({
          id: v.id,
          index: v.seq,
          status: GuildskillConst.status.un_activity
        });
      }
      if (Utils.next(object.skill_ids)) {
        object.skill_ids.sort(function (a, b) {
          return a.index < b.index;
        });
      }
    }

    //升级之后，这边做一次保存当前待升级的技能id
    var skill_id = 0;
    for (var k in object.skill_ids) {
      var v = object.skill_ids[k];
      if (v.status == GuildskillConst.status.un_activity) {
        skill_id = v.id;
        break;
      }
    }
    this.updateGuildSkillStatus(career, skill_id);
    gcore.GlobalEvent.fire(GuildskillEvent.UpdateSkilUpgradeEvent, career, group_id);
  },
  //获取当前技能组上线
  getCareerGroupMax: function getCareerGroupMax(career) {
    career = career;
    if (this.career_group_max == null) this.career_group_max = {};
    if (this.career_group_max[career] == null) {
      var config = gdata("guild_skill_data", "data_career_list", [career]);
      if (config) {
        this.career_group_max[career] = config.length;
      } else {
        this.career_group_max[career] = 0;
      }
    }
    return this.career_group_max[career];
  },
  //公会技能的初始化红点状态
  initGuildSkillStatus: function initGuildSkillStatus(data) {
    if (data && data.outline) {
      this.skill_wait_upgrade_list = {};
      for (var i in data.outline) {
        var v = data.outline[i];
        this.skill_wait_upgrade_list[v.career] = v.skill_id;
      }
    }
    this.checkGuildSkillRedStatus();
  },
  //更新当前技能
  updateGuildSkillStatus: function updateGuildSkillStatus(career, skill_id) {
    if (this.skill_wait_upgrade_list == null) this.skill_wait_upgrade_list = {};
    this.skill_wait_upgrade_list[career] = skill_id;
    this.checkGuildSkillRedStatus();
  },
  //公会技能红点的算法更新
  checkGuildSkillRedStatus: function checkGuildSkillRedStatus() {
    if (this.skill_wait_upgrade_list == null || Utils.next(this.skill_wait_upgrade_list) == null) return;
    // RedMgr.getInstance().addCalHandler(function () {
    //     var role_vo = RoleController.getInstance().getRoleVo();
    //     var backpack_model = BackpackController.getInstance().getModel();
    //     var red_list = {};
    //     for (var k in this.skill_wait_upgrade_list) {
    //         var skill_id = this.skill_wait_upgrade_list[k];
    //         var config = gdata("guild_skill_data", "data_info", [skill_id]);
    //         if (config) {
    //             red_list[k] = true;
    //             if (config.guild_lev > role_vo.guild_lev) {
    //                 red_list[k] = false;
    //             } else {
    //                 for (var i in config.loss || {}) {
    //                     var v = config.loss[i];
    //                     if (v[0] != null && v[1] != null) {
    //                         var bid = v[0];
    //                         var num = v[1];
    //                         var assert = game.configs.item_data.data_assets_id2label[bid];
    //                         if (assert) {
    //                             if (num > role_vo[assert]) {
    //                                 red_list[k] = false;
    //                                 break
    //                             }
    //                         } else {
    //                             var sum = backpack_model.getBackPackItemNumByBid(bid);
    //                             if (num > sum) {
    //                                 red_list[k] = false;
    //                                 break
    //                             }
    //                         }
    //                     }
    //                 }
    //             }
    //         }
    //     }
    //     for (var k in red_list) {
    //         var id = this.getCareerKey(k);
    //         this.updateGuildRedStatus(id, red_list[k]);
    //     }
    // }.bind(this), RedIds.GuildSkill)
  },

  //设置一个唯一id吧, 跟 guildconst.skill_2 ,3 ,4 ,5对应
  getCareerKey: function getCareerKey(career) {
    career = career || GuildskillConst.index.physics;
    // if (career == GuildskillConst.index.magic)
    //     return GuildConst.red_index.skill_2;
    // else if (career == GuildskillConst.index.physics)
    //     return GuildConst.red_index.skill_3
    // else if (career == GuildskillConst.index.defence)
    //     return GuildConst.red_index.skill_4
    // else if (career == GuildskillConst.index.assist)
    //     return GuildConst.red_index.skill_5
    // else
    //     return GuildConst.red_index.skill_3
  },

  //清楚主界面上面的红点
  clearGuildSkillIconRed: function clearGuildSkillIconRed() {
    if (this.had_close_mainui == true) return;
    this.had_close_mainui = true;
    var is_red = false;
    for (var k in this.skill_red_status_list) {
      var v = this.skill_red_status_list[k];
      if (v == true) {
        is_red = true;
        break;
      }
    }
    if (!is_red) {
      for (var _k in self.pvp_skill_red_status_list) {
        var _v = self.pvp_skill_red_status_list[_k];
        if (_v == true) {
          is_red = true;
          break;
        }
      }
    }
    if (is_red == true) {
      var data = [{
        bid: GuildConst.red_index.skill_2,
        status: false
      }, {
        bid: GuildConst.red_index.skill_3,
        status: false
      }, {
        bid: GuildConst.red_index.skill_4,
        status: false
      }, {
        bid: GuildConst.red_index.skill_5,
        status: false
      }, {
        bid: GuildConst.red_index.pvp_skill_2,
        status: false
      }, {
        bid: GuildConst.red_index.pvp_skill_3,
        status: false
      }, {
        bid: GuildConst.red_index.pvp_skill_4,
        status: false
      }, {
        bid: GuildConst.red_index.pvp_skill_5,
        status: false
      }];
    }
  },
  //更新公会技能红点
  updateGuildRedStatus: function updateGuildRedStatus(bid, status) {
    var _status = this.skill_red_status_list[bid];
    if (_status == status) return;
    this.skill_red_status_list[bid] = status;

    //更新场景红点状态,只在登录的时候提示一次
    if (this.had_send_mainui == false) {
      this.had_send_mainui = true;
    }

    //事件用于同步更新公会主ui的红点
    gcore.GlobalEvent.fire(GuildEvent.UpdateGuildRedStatus, bid, status);
  },
  getRedStatus: function getRedStatus(career) {
    var id = this.getCareerKey(career);
    var pvp_id = this.getPvpCareerKey(career);
    return this.skill_red_status_list[id] || this.pvp_skill_red_status_list[pvp_id];
  },
  getRedTotalStatus: function getRedTotalStatus() {
    for (var k in this.skill_red_status_list) {
      var _status = this.skill_red_status_list[k];
      if (_status == true) return true;
    }
    for (var _k2 in this.pvp_skill_red_status_list) {
      var _status2 = this.pvp_skill_red_status_list[_k2];
      if (_status2 == true) {
        return true;
      }
    }
    return false;
  },
  // --获取各职业的公会技能等级
  getCareerSkillLevel: function getCareerSkillLevel(career) {
    if (this.career_skill_list[career]) {
      var skill_ids = this.career_skill_list[career].skill_ids;
      var count = this.career_skill_list[career].group_ids.length * 6;
      for (var i = 0; i < skill_ids.length; ++i) {
        var v = skill_ids[i];
        if (v.status == GuildskillConst.status.activity) {
          count = count + 1;
        }
      }
      return count;
    }
    return -1;
  },
  resetCareerSkillInfo: function resetCareerSkillInfo(career) {
    var self = this;
    // -- body
    var object = self.career_skill_list[career];
    if (object) {
      object.group_id = Math.floor(object.group_id / 1000) * 1000 + 1;
      object.group_ids = {};
      var config = game.configs.guild_skill_data.data_info_group[object.group_id];
      object.skill_ids = [];
      for (var i in config) {
        var v = config[i];
        var data = {};
        data.id = v.id;
        data.index = v.seq;
        data.status = GuildskillConst.status.un_activity;
        object.skill_ids.push(data);
        // table_insert(object.skill_ids, data)
      }

      object.had_skill_up = false;
      gcore.GlobalEvent.fire(GuildskillEvent.ResetGuildSkillEvent, career);
    }
  },
  setPvpFisrtReset: function setPvpFisrtReset(is_first) {
    this.is_pvp_first = is_first;
  },
  getPvpskillInfo: function getPvpskillInfo() {
    return this.pvp_career_skill_list;
  },
  initPvpCareerSkillInfo: function initPvpCareerSkillInfo(data) {
    if (!data) return;
    var self = this;
    self.dic_pvp_power_career = null;
    if (this.pvp_career_skill_list == null) {
      this.pvp_career_skill_list = {};
    }
    for (var i in data) {
      var v = data[i];
      if (v.career) {
        self.pvp_career_skill_list[v.career] = v;
        v.attr_formation.sort(Utils.tableLowerSorter(["id"]));
      }
    }
    this.checkGuildPvpSkillRedStatus();
  },
  getPvpskillInfoByCareer: function getPvpskillInfoByCareer(career) {
    if (this.pvp_career_skill_list) {
      return this.pvp_career_skill_list[career];
    }
  }
}, _cc$Class["getPvpskillInfo"] = function getPvpskillInfo() {
  return this.pvp_career_skill_list;
}, _cc$Class.getPvpPowerByCareerlist = function getPvpPowerByCareerlist(list) {
  var self = this;
  if (self.dic_pvp_power_career == null) {
    self.dic_pvp_power_career = {};
  }
  var total_power = 0;
  for (var i in list) {
    var career = list[i];
    if (self.dic_pvp_power_career[career] == null) {
      var pvp_career_data = self.getPvpskillInfoByCareer(career);
      if (pvp_career_data) {
        var career_power = 0;
        for (var _i in pvp_career_data.attr_formation) {
          var v = pvp_career_data.attr_formation[_i];
          var _key = Utils.getNorKey(v.id, v.lev);
          var config = gdata("guild_skill_data", "data_pvp_attr_info", _key);
          if (config) {
            career_power = career_power + config.power;
          }
        }
        var key = Utils.getNorKey(career, pvp_career_data.skill_lev);
        var pvp_skill_config = gdata("guild_skill_data", "data_pvp_skill_info", key);
        if (pvp_skill_config) {
          career_power = career_power + pvp_skill_config.power;
        }
        self.dic_pvp_power_career[career] = career_power;
      }
    }
    var power = self.dic_pvp_power_career[career] || 0;
    total_power = total_power + power;
  }
  return total_power;
}, _cc$Class.checkGuildPvpSkillRedStatus = function checkGuildPvpSkillRedStatus() {
  // let self  =this;
  // if( self.pvp_career_skill_list ){
  //     for (let k in self.pvp_career_skill_list) {
  //         let pvp_career_skill_data =  self.pvp_career_skill_list[k]
  //         let total_status = false
  //         for (let i in pvp_career_skill_data.attr_formation) {
  //             let v  = pvp_career_skill_data.attr_formation[i];
  //             let key = Utils.getNorKey(v.id, v.lev)
  //             let config = gdata("guild_skill_data","data_pvp_attr_info",key); 
  //             let status = true
  //             if (config && config.loss) {
  //                 for (let i in config.loss) {
  //                     let cost = config.loss[i]
  //                     let bid = cost[0]
  //                     let have_num = BackpackController.getInstance().getModel().getItemNumByBid(bid)
  //                     if (have_num < cost[1]) {
  //                         status = false
  //                     }
  //                 }
  //              } else{
  //                 // --沒有消耗 就木有紅點了
  //                 status = false
  //              }
  //             if (!total_status) {
  //                 total_status = status
  //             }

  //         }
  //         if (!total_status) {
  //             total_status = self.checkGuildPvpOnlySkillRedpoit(pvp_career_skill_data.career, pvp_career_skill_data.skill_lev, pvp_career_skill_data.attr_formation)
  //         }
  //         let id = self.getPvpCareerKey(k)
  //         self.updateGuildPvpRedStatus(id, total_status)
  //     }   
  // }
}, _cc$Class.checkGuildPvpOnlySkillRedpoit = function checkGuildPvpOnlySkillRedpoit(career, skill_lev, attr_formation) {
  // let self = this;
  // if (!career) return;
  // if( skill_lev==null )return;
  // if (!attr_formation) return;

  // let key = Utils.getNorKey(career, skill_lev)
  // let pvp_skill_config = gdata("guild_skill_data","data_pvp_skill_info",key); 
  // if (pvp_skill_config) {
  //     for (let i in attr_formation) {
  //         let v = attr_formation[i];
  //         if (v.lev < pvp_skill_config.need_lev) {
  //             return false
  //         }
  //     }

  //     if (pvp_skill_config.loss && pvp_skill_config.loss.length!=0) {
  //         for (let i in pvp_skill_config.loss) {
  //             let cost = pvp_skill_config.loss[i]
  //             let bid = cost[0]
  //             let have_num = BackpackController.getInstance().getModel().getItemNumByBid(bid)
  //             if (have_num < cost[1]) {
  //                 return false
  //             }
  //         }
  //     }else{
  //         // --沒有消耗 就木有紅點了
  //         return false
  //     }
  //     return true
  // }
  // return false
}, _cc$Class.updateGuildPvpRedStatus = function updateGuildPvpRedStatus(bid, status) {
  var self = this;
  var _status = self.pvp_skill_red_status_list[bid];
  if (_status == status) return;
  self.pvp_skill_red_status_list[bid] = status;

  // -- 更新場景紅點狀態,只在登錄的時候提示一次
  if (self.had_send_mainui == false) {
    self.had_send_mainui = true;
  }

  // -- 事件用於同步更新公會主ui的紅點
  gcore.GlobalEvent.fire(GuildEvent.UpdateGuildRedStatus, bid, status);
}, _cc$Class.getCareerPvpSkillLevel = function getCareerPvpSkillLevel(career) {
  var self = this;
  if (self.pvp_career_skill_list && self.pvp_career_skill_list[career]) {
    var attr_lev = 0;
    var pvp_career_skill_data = self.pvp_career_skill_list[career];
    for (var i in pvp_career_skill_data.attr_formation) {
      var v = pvp_career_skill_data.attr_formation[i];
      attr_lev = attr_lev + v.lev;
    }
    var skill_lev = pvp_career_skill_data.skill_lev || 0;
    return attr_lev, skill_lev;
  }
  return -1;
}, _cc$Class.getPvpCareerKey = function getPvpCareerKey(career2) {
  // let self = this;
  // let career = career2  || GuildskillConst.index.physics
  // if (career == GuildskillConst.index.magic) { 
  //     return GuildConst.red_index.pvp_skill_2
  // }else if (career == GuildskillConst.index.physics) {
  //     return GuildConst.red_index.pvp_skill_3
  // }else if (career == GuildskillConst.index.defence) {
  //     return GuildConst.red_index.pvp_skill_4
  // }else if (career == GuildskillConst.index.assist ){
  //     return GuildConst.red_index.pvp_skill_5
  // }else{
  //     return GuildConst.red_index.pvp_skill_3
  // }
}, _cc$Class.isPvpFisrtReset = function isPvpFisrtReset() {
  return this.is_pvp_first == true;
}, _cc$Class));

cc._RF.pop();