Các thành phần của thư viện Ezyfox-server-flutter-client (The components of the Ezyfox-server-flutter-client library)

class EzyClient {
  late bool enableSSL;
  late bool enableDebug;
  late EzyConfig config;
  late String name;
  late EzyZone? zone;
  late EzyUser? me;
  late EzySetup setup;
  late EzyHandlerManager handlerManager;
  late Uint8List? privateKey;
  late int sessionId;
  late String? sessionToken;
  late Uint8List? sessionKey;

  EzyClient(this.config) {
    EzyProxy.run("init", config.toMap());
    name = config.getClientName();
    enableSSL = config.enableSSL;
    enableDebug = config.enableDebug;
    handlerManager = EzyHandlerManager.create(this);
    setup = EzySetup(handlerManager);
  }

  void connect(String host, int port) {
    privateKey = null;
    sessionKey = null;
    var params = Map();
    params["clientName"] = name;
    params["host"] = host;
    params["port"] = port;
    EzyProxy.run("connect", params);
  }

  Future reconnect() {
    privateKey = null;
    sessionKey = null;
    var params = Map();
    params["clientName"] = name;
    return EzyProxy.run("reconnect", params);
  }

  void disconnect([int reason = EzyDisconnectReason.CLOSE]) {
    var params = Map();
    params["clientName"] = name;
    params["reason"] = reason;
    EzyProxy.run("disconnect", params);
  }

  void close() {
    disconnect();
  }

  void send(String cmd, dynamic data, [bool encrypted = false]) {
    var shouldEncrypted = encrypted;
    if (encrypted && sessionKey == null) {
      if (enableDebug) {
        shouldEncrypted = false;
      } else {
        EzyLogger.error(
          "can not send command: $cmd, you must enable SSL "
          "or enable debug mode by configuration when you create the client",
        );
        return;
      }
    }
    var params = Map();
    params["clientName"] = name;
    var requestParams = Map();
    requestParams["command"] = cmd;
    requestParams["data"] = data;
    requestParams["encrypted"] = shouldEncrypted;
    params["request"] = requestParams;
    EzyProxy.run("send", params);
  }

  void startPingSchedule() {
    var params = Map();
    params["clientName"] = name;
    EzyProxy.run("startPingSchedule", params);
  }

  void setStatus(String status) {
    var params = Map();
    params["clientName"] = name;
    params["status"] = status;
    EzyProxy.run("setStatus", params);
  }

  void setSessionKey(Uint8List sessionKey) {
    this.sessionKey = sessionKey;
    var params = Map();
    params["clientName"] = name;
    params["sessionKey"] = sessionKey;
    EzyProxy.run("setSessionKey", params);
  }

  EzyApp? getApp() {
    if (zone != null) {
      var appManager = zone!.appManager;
      var app = appManager.getApp();
      return app;
    }
    return null;
  }

  EzyApp? getAppById(int appId) {
    if (zone != null) {
      var appManager = zone!.appManager;
      var app = appManager.getAppById(appId);
      return app;
    }
    return null;
  }

  void handleEvent(String eventType, Map data) {
    var eventHandlers = handlerManager.eventHandlers;
    eventHandlers.handle(eventType, data);
  }

  void handleData(String command, List data) {
    var dataHandlers = handlerManager.dataHandlers;
    dataHandlers.handle(command, data);
  }
}

class EzyClients {
  late String defaultClientName;
  late Map<String, EzyClient> clients;
  static final EzyClients _INSTANCE = EzyClients._();

  EzyClients._() {
    defaultClientName = "";
    clients = <String, EzyClient>{};
  }

  static EzyClients getInstance() {
    return _INSTANCE;
  }

  EzyClient newClient(EzyConfig config) {
    var client = EzyClient(config);
    addClient(client);
    if (defaultClientName == "") {
      defaultClientName = client.name;
    }
    return client;
  }

  EzyClient newDefaultClient(EzyConfig config) {
    var client = newClient(config);
    defaultClientName = client.name;
    return client;
  }

  void addClient(EzyClient client) {
    clients[client.name] = client;
  }

  EzyClient getClient(String clientName) {
    var client = clients[clientName]!;
    return client;
  }

  EzyClient getDefaultClient() {
    return clients[defaultClientName]!;
  }
}

class EzyKeyPairProxy {
  late String publicKey;
  late Uint8List privateKey;

  EzyKeyPairProxy(this.publicKey, this.privateKey);
}

