/**
 * TCP连接工具类
 * 用于处理TCP连接、发送消息和断开连接
 *
 * @format
 */

// 引用TCP插件
// const TCPSocket = uni.requireNativePlugin('Aimer-TCPPlugin');
// const TCPSocket = uni.requireNativePlugin("Aimer-TCPPlugin");

// TCP连接配置
const TCP_CONFIG = {
  ip: "39.102.136.61",
  port: "8088",
  channel: "1", // 可选 1~20
  charsetname: "UTF-8", // 默认UTF-8，可选GBK
};

/**
 * TCP连接管理类
 */
class TCPConnection {
    constructor() {
        this.channelConnections = new Map(); // 存储每个channel的连接状态
        this.connectionCallbacks = [];
        this.messageCallbacks = [];
    }

    /**
     * TCP初始化连接
     * @param {Object} config - 连接配置 {ip, port, channel, charsetname}
     * @param {Function} callback - 连接状态回调函数
     */
    connect(config = {}, callback = null) {
        const channel = config.channel || TCP_CONFIG.channel;
        
        // 如果该channel已经连接，先断开现有连接
        if (this.channelConnections.get(channel)) {
            console.log(`检测到channel ${channel}现有TCP连接，先断开...`);
            this.disconnect(config);
            // 等待断开完成后再连接
            setTimeout(() => {
                this._performConnect(config, callback);
            }, 300);
        } else {
            // 直接连接
            this._performConnect(config, callback);
        }
    }

  /**
   * 执行TCP连接
   * @param {Object} config - 连接配置
   * @param {Function} callback - 连接状态回调函数
   */
  _performConnect(config = {}, callback = null) {
    const connectionConfig = {
      channel: config.channel || TCP_CONFIG.channel,
      ip: config.ip || TCP_CONFIG.ip,
      port: config.port || TCP_CONFIG.port,
    };

    // 如果指定了字符集，添加到配置中
    if (config.charsetname || TCP_CONFIG.charsetname) {
      connectionConfig.charsetname = config.charsetname || TCP_CONFIG.charsetname;
    }

        console.log('开始建立TCP连接:', connectionConfig);
        TCPSocket.connect(
            connectionConfig,
            result => {
                /**
                 * status : 0 连接成功
                 * status : 1 断开连接
                 * receivedMsg : 服务器返回字符串(普通的字符串交互)
                 * receivedHexMsg : 服务器返回字节数组(单片机、智能家居等硬件数据交互)
                 */
                if (result.status == '0') {
                    // TCP连接成功
                    this.channelConnections.set(connectionConfig.channel, true);
                    console.log(`TCP连接成功 - Channel ${connectionConfig.channel}`);
                    this._notifyConnectionCallbacks('connected', result, connectionConfig.channel);
                } else if (result.status == '1') {
                    // TCP断开连接
                    this.channelConnections.set(connectionConfig.channel, false);
                    console.log(`TCP断开连接 - Channel ${connectionConfig.channel}`);
                    this._notifyConnectionCallbacks('disconnected', result, connectionConfig.channel);
                }

                if (result.receivedMsg) {
                    // 服务器返回字符串
                    console.log('收到字符串消息:', result.receivedMsg);
                    this._notifyMessageCallbacks('string', result.receivedMsg, null, connectionConfig.channel);
                }

      // if (result.receivedHexMsg) {
      //     // 硬件服务器返回16进制数据
      //     console.log('收到16进制消息:', result.receivedHexMsg);
      //     let msg = result.receivedHexMsg;
      //     let sum = msg.length / 2;
      //     let arr = [];
      //     for (let k = 0; k < sum; k++) {
      //         let i = msg.substring(k * 2, k * 2 + 2);
      //         arr.push(i);
      //     }
      //     console.log('解析后的16进制数组:', arr);
      //     this._notifyMessageCallbacks('hex', result.receivedHexMsg, arr);
      // }

      // 执行回调函数
      if (callback && typeof callback === "function") {
        callback(result);
      }
    });
  }

