"use strict";
cc._RF.push(module, '845d0UJOXtKK5xH2PgGrp3u', 'bridge.controller');
// Scripts/zbridge/base/bridge.controller.js

"use strict";

/*-----------------------------------------------------+
 * 桥接: 控制器基类
 +-----------------------------------------------------*/

var BridgeController = cc.Class({
  name: "BridgeController",
  statics: {
    instance: null,
    // 实例化单利
    getInstance: function getInstance(_id, _key, _rebuild) {
      if (_rebuild === void 0) {
        _rebuild = false;
      }
      // 强制重建
      if (_rebuild && this.instance) {
        this.instance.onDestroy();
        delete this.instance;
        this.instance = null;
      }
      if (this.instance) {
        return this.instance;
      }
      new this();
      this.instance.init(_id, _key);
      return this.instance;
    }
  },
  // 构造
  ctor: function ctor() {
    if (this.constructor.instance) {
      throw new Error("不能重复实例化一个单例");
    }

    // 桥接:内部使用
    this.__fid = 0;
    this.__fkey = "";
    this.__flock = true;

    // 监听回调
    this.hooks = {};
    this.constructor.instance = this;
  },
  // 销毁
  onDestroy: function onDestroy() {
    // 注销网络协议监听
    for (var id in this.hooks) {
      client.socket.unbindCmd(id, this.__fkey);
    }
    this.hooks = {};
  },
  // 初始化
  init: function init(_id, _key) {
    // 桥接:内部使用
    this.__fid = _id || 0;
    this.__fkey = _key || "";

    // 初始化配置
    this.initConfig();

    // 本地事件监听
    this.registerEvents();

    // 协议监听
    this.registerProtocals();
  },
  // ============================================================
  // 配置&&监听
  // ============================================================

  // 初始化配置数据
  initConfig: function initConfig() {
    // 重载 TODO...
  },
  // 注册监听事件
  registerEvents: function registerEvents() {
    // 重载 TODO...
  },
  // 注册协议接受事件
  registerProtocals: function registerProtocals() {
    // 重载 TODO...
  },
  // ============================================================
  // 初始化/解锁相关
  // ============================================================

  // 设置功能ID
  setFunctionID: function setFunctionID(_id, _key) {
    this.__fid = _id;
    this.__fkey = _key;
  },
  // 设置功能锁
  setFunctionLock: function setFunctionLock(_lock) {
    this.__flock = !!_lock;
  },
  // 从服务器初始化数据
  reqBaseFromServer: function reqBaseFromServer(_cb) {
    // 重载 TODO...
    nx.dt.fnInvoke(_cb, true);
  },
  // 配置队列加载
  loadConfigs: function loadConfigs(_lst, _cb) {
    // 判空
    if (nx.dt.arrEmpty(_lst)) {
      nx.dt.fnInvoke(_cb, true);
      return;
    }

    // 依次加载
    var files = nx.dt.objClone(_lst);
    var next = function next() {
      if (nx.dt.arrEmpty(files)) {
        nx.dt.fnInvoke(_cb, true);
        return;
      }
      var key = files.shift();
      if (game.configs[key]) {
        next();
        return;
      }
      var path = cc.path.join("configs/excels", key);
      nx.res.loadJson(path, function (_err, _data) {
        if (_err) {
          nx.error("$配置加载失败:", path);
        } else {
          game.configs[key] = _data;
        }
        next();
      });
    };
    next();
  },
  // ============================================================
  // 协议相关
  // ============================================================

  // 消息监听
  RegisterProtocal: function RegisterProtocal(cmd, func) {
    // 参数无效
    if (!cmd || typeof func != "function") {
      cc.error("消息监听失败:" + cmd);
      return;
    }

    // 重复
    if (this.hooks[cmd]) {
      cc.error("消息监听重复:" + cmd);
      return;
    }

    // 老方法
    this.hooks[cmd] = {
      fnRegist: func,
      // 老监听回调,通过RegisterProtocal
      fnSend: null // QA监听回调,通过SendProtocal
    };

    // 走新方法
    client.socket.bindCmd(cmd, this.onRecvProtocal.bind(this), this.__fkey);
  },
  // 消息发送
  SendProtocal: function SendProtocal(cmd, data, _cb) {
    // 参数无效
    if (!cmd) {
      cc.error("发送失败，错误的协议号");
      return;
    }

    // QA监听回调
    if (this.hooks[cmd] && typeof _cb == "function") {
      this.hooks[cmd].fnSend = _cb;
    }

    // 发送
    client.socket.send(cmd, data || {});
  },
  // 消息接收
  onRecvProtocal: function onRecvProtocal(_data, _cmd) {
    var hook = this.hooks[_cmd];
    if (!hook) {
      cc.error("接收到未注册消息,什么鬼:", _cmd);
      return;
    }

    // 两种监听回调
    try {
      if (typeof hook.fnRegist == "function") {
        // hook.fnRegist( _data );
        hook.fnRegist.call(this, _data);
      }

      // 单次调用后解除回调
      if (typeof hook.fnSend == "function") {
        // code如果 等于1则为成功,否则为失败
        if (nx.dt.numGood(_data.code)) {
          if (_data.code == 1) {
            hook.fnSend(true, _data);
          } else {
            hook.fnSend(false, _data.msg || "ErrFailed", _data.code);
          }
          hook.fnSend = null;
          return;
        }

        // 如果code不存在
        else if (nx.dt.strEmpty(_data.msg)) {
          hook.fnSend(true, _data);
        } else {
          hook.fnSend(false, _data.msg, _data.code);
        }
        hook.fnSend = null;
      }
    } catch (err) {
      cc.error("消息接收后处理失败:" + _cmd + " msg:" + err.message, err.stack);
      if (err && cc.sys.isNative && window && window.__errorHandler) {
        window.__errorHandler(err.message, "", "", err.stack);
      }
    }
  },
  // 成功的返回
  // 新定义的规则: _data.msg 空/非空 == 成功/失败
  isGoodData: function isGoodData(_data, _tbox) {
    if (_tbox === void 0) {
      _tbox = true;
    }
    var ok = _data && (_data.code == 1 || nx.dt.strEmpty(_data.msg));
    if (!ok && _tbox) {
      nx.tbox(nx.text.getKey(_data.msg));
    }
    return ok;
  }
});
module.exports = BridgeController;

cc._RF.pop();