class EzyRSAProxy {
  static final EzyRSAProxy _INSTANCE = EzyRSAProxy._();

  EzyRSAProxy._();

  static EzyRSAProxy getInstance() {
    return _INSTANCE;
  }

  void _onKeyPairGenerated(Map result, Function(EzyKeyPairProxy) callback) {
    callback(EzyKeyPairProxy(result["publicKey"], result["privateKey"]));
  }

  void generateKeyPair(Function(EzyKeyPairProxy) callback) {
    EzyProxy.run("generateKeyPair", {})
        .then((result) => {_onKeyPairGenerated(result, callback)});
  }

  void decrypt(
      Uint8List message, Uint8List privateKey, Function(Uint8List) callback) {
    Map<String, Uint8List> params = {
      "message": message,
      "privateKey": privateKey
    };
    EzyProxy.run("rsaDecrypt", params).then((result) => {callback(result)});
  }
}

class EzyConfig {
  late String zoneName = "";
  late String clientName;
  late bool enableSSL = false;
  late bool enableDebug = false;
  late EzyPingConfig ping = EzyPingConfig();
  late EzyReconnectConfig reconnect = EzyReconnectConfig();

  String getClientName() {
    if (clientName == null) return zoneName;
    return clientName;
  }

  Map toMap() {
    Map map = {};
    map["clientName"] = getClientName();
    map["zoneName"] = zoneName;
    map["enableSSL"] = enableSSL;
    map["enableDebug"] = enableDebug;
    map["ping"] = ping.toMap();
    map["reconnect"] = reconnect.toMap();
    return map;
  }
}

class EzyPingConfig {
  late int pingPeriod = 3000;
  late int maxLostPingCount = 5;

  Map toMap() {
    Map map = {};
    map["pingPeriod"] = pingPeriod;
    map["maxLostPingCount"] = maxLostPingCount;
    return map;
  }
}

class EzyReconnectConfig {
  late bool enable = true;
  late int maxReconnectCount = 5;
  late int reconnectPeriod = 3000;

  Map toMap() {
    Map map = {};
    map["enable"] = enable;
    map["maxReconnectCount"] = maxReconnectCount;
    map["reconnectPeriod"] = reconnectPeriod;
    return map;
  }
}

class EzyCommand {
  EzyCommand._();

  static const ERROR = "ERROR";
  static const HANDSHAKE = "HANDSHAKE";
  static const PING = "PING";
  static const PONG = "PONG";
  static const LOGIN = "LOGIN";
  static const LOGIN_ERROR = "LOGIN_ERROR";
  static const LOGOUT = "LOGOUT";
  static const APP_ACCESS = "APP_ACCESS";
  static const APP_REQUEST = "APP_REQUEST";
  static const APP_EXIT = "APP_EXIT";
  static const APP_ACCESS_ERROR = "APP_ACCESS_ERROR";
  static const APP_REQUEST_ERROR = "APP_REQUEST_ERROR";
  static const PLUGIN_INFO = "PLUGIN_INFO";
  static const PLUGIN_REQUEST = "PLUGIN_REQUEST";
}

class EzyEventType {
  EzyEventType._();

  static const CONNECTION_SUCCESS = "CONNECTION_SUCCESS";
  static const CONNECTION_FAILURE = "CONNECTION_FAILURE";
  static const DISCONNECTION = "DISCONNECTION";
  static const LOST_PING = "LOST_PING";
  static const TRY_CONNECT = "TRY_CONNECT";
}

class EzyConnectionStatus {
  EzyConnectionStatus._();

  static const NULL = "NULL";
  static const CONNECTING = "CONNECTING";
  static const CONNECTED = "CONNECTED";
  static const DISCONNECTED = "DISCONNECTED";
  static const FAILURE = "FAILURE";
  static const RECONNECTING = "RECONNECTING";
}

class EzyDisconnectReason {
  EzyDisconnectReason._();

  static const CLOSE = -1;
  static const UNKNOWN = 0;
  static const IDLE = 1;
  static const NOT_LOGGED_IN = 2;
  static const ANOTHER_SESSION_LOGIN = 3;
  static const ADMIN_BAN = 4;
  static const ADMIN_KICK = 5;
  static const MAX_REQUEST_PER_SECOND = 6;
  static const MAX_REQUEST_SIZE = 7;
  static const SERVER_ERROR = 8;
  static const SERVER_NOT_RESPONDING = 400;
  static const UNAUTHORIZED = 401;
}

