"use strict";
cc._RF.push(module, '859a9X1XhRJLaXkg0bNqr0N', 'login.mod');
// Scripts/mod/login/login.mod.js

"use strict";

// --------------------------------------------------------------------
// @author: shiraho@syg.com(必填, 创建模块的人员)
// @description:
//      登录控制器
// <br/>Create: new Date().toISOString()
// --------------------------------------------------------------------

var BridgeController = require("bridge.controller");
var RoleController = require("role_controller");
var FFSDK = require("ff_sdk");
var FFPlugin = require("plugin_help");
var LoginMod = cc.Class({
  "extends": BridgeController,
  // 初始化配置数据
  initConfig: function initConfig() {
    // 本地化缓存
    var cache = nx.storage.getObject("TKAccount");
    nx.bridge.vset("curAccount", cache);
    nx.bridge.login = this;

    // SDK准备
    this.readySDK();
  },
  // 注册监听事件
  registerEvents: function registerEvents() {},
  // 注册协议接受事件
  registerProtocals: function registerProtocals() {
    this.RegisterProtocal(1110, this.on1110);
    this.RegisterProtocal(10310, this.on10310);
    this.RegisterProtocal(10101, this.on10101);
    this.RegisterProtocal(10102, this.on10102);
    this.RegisterProtocal(10103, this.on10103);
  },
  // 账号登录
  reqAccountLogin: function reqAccountLogin(_cb) {
    var info = nx.bridge.vget("curAccount");
    var svr = nx.bridge.vget("curServer");
    var args = [{
      key: "account",
      val: info.account
    }, {
      key: "ip",
      val: nx.frame.vget("Host")
    }, {
      key: "idfa",
      val: nx.frame.vget("IDFA")
    }, {
      key: "language",
      val: nx.frame.vget("LocalLanguage")
    }, {
      key: "device_id",
      val: nx.frame.vget("DeviceID")
    }, {
      key: "device_type",
      val: nx.frame.vget("Platform")
    }, {
      key: "package_name",
      val: nx.frame.vget("ApkName")
    }, {
      key: "package_version",
      val: nx.frame.vget("ApkVersion")
    }, {
      key: "os",
      val: cc.sys.os
    }, {
      key: "os_ver",
      val: cc.sys.osVersion
    }, {
      key: "app_name",
      val: nx.bridge.vget("gname")
    }, {
      key: "channel",
      val: nx.bridge.vget("channel")
    }, {
      key: "platform",
      val: nx.bridge.vget("channelName")
    }, {
      key: "net_type",
      val: nx.frame.vget("NetType")
    }, {
      key: "emulator",
      val: nx.frame.vget("Simulator")
    }, {
      key: "enter_srv_id",
      val: svr.srv_id
    }];

    // 账号登录
    nx.info("$Login:账号登录..");
    this.SendProtocal(1110, {
      args: args
    }, function (_ret, _data, _code) {
      if (!_ret) {
        nx.warn("$Login:账号登录失败:", _data, _code);
        nx.dt.fnInvoke(_cb, false, _data, _code);
        return;
      }

      // 登录成功
      nx.info("$Login:账号登录成功...");
      nx.dt.fnInvoke(_cb, true, _data, _code);
      if (FFSDK.getInstance().isEnableSDK()) {
        FFSDK.getInstance().reportOpenID(info.account);
      }
    });
  },
  // 账号角色列表信息返回
  on1110: function on1110(data) {},
  // 掉线提示， 收到该协议后将不会进行重连
  on10310: function on10310(data) {
    client.socket.close("kicked");
    nx.mbox("lab_login_controller_tip1", ["confirm"], function (_key, _box) {
      _box.close();
      game.enterLogin();
    });
  },
  // 创建新角色返回
  on10101: function on10101(data) {},
  // 角色登录成功返回
  on10102: function on10102(data) {
    if (!this.isGoodData(data)) {
      return;
    }
    nx.bridge.closePanel("WndServerList");
    if (nx.temp_login_wnd) {
      nx.temp_login_wnd.changeSubPanel(3);
    }
    nx.bridge.vset("logInTime", data.timestamp);
    // RoleController.getInstance().getModel().setWorldLev( data.world_lev || 0 );
  },

  // 角色重连成功返回
  on10103: function on10103(data) {
    if (!this.isGoodData(data)) {
      return;
    }

    // nx.tbox( "reconnect success!" )
    // var RoleController = require( "role_controller" )
    // RoleController.getInstance().setReconnect( true )
    // nx.bridge.game.gameReady();
  },

  // 强制下线
  sender10312: function sender10312() {
    this.SendProtocal(10312, {});
  },
  // =======================================================
  // 改造
  // =======================================================

  // 获取服务器列表以及所有角色信息
  fetchServerRoles: function fetchServerRoles(_cb) {
    var _this = this;
    var info = nx.bridge.vget("curAccount");
    nx.bridge.remote.queryServers(info.account, "", true, function (_err, _data) {
      if (_err) {
        cc.error("错误未处理!");
        nx.dt.fnInvoke(_cb, false, "TipFetchServersFailed");
        return;
      }

      // 所有服務器
      var srvs = {};
      var temp = [];
      if (nx.dt.arrNEmpty(_data.data.server_list)) {
        // 排序
        _data.data.server_list.sort(function (_a, _b) {
          return _a.zone_id - _b.zone_id;
        });

        // 统计
        _data.data.server_list.forEach(function (_svr) {
          var data = _this.convertServerInfo(_svr);
          var gid = data.group_id;
          srvs[gid] = srvs[gid] || [];
          srvs[gid].push(data);
          temp.push(data);
        });
      }
      nx.bridge.vset("allServers", srvs);

      // 取最新的5台服务器作为推荐服务器
      temp.sort(function (_a, _b) {
        return _b.stamp - _a.stamp;
      });
      nx.bridge.vset("recServers", temp.slice(0, 5));

      // 所有角色
      var roles = [];
      if (nx.dt.arrNEmpty(_data.data.role_info.role_list)) {
        _data.data.role_info.role_list.forEach(function (_role) {
          roles.push(_role);
        });
      }
      nx.bridge.vset("allRoles", roles);

      // 当前服务器
      var cur = null;
      if (nx.dt.objNEmpty(_data.data.default_zone)) {
        cur = _this.convertServerInfo(_data.data.default_zone);
      }
      nx.bridge.vset("curServer", cur);

      // 默认角色
      var list = cur ? _this.getServerRoles(cur.srv_id) : [];
      nx.bridge.vset("curRole", list[0]);
    });
  },
  // 服务器查询
  queryServer: function queryServer(_sid) {
    var all = nx.bridge.vget("allServers");
    for (var gid in all) {
      var lst = all[gid];
      for (var i in lst) {
        if (lst[i].srv_id == _sid) {
          return lst[i];
        }
      }
    }
    nx.error("$Login:查找服务器失败 ", _sid);
    return null;
  },
  // 统计指定服角色
  getServerRoles: function getServerRoles(_sid) {
    var ret = [];
    var roles = nx.bridge.vget("allRoles");
    roles.forEach(function (tm) {
      if (tm.srv_id == _sid) {
        ret.push(tm);
      }
    });
    return ret;
  },
  // 连接服务器
  linkServer: function linkServer(_svr_id, _cb) {
    // 服务器
    var server = this.queryServer(_svr_id);
    if (!server) {
      nx.dt.fnInvoke(_cb, false, "TipSelectServer");
      return;
    }
    nx.bridge.vset("curServer", server);

    // 连接服务器
    client.socket.connect(server.host, server.port, server.ws, _cb);
  },
  // 自动进入游戏
  autoEnter: function autoEnter(_cb, _relog) {
    if (_relog === void 0) {
      _relog = false;
    }
    var self = this;

    // STEP4:角色进入
    var step4 = function step4(_rid, _sid) {
      var args = {
        rid: _rid,
        srv_id: _sid
      };
      self.SendProtocal(_relog ? 10103 : 10102, args, _cb);
    };

    // STEP3:角色注册
    var step3 = function step3() {
      var args = {
        sex: 0,
        name: "",
        career: 1,
        playform: nx.frame.vget("Platform")
      };
      self.SendProtocal(10101, args, function (_ret, _data, _code) {
        if (!_ret) {
          nx.dt.fnInvoke(false, _data, _code);
          return;
        }
        nx.bridge.vset("curRole", _data);
        step4(_data.rid, _data.srv_id);
      });
    };

    // STEP2:账号登录
    var step2 = function step2() {
      self.reqAccountLogin(function (_ret, _data, _code) {
        if (!_ret) {
          nx.dt.fnInvoke(false, _data, _code);
          return;
        }
        var role = nx.bridge.vget("curRole");
        if (nx.dt.objEmpty(role)) {
          step3();
        } else {
          step4(role.rid, role.srv_id);
        }
      });
    };

    // STEP1:连接服务器
    var server = nx.bridge.vget("curServer");
    if (nx.dt.objEmpty(server)) {
      nx.dt.fnInvoke(_cb, false, "TipSelectServer");
      return;
    }

    // 连接服务器
    client.socket.connect(server.host, server.port, server.ws, function (_ret, _data) {
      // 连接失败
      if (!_ret) {
        nx.dt.fnInvoke(_cb, false, _data);
        return;
      }

      // // 重复连接
      // if( _data == "repeat" ) {
      //     return;
      // }

      // STEP2:账号登录
      step2();
    });
  },
  // 服务器信息数据转换
  convertServerInfo: function convertServerInfo(server) {
    var info = {
      srv_name: server.name || server.srv_name,
      srv_id: server.srv_id || server.platform + "_" + server.zone_id,
      ip: server.ip || server.host,
      host: server.host || server.ip,
      port: server.erl_port,
      ws: server.ws || "ws",
      zone_id: server.zone_id,
      platform: server.platform,
      platform_name: server.platform_name,
      main_srv_id: server.main_srv_id,
      is_close: server.maintain == 1,
      is_try: server.first_zone == 1,
      is_new: Number(server.isnew) == 1,
      is_recomed: server.recomed == 1,
      open_time: server.open_time,
      roles: server.roles || [],
      group_num: server.group_num || 1,
      group_id: server.group_id || 1
    };

    // 时间转换
    var dt = new Date(info.open_time);
    info.stamp = Math.floor(dt.getTime() / 1000);
    return info;
  },
  // =======================================================
  // SDK相关
  // =======================================================

  // SDK准备
  readySDK: function readySDK() {
    if (!FFSDK.getInstance().isEnableSDK()) {
      return;
    }
    var FP = FFPlugin.getInstance();
    FP.regSdkCallBack("login", this.onSDKLoginResult, this);
    FP.regSdkCallBack("logout", this.onSDKLogoutResult, this);
    FP.regSdkCallBack("bindaccount", this.onSDKBindAccountResult, this);
  },
  // SDK登录
  reqSDKLogin: function reqSDKLogin(_cb, _swap) {
    if (_swap === void 0) {
      _swap = false;
    }
    this.cbSDKLogin = _cb;
    if (_swap) {
      FFSDK.getInstance().switchAccount();
    } else {
      FFSDK.getInstance().autoLogin();
    }
  },
  // 登录返回
  onSDKLoginResult: function onSDKLoginResult(_params) {
    if (nx.dt.objEmpty(_params)) {
      nx.error("$Login:SDK\u767B\u5F55\u8FD4\u56DE\u7A7A!");
      return;
    }
    var openId = _params.openId || "";
    nx.dt.fnInvoke(this.cbSDKLogin, true, {
      openId: openId
    });
    var url = nx.bridge.vget("noticeURL");
    nx.web.get(url, {}, function (_err, _data) {
      if (_err) {
        //    nx.tbox( "NoticeFetchFailed" );
        return;
      }
      if (_data && _data.data) {
        nx.bridge.createPanel("WndNotice");
      }
    }, false);
  },
  // SDK登出
  reqSDKLogout: function reqSDKLogout(_cb) {
    this.cbSDKLogout = _cb;
    FFSDK.getInstance().logOut();
  },
  // 登出返回
  onSDKLogoutResult: function onSDKLogoutResult(_params) {
    if (nx.dt.objEmpty(_params)) {
      nx.error("$Login:SDK\u767B\u51FA\u8FD4\u56DE\u7A7A!");
      return;
    }
    var result = _params.result;
    var ret = result && 0 != parseInt(result);
    nx.dt.fnInvoke(this.cbSDKLogout, ret);
  },
  // 账号绑定返回
  onSDKBindAccountResult: function onSDKBindAccountResult(_params) {}

  // sdkLogin: function() {
  //     // LoginPlatform
  //     var protocal = {}
  //     var account = this.model.getLoginData().usrName || "";
  //     var srv_id = this.model.getLoginData().srv_id || "";
  //     var device_id = "nicai"
  //     // var device_id = device.getDeviceName()
  //     var timestamp = LoginPlatform.getInstance().getTimestamp();
  //     var token = LoginPlatform.getInstance().getToken();
  //     var sign = LoginPlatform.getInstance().getSign();
  //     var channel = LoginPlatform.getInstance().getChannel();
  //     account = channel + "_" + account;
  //     var final_channel = LoginPlatform.getInstance().getFinalChannel();
  //     var gettui_cid = "meiyou";
  //     var device_type = "";
  //     // var gettui_cid = device.getuiId()
  //     var idfa = "meiyou";
  //     var is_emulator = "false";
  //     var os_ver = "";
  //     var carrier_name = "";
  //     var net_type = "";
  //     var app_name = nx.bridge.vget( "gname" );
  //     var package_name = nx.bridge.vget( "gname" );
  //     var package_version = "1.0.1";
  //     var os = "os";

  //     var logsign_str = account + device_id + idfa + channel + gettui_cid + is_emulator;
  //     var MD5 = require( "md5.min" );
  //     // cc.log("value_1==>", value);
  //     var logsign = MD5( logsign_str );
  //     logsign = logsign.toLowerCase();

  //     protocal.args = [
  //         { key: "account", val: account },
  //         { key: "timestamp", val: timestamp },
  //         { key: "enter_srv_id", val: srv_id },
  //         { key: "platform", val: PLATFORM_NAME },
  //         { key: "device_id", val: device_id },
  //         { key: "device_type", val: device_type },
  //         { key: "gettui_cid", val: gettui_cid },
  //         { key: "idfa", val: idfa },
  //         { key: "token", val: token },
  //         { key: "channel", val: final_channel },
  //         { key: "sign", val: sign },
  //         { key: "logsign", val: logsign },
  //         { key: "os_ver", os_ver },
  //         { key: "carrier_name", val: carrier_name },
  //         { key: "net_type", val: net_type },
  //         { key: "os", val: os },
  //         { key: "emulator", val: is_emulator },
  //         { key: "app_name", val: app_name },
  //         { key: "package_name", val: package_name },
  //         { key: "package_version", val: package_version }
  //     ];

  //     this.SendProtocal( 1110, protocal );
  // },
});

module.exports = LoginMod;

cc._RF.pop();