    /**
     * TCP发送消息(普通的字符串交互)
     * @param {String|Object} message - 要发送的消息，如果是对象会自动转换为JSON字符串
     * @param {Object} config - 发送配置 {channel, charsetname}
     */
    send(message, config = {}) {
        const channel = config.channel || '1';
        
        if (!this.channelConnections.get(channel)) {
            console.warn(`TCP Channel ${channel}未连接，无法发送消息`);
            return false;
        }

    // 如果message是对象，转换为JSON字符串
    let messageStr = message;
    if (typeof message === "object") {
      messageStr = JSON.stringify(message) + "\n";
    }

    const sendConfig = {
      channel: config.channel || "1", // 注意：channel应该是字符串
      message: messageStr,
    };

    // 如果指定了字符编码，添加到配置中
    if (config.charsetname) {
      sendConfig.charsetname = config.charsetname;
    }

    TCPSocket.send(sendConfig);
    console.log("js成功发送TCP消息:", messageStr);
    return true;
  }

    /**
     * TCP断开连接
     * @param {Object} config - 断开配置 {channel}
     */
    disconnect(config = {}) {
        const channel = config.channel || TCP_CONFIG.channel;
        const disconnectConfig = {
            channel: channel
        };

        TCPSocket.disconnect(disconnectConfig);
        this.channelConnections.set(channel, false);
        console.log(`TCP连接已断开 - Channel ${channel}`, disconnectConfig);
    }

  /**
   * 添加连接状态监听器
   * @param {Function} callback - 回调函数 (status, result) => {}
   */
  onConnectionChange(callback) {
    if (typeof callback === "function") {
      this.connectionCallbacks.push(callback);
    }
  }

  /**
   * 添加消息监听器
   * @param {Function} callback - 回调函数 (type, message, parsedArray) => {}
   */
  onMessage(callback) {
    if (typeof callback === "function") {
      this.messageCallbacks.push(callback);
    }
  }

  /**
   * 移除连接状态监听器
   * @param {Function} callback - 要移除的回调函数
   */
  removeConnectionListener(callback) {
    const index = this.connectionCallbacks.indexOf(callback);
    if (index > -1) {
      this.connectionCallbacks.splice(index, 1);
    }
  }

  /**
   * 移除消息监听器
   * @param {Function} callback - 要移除的回调函数
   */
  removeMessageListener(callback) {
    const index = this.messageCallbacks.indexOf(callback);
    if (index > -1) {
      this.messageCallbacks.splice(index, 1);
    }
  }

    /**
     * 获取连接状态
     * @param {String} channel - 要检查的channel，如果不指定则返回所有channel的连接状态
     * @returns {Boolean|Object} 连接状态
     */
    getConnectionStatus(channel = null) {
        if (channel) {
            return this.channelConnections.get(channel) || false;
        }
        // 返回所有channel的连接状态
        const allConnections = {};
        for (const [ch, status] of this.channelConnections) {
            allConnections[ch] = status;
        }
        return allConnections;
    }

    /**
     * 通知连接状态回调
     * @private
     */
    _notifyConnectionCallbacks(status, result, channel) {
        this.connectionCallbacks.forEach(callback => {
            try {
                callback(status, result, channel);
            } catch (error) {
                console.error('连接状态回调执行错误:', error);
            }
        });
    }

    /**
     * 通知消息回调
     * @private
     */
    _notifyMessageCallbacks(type, message, parsedArray = null, channel = null) {
        this.messageCallbacks.forEach(callback => {
            try {
                callback(type, message, parsedArray, channel);
            } catch (error) {
                console.error('消息回调执行错误:', error);
            }
        });
    }
}

// 创建TCP连接实例
const tcpConnection = new TCPConnection();

// 导出TCP连接实例和类
export default tcpConnection;
export { TCPConnection, TCP_CONFIG };