class EzyDisconnectReasons {
  static const _REASON_NAMES = {
    EzyDisconnectReason.CLOSE: "CLOSE",
    EzyDisconnectReason.UNKNOWN: "UNKNOWN",
    EzyDisconnectReason.IDLE: "IDLE",
    EzyDisconnectReason.NOT_LOGGED_IN: "NOT_LOGGED_IN",
    EzyDisconnectReason.ANOTHER_SESSION_LOGIN: "ANOTHER_SESSION_LOGIN",
    EzyDisconnectReason.ADMIN_BAN: "ADMIN_BAN",
    EzyDisconnectReason.ADMIN_KICK: "ADMIN_KICK",
    EzyDisconnectReason.MAX_REQUEST_PER_SECOND: "MAX_REQUEST_PER_SECOND",
    EzyDisconnectReason.MAX_REQUEST_SIZE: "MAX_REQUEST_SIZE",
    EzyDisconnectReason.SERVER_ERROR: "SERVER_ERROR",
    EzyDisconnectReason.SERVER_NOT_RESPONDING: "SERVER_NOT_RESPONDING",
    EzyDisconnectReason.UNAUTHORIZED: "UNAUTHORIZED"
  };

  EzyDisconnectReasons._();

  static String getDisconnectReasonName(int reasonId) {
    return _REASON_NAMES[reasonId] ?? reasonId.toString();
  }
}

class EzyConnectionFailedReason {
  EzyConnectionFailedReason._();

  static const TIMEOUT = 0;
  static const NETWORK_UNREACHABLE = 1;
  static const UNKNOWN_HOST = 2;
  static const CONNECTION_REFUSED = 3;
  static const UNKNOWN = 4;
}

class EzyConnectionFailedReasons {
  static const _REASON_NAMES = {
    EzyConnectionFailedReason.TIMEOUT: "TIMEOUT",
    EzyConnectionFailedReason.NETWORK_UNREACHABLE: "NETWORK_UNREACHABLE",
    EzyConnectionFailedReason.UNKNOWN_HOST: "UNKNOWN_HOST",
    EzyConnectionFailedReason.CONNECTION_REFUSED: "CONNECTION_REFUSED",
    EzyConnectionFailedReason.UNKNOWN: "UNKNOWN"
  };
  EzyConnectionFailedReasons._();

  static String getConnectionFailedReasonName(int reasonId) {
    return _REASON_NAMES[reasonId] ?? reasonId.toString();
  }
}

class EzyZone {
  late int id;
  late String name;
  late EzyClient client;
  late EzyAppManager appManager;

  EzyZone(this.client, this.id, this.name) {
    appManager = EzyAppManager(name);
  }

  EzyApp? getApp() {
    return appManager.getApp();
  }
}

class EzyApp {
  late int id;
  late String name;
  late EzyZone zone;
  late EzyClient client;
  late EzyAppDataHandlers dataHandlers;
  static const Map EMPTY_MAP = {};

  EzyApp(this.client, this.zone, this.id, this.name) {
    dataHandlers = client.handlerManager.getAppDataHandlers(name);
  }

  void send(String cmd, [dynamic data = EMPTY_MAP, bool encrypted = false]) {
    var requestData = [];
    requestData.add(id);
    var requestParams = [];
    requestParams.add(cmd);
    requestParams.add(data);
    requestData.add(requestParams);
    client.send(EzyCommand.APP_REQUEST, requestData, encrypted);
  }

  EzyAppDataHandler? getDataHandler(String cmd) {
    return dataHandlers.getHandler(cmd);
  }
}

class EzyUser {
  late int id;
  late String name;

  EzyUser(this.id, this.name);
}

class EzyEventHandler {
  void handle(Map event) {}
}

class EzyDataHandler {
  void handle(List data) {}
}

class EzyAbstractEventHandler extends EzyEventHandler {
  late EzyClient client;
}

class EzyAbstractDataHandler extends EzyDataHandler {
  late EzyClient client;
}

class EzyAppDataHandler<T> {
  void handle(EzyApp app, T data) {}
}

class EzyAbstractAppDataHandler<T> implements EzyAppDataHandler<T> {
  @override
  void handle(EzyApp app, T data) {
    process(app, data);
  }

  void process(EzyApp app, T data) {}
}

class EzyConnectionSuccessHandler extends EzyAbstractEventHandler {
  var clientType = "FLUTTER";
  var clientVersion = "1.0.0";

  @override
  void handle(Map event) {
    sendHandshakeRequest();
    postHandle();
  }

  void postHandle() {}

  void sendHandshakeRequest() {
    generateClientKey((clientKey) =>
        {client.send(EzyCommand.HANDSHAKE, newHandshakeRequest(clientKey))});
  }

  List newHandshakeRequest(String? clientKey) {
    var clientId = getClientId();
    var token = getStoredToken();
    var request = [];
    request.add(clientId);
    request.add(clientKey);
    request.add(clientType);
    request.add(clientVersion);
    request.add(_isEnableSSL(clientKey));
    request.add(token);
    return request;
  }

  bool _isEnableSSL(String? clientKey) {
    return client.enableSSL;
  }

  void _onKeyPairGenerated(
      EzyKeyPairProxy keyPair, Function(String?) callback) {
    client.privateKey = keyPair.privateKey;
    callback(keyPair.publicKey);
  }

  void generateClientKey(Function(String?) callback) {
    if (client.enableSSL) {
      EzyRSAProxy.getInstance().generateKeyPair(
          (keyPair) => {_onKeyPairGenerated(keyPair, callback)});
    } else {
      callback(null);
    }
  }

  String getClientId() {
    return UUID.random();
  }

  String getStoredToken() {
    return "";
  }
}

//=======================================================
class EzyConnectionFailureHandler extends EzyAbstractEventHandler {
  @override
  void handle(Map event) {
    var reason = event["reason"] as int;
    var reasonName =
        EzyConnectionFailedReasons.getConnectionFailedReasonName(reason);
    EzyLogger.warn("connection failure, reason = $reasonName");
    var config = client.config;
    var reconnectConfig = config.reconnect;
    var should = shouldReconnect(event);
    var reconnectEnable = reconnectConfig.enable;
    var mustReconnect = reconnectEnable && should;
    client.setStatus(EzyConnectionStatus.FAILURE);
    if (mustReconnect) {
      client.reconnect().then((value) => {_onReconnect(event, value)});
    } else {
      onConnectionFailed(event);
      postHandle(event);
    }
  }

  bool shouldReconnect(Map event) {
    return true;
  }

  void _onReconnect(Map event, bool success) {
    if (success) {
      onReconnecting(event);
    } else {
      onConnectionFailed(event);
    }
    postHandle(event);
  }

  void onReconnecting(Map event) {}

  void onConnectionFailed(Map event) {}

  void postHandle(Map event) {}
}

//=======================================================
class EzyDisconnectionHandler extends EzyAbstractEventHandler {
  @override
  void handle(Map event) {
    var reason = event["reason"] as int;
    var reasonName = EzyDisconnectReasons.getDisconnectReasonName(reason);
    EzyLogger.info("handle disconnection, reason = $reasonName");
    preHandle(event);
    var config = client.config;
    var reconnectConfig = config.reconnect;
    var should = shouldReconnect(event);
    var reconnectEnable = reconnectConfig.enable;
    var mustReconnect = reconnectEnable &&
        reason != EzyDisconnectReason.UNAUTHORIZED &&
        reason != EzyDisconnectReason.CLOSE &&
        should;
    client.setStatus(EzyConnectionStatus.DISCONNECTED);
    if (mustReconnect) {
      client.reconnect().then((value) => {_onReconnect(event, value)});
    } else {
      onDisconnected(event);
      postHandle(event);
    }
  }

  void _onReconnect(Map event, bool success) {
    if (success) {
      onReconnecting(event);
    } else {
      onDisconnected(event);
    }
    postHandle(event);
  }

  void preHandle(Map event) {}

  bool shouldReconnect(Map event) {
    var reason = event["reason"] as int;
    if (reason == EzyDisconnectReason.ANOTHER_SESSION_LOGIN) {
      return false;
    }
    return true;
  }

  void control(Map event) {}

  void onReconnecting(Map event) {}

  void onDisconnected(Map event) {}

  void postHandle(Map event) {}
}

//=======================================================
class EzyPongHandler extends EzyAbstractDataHandler {}

//=======================================================

class EzyHandshakeHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    startPing();
    doHandle(data);
  }

  void _onSessionKeyDecrypted(List data, Uint8List? sessionKey, bool success) {
    if (sessionKey != null) {
      client.setSessionKey(sessionKey);
    }
    if (success) {
      handleLogin();
    }
    postHandle(data);
  }

  void doHandle(List data) {
    client.sessionToken = data[1] as String;
    client.sessionId = data[2] as int;
    if (client.enableSSL) {
      decryptSessionKey(
          data[3],
          (sessionKey, success) =>
              {_onSessionKeyDecrypted(data, sessionKey, success)});
    } else {
      _onSessionKeyDecrypted(data, null, true);
    }
  }

  void decryptSessionKey(
      Uint8List? encryptedSessionKey, Function(Uint8List?, bool) callback) {
    if (encryptedSessionKey == null) {
      if (client.enableDebug) {
        callback(null, true);
        return;
      }
      EzyLogger.error(
        "maybe server was not enable SSL, you must enable SSL on server or disable SSL on your client or enable debug mode",
      );
      client.close();
      callback(null, false);
      return;
    }
    EzyRSAProxy.getInstance().decrypt(encryptedSessionKey, client.privateKey!,
        (sessionKey) => {callback(sessionKey, true)});
  }

  void postHandle(List data) {}

  void handleLogin() {
    var loginRequest = getLoginRequest();
    client.send(EzyCommand.LOGIN, loginRequest, encryptedLoginRequest());
  }

  bool encryptedLoginRequest() {
    return false;
  }

  List getLoginRequest() {
    var array = [];
    array.add("test");
    array.add("test");
    array.add("test");
    array.add([]);
    return array;
  }

  void startPing() {
    client.startPingSchedule();
  }
}

//=======================================================
class EzyLoginSuccessHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    var responseData = data[4];
    var user = newUser(data);
    var zone = newZone(data);
    client.me = user;
    client.zone = zone;
    handleLoginSuccess(responseData);
    EzyLogger.info("user: ${user.name} logged in successfully");
  }

  EzyUser newUser(List data) {
    var userId = data[2] as int;
    var username = data[3] as String;
    var user = EzyUser(userId, username);
    return user;
  }

  EzyZone newZone(List data) {
    var zoneId = data[0] as int;
    var zoneName = data[1] as String;
    var zone = EzyZone(client, zoneId, zoneName);
    return zone;
  }

  void handleLoginSuccess(dynamic responseData) {}
}

//=======================================================
class EzyLoginErrorHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    client.disconnect(EzyDisconnectReason.UNAUTHORIZED);
    handleLoginError(data);
  }

  void handleLoginError(List data) {}
}

//=======================================================
class EzyAppAccessHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    var zone = client.zone;
    var appManager = zone!.appManager;
    var app = newApp(zone, data);
    appManager.addApp(app);
    postHandle(app, data);
    EzyLogger.info("access app: ${app.name} successfully");
  }

  EzyApp newApp(EzyZone zone, List data) {
    var appId = data[0] as int;
    var appName = data[1] as String;
    var app = EzyApp(client, zone, appId, appName);
    return app;
  }

  void postHandle(EzyApp app, List data) {}
}

//=======================================================
class EzyAppExitHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    var zone = client.zone;
    var appManager = zone!.appManager;
    var appId = data[0] as int;
    var reasonId = data[1] as int;
    var app = appManager.removeApp(appId);
    if (app != null) {
      postHandle(app, data);
      EzyLogger.info("user exit app: ${app.name}, reason: $reasonId");
    }
  }

  void postHandle(EzyApp app, List data) {}
}

//=======================================================
class EzyAppResponseHandler extends EzyAbstractDataHandler {
  @override
  void handle(List data) {
    var appId = data[0] as int;
    var responseData = data[1] as List;
    var cmd = responseData[0];
    var commandData = responseData[1] as Map;

    var app = client.getAppById(appId);
    if (app == null) {
      EzyLogger.info("receive message when has not joined app yet");
      return;
    }
    var handler = app.getDataHandler(cmd);
    if (handler != null) {
      handler.handle(app, commandData);
    } else {
      EzyLogger.warn("app: ${app.name} has no handler for command: $cmd");
    }
  }
}

//=======================================================
class EzyEventHandlers {
  late EzyClient client;
  late Map handlers;

  EzyEventHandlers(this.client) {
    handlers = Map();
  }

  void addHandler(String eventType, EzyEventHandler handler) {
    var abs = handler as EzyAbstractEventHandler;
    abs.client = client;
    handlers[eventType] = handler;
  }

  EzyEventHandler? getHandler(String eventType) {
    return handlers[eventType];
  }

  void handle(String eventType, Map data) {
    var handler = getHandler(eventType);
    if (handler != null) {
      handler.handle(data);
    } else {
      EzyLogger.warn("has no handler with event: $eventType");
    }
  }
}

//=======================================================

class EzyDataHandlers {
  late EzyClient client;
  late Map handlerByCommand;

  EzyDataHandlers(this.client) {
    handlerByCommand = Map();
  }

  void addHandler(String cmd, EzyDataHandler handler) {
    var abs = handler as EzyAbstractDataHandler;
    abs.client = client;
    handlerByCommand[cmd] = handler;
  }

  EzyDataHandler? getHandler(String cmd) {
    return handlerByCommand[cmd];
  }

  void handle(String cmd, dynamic data) {
    var handler = getHandler(cmd);
    if (handler != null) {
      handler.handle(data);
    } else {
      EzyLogger.warn("has no handler with command: $cmd");
    }
  }
}

//=======================================================

class EzyAppDataHandlers {
  late Map<String, EzyAppDataHandler> _handlerByAppName;

  EzyAppDataHandlers() {
    _handlerByAppName = Map();
  }

  void addHandler(String cmd, EzyAppDataHandler handler) {
    _handlerByAppName[cmd] = handler;
  }

  EzyAppDataHandler? getHandler(String cmd) {
    return _handlerByAppName[cmd];
  }
}

class EzyLogger {
  EzyLogger._();

  static void error(String message) {
    Map params = {
      "level": "e",
      "message": message
    };
    EzyProxy.run("log", params);
  }

  static void warn(String message) {
    Map params = {
      "level": "w",
      "message": message
    };
    EzyProxy.run("log", params);
  }

  static void info(String message) {
    Map params = {
      "level": "i",
      "message": message
    };
    EzyProxy.run("log", params);
  }
}

class EzyAppManager {
  late String zoneName;
  late List<EzyApp> appList;
  late Map<int, EzyApp> appById;
  late Map<String, EzyApp> appByName;

  EzyAppManager(this.zoneName) {
    appList = [];
    appById = Map();
    appByName = Map();
  }

  EzyApp? getApp() {
    if (appList.isEmpty) {
      EzyLogger.warn("there is no app in zone: $zoneName");
      return null;
    }
    return appList[0];
  }

  void addApp(EzyApp app) {
    appList.add(app);
    appById[app.id] = app;
    appByName[app.name] = app;
  }

  EzyApp? removeApp(int appId) {
    var app = appById[appId];
    if (app != null) {
      appList.remove(app);
      appById.remove(app.id);
      appByName.remove(app.name);
    }
    return app;
  }

  EzyApp? getAppById(int appId) {
    return appById[appId];
  }

  EzyApp? getAppByName(String appName) {
    return appByName[appName];
  }
}

//===================================================
class EzyHandlerManager {
  late EzyClient client;
  late EzyDataHandlers dataHandlers;
  late EzyEventHandlers eventHandlers;
  late Map<String, EzyAppDataHandlers> appDataHandlersByAppName;

  EzyHandlerManager(this.client) {
    appDataHandlersByAppName = Map<String, EzyAppDataHandlers>();
    dataHandlers = _newDataHandlers();
    eventHandlers = _newEventHandlers();
  }

  static EzyHandlerManager create(EzyClient client) {
    var pRet = EzyHandlerManager(client);
    return pRet;
  }

  EzyEventHandlers _newEventHandlers() {
    var handlers = EzyEventHandlers(client);
    handlers.addHandler(
        EzyEventType.CONNECTION_SUCCESS, EzyConnectionSuccessHandler());
    handlers.addHandler(
        EzyEventType.CONNECTION_FAILURE, EzyConnectionFailureHandler());
    handlers.addHandler(EzyEventType.DISCONNECTION, EzyDisconnectionHandler());
    return handlers;
  }

  EzyDataHandlers _newDataHandlers() {
    var handlers = EzyDataHandlers(client);
    handlers.addHandler(EzyCommand.PONG, EzyPongHandler());
    handlers.addHandler(EzyCommand.HANDSHAKE, EzyHandshakeHandler());
    handlers.addHandler(EzyCommand.LOGIN, EzyLoginSuccessHandler());
    handlers.addHandler(EzyCommand.LOGIN_ERROR, EzyLoginErrorHandler());
    handlers.addHandler(EzyCommand.APP_ACCESS, EzyAppAccessHandler());
    handlers.addHandler(EzyCommand.APP_EXIT, EzyAppExitHandler());
    handlers.addHandler(EzyCommand.APP_REQUEST, EzyAppResponseHandler());
    return handlers;
  }

  EzyDataHandler? getDataHandler(String cmd) {
    return dataHandlers.getHandler(cmd);
  }

  EzyEventHandler? getEventHandler(String eventType) {
    return eventHandlers.getHandler(eventType);
  }

  EzyAppDataHandlers getAppDataHandlers(String appName) {
    var answer = appDataHandlersByAppName[appName];
    if (answer == null) {
      answer = EzyAppDataHandlers();
      appDataHandlersByAppName[appName] = answer;
    }
    return answer;
  }

  void addDataHandler(String cmd, EzyDataHandler handler) {
    dataHandlers.addHandler(cmd, handler);
  }

  void addEventHandler(String eventType, EzyEventHandler handler) {
    eventHandlers.addHandler(eventType, handler);
  }
}

class EzyProxy {
  late MethodChannel _methodChannel;

  static final EzyProxy _INSTANCE = EzyProxy._();

  EzyProxy._() {
    _methodChannel = const MethodChannel('com.tvd12.ezyfoxserver.client');
    _methodChannel.setMethodCallHandler(_handleSocketEventDatas);
  }

  static EzyProxy getInstance() {
    return _INSTANCE;
  }

  Future<void> _handleSocketEventDatas(MethodCall call) async {
    // type inference will work here avoiding an explicit cast
    switch (call.method) {
      case "ezy.event":
        _onSocketEvent(call.arguments);
        break;
      case "ezy.data":
        _onSocketData(call.arguments);
        break;
      default:
        EzyLogger.warn(
          "there is no handler for method: ${call.method}, ignore it",
        );
    }
  }

  void _onSocketEvent(Map arguments) {
    String clientName = arguments["clientName"];
    String eventType = arguments["eventType"];
    dynamic data = arguments["data"];
    EzyClient client = _getClient(clientName);
    client.handleEvent(eventType, data);
  }

  void _onSocketData(Map arguments) {
    String clientName = arguments["clientName"];
    String command = arguments["command"];
    dynamic data = arguments["data"];
    EzyClient client = _getClient(clientName);
    client.handleData(command, data);
  }

  static Future<T?> run<T>(String method, Map params) {
    return EzyProxy.getInstance()._methodChannel.invokeMethod(method, params);
  }

  EzyClient _getClient(String clientName) {
    return EzyClients.getInstance().getClient(clientName);
  }
}

class EzySetup {
  late EzyHandlerManager handlerManager;
  late Map<String, EzyAppSetup> appSetupByAppName;

  EzySetup(this.handlerManager) {
    appSetupByAppName = Map();
  }

  EzySetup addDataHandler(String cmd, EzyDataHandler handler) {
    handlerManager.addDataHandler(cmd, handler);
    return this;
  }

  EzySetup addEventHandler(String eventType, EzyEventHandler handler) {
    handlerManager.addEventHandler(eventType, handler);
    return this;
  }

  EzyAppSetup setupApp(String appName) {
    var appSetup = appSetupByAppName[appName];
    if (appSetup == null) {
      var appDataHandlers = handlerManager.getAppDataHandlers(appName);
      appSetup = EzyAppSetup(appDataHandlers, this);
      appSetupByAppName[appName] = appSetup;
    }
    return appSetup;
  }
}

class EzyAppSetup {
  late EzySetup parent;
  late EzyAppDataHandlers dataHandlers;

  EzyAppSetup(this.dataHandlers, this.parent);

  EzyAppSetup addDataHandler(String cmd, EzyAppDataHandler handler) {
    dataHandlers.addHandler(cmd, handler);
    return this;
  }

  EzySetup done() {
    return parent;
  }
}

class UUID {
  static const _CHARS =
      'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz1234567890';
  UUID._() {}

  static String random() {
    return "${_randomString(8)}-${_randomString(8)}-${_randomString(8)}-${_randomString(8)}";
  }

  static String _randomString(int length) {
    Random random = Random();
    return String.fromCharCodes(Iterable.generate(
        length, (_) => _CHARS.codeUnitAt(random.nextInt(_CHARS.length))));
  }
}