/**
 * 蓝牙 BLE 采集服务
 */
const hex = require('../utils/hex.js');

// BLE 状态常量
const BLE_STATE = {
  DISCONNECTED: 'disconnected',
  CONNECTING: 'connecting',
  CONNECTED: 'connected',
  DISCOVERING: 'discovering',
  READY: 'ready',
};

// 默认配置
const DEFAULT_CONFIG = {
  // 扫描超时时间（毫秒）
  scanTimeout: 10000,
  // 连接超时时间（毫秒）
  connectTimeout: 10000,
  // 默认服务 UUID（需根据实际设备配置）
  serviceUUIDs: [],
  // 调试日志开关（高频数据禁止逐包打印，否则阻塞 BLE 接收）
  debug: false,
  // 掉线自动重连（工业场景建议开启）
  autoReconnect: true,
};

class BleService {
  constructor() {
    this.state = BLE_STATE.DISCONNECTED;
    this.deviceId = null;
    this.serviceId = null;
    this.notifyCharacteristicId = null;
    this.writeCharacteristicId = null;
    this.onDataCallback = null;
    this.onStateChangeCallback = null;
    this.config = { ...DEFAULT_CONFIG };
    // 监听器注册标志（防止叠加）
    this._listenersRegistered = false;
    // 适配器是否已开启
    this._openedAdapter = false;
    // 收包计数/最近收包时间（诊断、静默探测用）
    this._recvCount = 0;
    this._lastRecvAt = 0;
    // 当前会话已启用 notify 的特征列表
    this._notifyCharacteristicIds = [];
    // 自动重连相关
    this._lastDeviceId = null;
    this._lastServiceId = null;
    this._reconnectTimer = null;
    this._reconnectAttempts = 0;
    this._manuallyDisconnected = false;
  }

  /**
   * 设置配置
   * @param {Object} config
   */
  setConfig(config) {
    this.config = { ...DEFAULT_CONFIG, ...config };
  }

  /**
   * 设置数据回调
   * @param {Function} callback - (data: {hex, buffer}) => void
   */
  onData(callback) {
    this.onDataCallback = callback;
  }

  /**
   * 设置状态变化回调
   * @param {Function} callback - (state) => void
   */
  onStateChange(callback) {
    this.onStateChangeCallback = callback;
  }

  /**
   * 更新状态并通知
   * @param {string} state
   */
  _setState(state) {
    this.state = state;
    if (this.onStateChangeCallback) {
      this.onStateChangeCallback(state);
    }
    console.log('[BLE] 状态变更:', state);
  }

  /**
   * 初始化蓝牙适配器（幂等）
   * wx 级全局监听只注册一次，不再每次 off/on 抖动，避免多页/重连切换时的丢包窗口。
   * @returns {Promise}
   */
  initBluetooth() {
    return new Promise((resolve, reject) => {
      // 已开启且监听已挂：直接复用
      if (this._openedAdapter && this._listenersRegistered) {
        resolve();
        return;
      }

      // 已开适配器但监听未挂（异常恢复路径），补挂监听即可
      const registerListeners = () => {
        if (this._listenersRegistered) return;

        wx.onBLEConnectionStateChange((res) => {
          console.log('[BLE] 连接状态变化:', res);
          if (!res.connected) {
            const wasConnected = this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
            this._setState(BLE_STATE.DISCONNECTED);
            // 保留 deviceId 供重连使用（不再置空），掉线自动重连
            if (wasConnected && this.config.autoReconnect && !this._manuallyDisconnected && this._lastDeviceId) {
              this._scheduleReconnect();
            }
          }
        });

        wx.onBLECharacteristicValueChange((res) => {
          // 只处理当前会话设备的值变化，防止切换设备后旧连接/残留连接串包
          if (this.deviceId && res.deviceId && res.deviceId !== this.deviceId) {
            return;
          }
          const hexData = hex.arrayBufferToHex(res.value);
          this._recvCount++;
          this._lastRecvAt = Date.now();
          // 首包 + 每 20 包打印摘要，debug 时逐包打印，避免高频逐包日志阻塞接收
          if (this.config.debug || this._recvCount === 1 || this._recvCount % 20 === 0) {
            console.log(`[BLE] 收到数据 #${this._recvCount} (${hexData.length / 2}字节):`, hexData);
          }
          if (this.onDataCallback) {
            this.onDataCallback({
              hex: hexData,
              buffer: res.value,
              deviceId: res.deviceId,
              serviceId: res.serviceId,
              characteristicId: res.characteristicId,
            });
          }
        });

        this._listenersRegistered = true;
        console.log('[BLE] 已注册全局监听');
      };

      if (this._openedAdapter) {
        registerListeners();
        resolve();
        return;
      }

      wx.openBluetoothAdapter({
        success: () => {
          console.log('[BLE] 初始化成功');
          this._openedAdapter = true;
          registerListeners();
          resolve();
        },
        fail: (err) => {
          const msg = (err && err.errMsg) || '';
          // 部分平台适配器已开启时 open 会报 already 类错误，视为成功
          if (/already/i.test(msg)) {
            console.log('[BLE] 适配器已开启（忽略 already）');
            this._openedAdapter = true;
            registerListeners();
            resolve();
          } else {
            console.error('[BLE] 初始化失败:', err);
            reject(new Error('蓝牙初始化失败: ' + msg || '未知错误'));
          }
        },
      });
    });
  }

  /**
   * 获取平台合适的 MTU 值
   * @returns {number}
   */
  _getMtu() {
    try {
      const platform = wx.getSystemInfoSync().platform;
      // iOS 最大 185，超出会协商失败；Android 建议 247
      return platform === 'ios' ? 185 : 247;
    } catch (e) {
      return 247;
    }
  }

  /**
   * 扫描蓝牙设备
   * @param {Array<string>} serviceUUIDs - 服务 UUID 列表（可选）
   * @param {number} timeout - 超时时间（毫秒）
   * @returns {Promise<Array>} 设备列表
   */
  scanDevices(serviceUUIDs = null, timeout = null) {
    return new Promise((resolve, reject) => {
      const uuids = serviceUUIDs || this.config.serviceUUIDs;
      const scanTimeout = timeout || this.config.scanTimeout;

      const devices = [];
      const deviceMap = new Map();

      // 移除旧的扫描监听器，防止叠加
      try {
        wx.offBluetoothDeviceFound();
      } catch (e) {
        // 忽略移除失败
      }

      // 开始扫描
      wx.startBluetoothDevicesDiscovery({
        services: uuids.length > 0 ? uuids : undefined,
        allowDuplicatesKey: false,
        success: () => {
          console.log('[BLE] 开始扫描, 超时:', scanTimeout);
          // 监听扫描结果
          wx.onBluetoothDeviceFound((res) => {
            res.devices.forEach((device) => {
              // 去重
              if (!deviceMap.has(device.deviceId)) {
                deviceMap.set(device.deviceId, true);
                devices.push({
                  deviceId: device.deviceId,
                  name: device.name || '未知设备',
                  localName: device.localName,
                  advertisData: device.advertisData,
                  RSSI: device.RSSI,
                });
              }
            });
          });

          // 设置超时
          setTimeout(() => {
            wx.stopBluetoothDevicesDiscovery({
              success: () => {
                console.log('[BLE] 扫描完成, 发现设备:', devices.length);
                // 移除扫描监听器
                try {
                  wx.offBluetoothDeviceFound();
                } catch (e) {
                  // 忽略
                }
                resolve(devices);
              },
              fail: () => {
                try {
                  wx.offBluetoothDeviceFound();
                } catch (e) {
                  // 忽略
                }
                resolve(devices);
              },
            });
          }, scanTimeout);
        },
        fail: (err) => {
          console.error('[BLE] 扫描失败:', err);
          reject(new Error('扫描失败: ' + (err.errMsg || '未知错误')));
        },
      });
    });
  }

  /**
   * 停止扫描
   */
  stopScan() {
    return new Promise((resolve) => {
      wx.stopBluetoothDevicesDiscovery({
        success: () => {
          console.log('[BLE] 已停止扫描');
          resolve();
        },
        fail: () => {
          resolve();
        },
      });
    });
  }

  /**
   * 连接设备
   * @param {string} deviceId - 设备 ID
   * @param {string} serviceId - 服务 UUID（可选，不传则自动发现）
   * @returns {Promise}
   */
  connectDevice(deviceId, serviceId = null) {
    return new Promise((resolve, reject) => {
      this._setState(BLE_STATE.CONNECTING);
      this.deviceId = deviceId;

      // 记录连接目标，供自动重连使用
      this._lastDeviceId = deviceId;
      this._lastServiceId = serviceId;
      this._manuallyDisconnected = false;
      this._clearReconnectTimer();

      const connectTimeout = this.config.connectTimeout;
      let timeoutId = null;

      // 设置连接超时
      timeoutId = setTimeout(() => {
        wx.closeBLEConnection({
          deviceId: deviceId,
          complete: () => {
            this._setState(BLE_STATE.DISCONNECTED);
            reject(new Error('连接超时'));
          },
        });
      }, connectTimeout);

      // 发起连接
      wx.createBLEConnection({
        deviceId: deviceId,
        success: () => {
          clearTimeout(timeoutId);
          console.log('[BLE] 连接成功:', deviceId);
          // 连接成功，重置重连退避计数
          this._reconnectAttempts = 0;
          this._setState(BLE_STATE.CONNECTED);

          // 获取 MTU（提高传输效率，iOS 最大 185，Android 建议 247）
          wx.setBLEMTU({
            deviceId: deviceId,
            mtu: this._getMtu(),
            complete: () => {
              // 发现服务
              this._discoverServices(deviceId, serviceId)
                .then(resolve)
                .catch(reject);
            },
          });
        },
        fail: (err) => {
          clearTimeout(timeoutId);
          const errMsg = (err && err.errMsg) || '';

          // 如果报错 "already connect"，先断开再重连
          if (/already connect/i.test(errMsg)) {
            console.warn('[BLE] 检测到已存在连接，先断开再重连');
            wx.closeBLEConnection({
              deviceId: deviceId,
              complete: () => {
                // 断开后重新连接
                setTimeout(() => {
                  wx.createBLEConnection({
                    deviceId: deviceId,
                    success: () => {
                      console.log('[BLE] 重连成功:', deviceId);
                      this._reconnectAttempts = 0;
                      this._setState(BLE_STATE.CONNECTED);
                      wx.setBLEMTU({
                        deviceId: deviceId,
                        mtu: this._getMtu(),
                        complete: () => {
                          this._discoverServices(deviceId, serviceId)
                            .then(resolve)
                            .catch(reject);
                        },
                      });
                    },
                    fail: (err2) => {
                      this._setState(BLE_STATE.DISCONNECTED);
                      console.error('[BLE] 重连失败:', err2);
                      reject(new Error('重连失败: ' + (err2.errMsg || '未知错误')));
                    },
                  });
                }, 500);  // 等待 500ms 确保断开完成
              },
            });
            return;
          }

          this._setState(BLE_STATE.DISCONNECTED);
          console.error('[BLE] 连接失败:', err);
          reject(new Error('连接失败: ' + errMsg || '未知错误'));
        },
      });
    });
  }

  /**
   * 发现服务和特征值
   * @param {string} deviceId
   * @param {string} serviceId
   * @returns {Promise}
   */
  _discoverServices(deviceId, serviceId = null) {
    return new Promise((resolve, reject) => {
      this._setState(BLE_STATE.DISCOVERING);

      wx.getBLEDeviceServices({
        deviceId: deviceId,
        success: (res) => {
          console.log('[BLE] 发现服务:', res.services);
          const services = res.services;

          // 选择目标服务
          let targetService = null;
          if (serviceId) {
            // 指定了服务 UUID
            targetService = services.find(s => s.uuid.toLowerCase().includes(serviceId.toLowerCase()));
          } else {
            // 自动选择：排除通用服务（GAP 0x1800, GATT 0x1801 等）
            const GENERIC_SERVICE_PREFIXES = ['00001800', '00001801', '0000180a', '0000180f'];
            targetService = services.find(s =>
              !GENERIC_SERVICE_PREFIXES.some(p => s.uuid.toLowerCase().startsWith(p))
            );
            // 如果没有非通用服务，选择第一个主服务
            if (!targetService) {
              targetService = services.find(s => s.isPrimary) || services[0];
            }
          }

          if (!targetService) {
            reject(new Error('未找到目标服务'));
            return;
          }

          this.serviceId = targetService.uuid;
          console.log('[BLE] 目标服务:', this.serviceId);

          // 获取特征值
          this._discoverCharacteristics(deviceId, this.serviceId)
            .then(resolve)
            .catch(reject);
        },
        fail: (err) => {
          console.error('[BLE] 获取服务失败:', err);
          reject(new Error('获取服务失败'));
        },
      });
    });
  }

  /**
   * 发现特征值
   * 目标服务下所有 notify/indicate 特征都尝试启用（数据特征未必是第一个 notify 特征），
   * 单个特征启用失败仅告警跳过，至少一个成功即视为就绪。
   * @param {string} deviceId
   * @param {string} serviceId
   * @returns {Promise}
   */
  _discoverCharacteristics(deviceId, serviceId) {
    return new Promise((resolve, reject) => {
      wx.getBLEDeviceCharacteristics({
        deviceId: deviceId,
        serviceId: serviceId,
        success: (res) => {
          console.log('[BLE] 发现特征值:', res.characteristics.map(c => ({
            uuid: c.uuid,
            properties: c.properties,
          })));
          const characteristics = res.characteristics;

          const notifyChars = characteristics.filter(c => c.properties.notify || c.properties.indicate);
          const writeChar = characteristics.find(c => c.properties.write || c.properties.writeNoResponse);
          if (writeChar) {
            this.writeCharacteristicId = writeChar.uuid;
            console.log('[BLE] 写入特征值:', this.writeCharacteristicId);
          }

          if (notifyChars.length === 0) {
            // 没有通知特征值，但可能有写入特征值
            console.warn('[BLE] ⚠️ 未找到 notify/indicate 特征值！设备将无法主动上报数据，只能被动写入。请核对设备的 GATT 服务/特征值。');
            this._notifyCharacteristicIds = [];
            this.notifyCharacteristicId = null;
            this._lastRecvAt = Date.now();
            this._setState(BLE_STATE.READY);
            resolve({
              serviceId: this.serviceId,
              notifyCharacteristicIds: [],
              notifyCharacteristicId: null,
              writeCharacteristicId: this.writeCharacteristicId,
            });
            return;
          }

          // 串行逐个启用 notify
          this._enableAllNotify(deviceId, serviceId, notifyChars).then((enabled) => {
            this._notifyCharacteristicIds = enabled;
            this.notifyCharacteristicId = enabled[0] || null;
            if (enabled.length === 0) {
              console.error('[BLE] 所有 notify 特征启用均失败');
              reject(new Error('启用通知失败'));
              return;
            }
            console.log('[BLE] 已启用 notify 特征:', enabled);
            // 作为后续“静默/掉线”探测的基线
            this._lastRecvAt = Date.now();
            this._setState(BLE_STATE.READY);
            resolve({
              serviceId: this.serviceId,
              notifyCharacteristicIds: enabled,
              notifyCharacteristicId: this.notifyCharacteristicId,
              writeCharacteristicId: this.writeCharacteristicId,
            });
          }).catch((err) => {
            console.error('[BLE] 启用通知异常:', err);
            reject(new Error('启用通知失败'));
          });
        },
        fail: (err) => {
          console.error('[BLE] 获取特征值失败:', err);
          reject(new Error('获取特征值失败'));
        },
      });
    });
  }

  /**
   * 串行启用多个 notify/indicate 特征
   * @param {string} deviceId
   * @param {string} serviceId
   * @param {Array} chars - 特征数组（含 uuid）
   * @returns {Promise<Array<string>>} 成功启用的特征 UUID 列表
   */
  _enableAllNotify(deviceId, serviceId, chars) {
    return chars.reduce((chain, c) => {
      return chain.then((enabled) => {
        return this._enableNotify(deviceId, serviceId, c.uuid).then((ok) => {
          if (ok) enabled.push(c.uuid);
          return enabled;
        });
      });
    }, Promise.resolve([]));
  }

  /**
   * 启用单个特征的 notify/indicate
   * @returns {Promise<string|null>} 成功返回特征 UUID，失败返回 null（不抛错）
   */
  _enableNotify(deviceId, serviceId, characteristicId) {
    return new Promise((resolve) => {
      wx.notifyBLECharacteristicValueChange({
        deviceId: deviceId,
        serviceId: serviceId,
        characteristicId: characteristicId,
        state: true,
        success: () => {
          console.log('[BLE] 启用通知:', characteristicId);
          resolve(characteristicId);
        },
        fail: (err) => {
          console.warn('[BLE] 启用通知失败(跳过):', characteristicId, err);
          resolve(null);
        },
      });
    });
  }

  /**
   * 写入数据
   * @param {string} hexData - 十六进制字符串
   * @returns {Promise}
   */
  writeCommand(hexData) {
    return new Promise((resolve, reject) => {
      if (!this.deviceId || !this.serviceId || !this.writeCharacteristicId) {
        reject(new Error('设备未连接或无写入特征值'));
        return;
      }

      const buffer = hex.hexToArrayBuffer(hexData);

      wx.writeBLECharacteristicValue({
        deviceId: this.deviceId,
        serviceId: this.serviceId,
        characteristicId: this.writeCharacteristicId,
        value: buffer,
        success: () => {
          console.log('[BLE] 写入成功:', hexData);
          resolve();
        },
        fail: (err) => {
          console.error('[BLE] 写入失败:', err);
          reject(new Error('写入失败: ' + (err.errMsg || '未知错误')));
        },
      });
    });
  }

  /**
   * 清除自动重连定时器
   */
  _clearReconnectTimer() {
    if (this._reconnectTimer) {
      clearTimeout(this._reconnectTimer);
      this._reconnectTimer = null;
    }
  }

  /**
   * 调度自动重连（指数退避：1s → 2s → 4s ... 最大 15s）
   */
  _scheduleReconnect() {
    if (this._reconnectTimer) return;
    const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), 15000);
    this._reconnectAttempts++;
    console.log(`[BLE] ${delay}ms 后自动重连（第 ${this._reconnectAttempts} 次）`);
    this._reconnectTimer = setTimeout(() => {
      this._reconnectTimer = null;
      if (!this._lastDeviceId) return;
      this.connectDevice(this._lastDeviceId, this._lastServiceId).catch((err) => {
        console.error('[BLE] 自动重连失败:', err.message);
        this._scheduleReconnect();
      });
    }, delay);
  }

  /**
   * 断开连接
   */
  disconnect() {
    return new Promise((resolve) => {
      // 用户主动断开，停止自动重连
      this._manuallyDisconnected = true;
      this._clearReconnectTimer();

      if (!this.deviceId) {
        if (this.state !== BLE_STATE.DISCONNECTED) {
          this._setState(BLE_STATE.DISCONNECTED);
        }
        resolve();
        return;
      }

      wx.closeBLEConnection({
        deviceId: this.deviceId,
        success: () => {
          console.log('[BLE] 已断开连接');
        },
        complete: () => {
          this._setState(BLE_STATE.DISCONNECTED);
          this.deviceId = null;
          this.serviceId = null;
          this.notifyCharacteristicId = null;
          this.writeCharacteristicId = null;
          this._notifyCharacteristicIds = [];
          this._lastRecvAt = 0;
          resolve();
        },
      });
    });
  }

  /**
   * 关闭蓝牙适配器
   */
  closeBluetooth() {
    return new Promise((resolve) => {
      this.disconnect().then(() => {
        wx.closeBluetoothAdapter({
          success: () => {
            console.log('[BLE] 已关闭蓝牙适配器');
          },
          complete: () => {
            resolve();
          },
        });
      });
    });
  }

  /**
   * 获取当前状态
   * @returns {string}
   */
  getState() {
    return this.state;
  }

  /**
   * 是否已连接
   * @returns {boolean}
   */
  isConnected() {
    return this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
  }

  /**
   * 是否处于可接收数据的就绪态
   * @returns {boolean}
   */
  isReady() {
    return this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
  }

  /**
   * 是否正处于连接流程中（用于避免与自动重连并发发起 createBLEConnection）
   * @returns {boolean}
   */
  isConnecting() {
    return this.state === BLE_STATE.CONNECTING || this.state === BLE_STATE.DISCOVERING;
  }

  /**
   * 强制重连当前目标设备（用于静默/掉线恢复）
   * @returns {Promise}
   */
  forceReconnect() {
    if (!this._lastDeviceId) {
      return Promise.reject(new Error('无重连目标'));
    }
    this._reconnectAttempts = 0;
    this._manuallyDisconnected = false;
    this._clearReconnectTimer();
    console.log('[BLE] 强制重连:', this._lastDeviceId);
    return this.connectDevice(this._lastDeviceId, this._lastServiceId);
  }

  /**
   * 探测连接是否仍活跃（超过 silentMs 无收包视为不活跃）
   * @param {number} silentMs - 静默阈值（毫秒）
   * @returns {boolean}
   */
  probeConnection(silentMs = 30000) {
    if (!this.isReady()) return false;
    if (!this._lastRecvAt) return true; // 尚未收到任何包，不做静默判定
    return (Date.now() - this._lastRecvAt) <= silentMs;
  }

  /**
   * 诊断信息（真机排查“收不到/收一条即停”用）
   * @returns {Object}
   */
  getDiagnostics() {
    return {
      state: this.state,
      adapterOpen: !!this._openedAdapter,
      deviceId: this.deviceId,
      serviceId: this.serviceId,
      notifyCharacteristicId: this.notifyCharacteristicId,
      notifyCharacteristicIds: this._notifyCharacteristicIds || [],
      writeCharacteristicId: this.writeCharacteristicId,
      recvCount: this._recvCount,
      lastRecvAt: this._lastRecvAt,
      autoReconnect: this.config.autoReconnect,
    };
  }

  /**
   * 清除数据回调（页面卸载时调用）
   */
  clearCallbacks() {
    this.onDataCallback = null;
    this.onStateChangeCallback = null;
    console.log('[BLE] 已清除回调');
  }
}

// 导出单例
const bleService = new BleService();

module.exports = {
  BLE_STATE,
  BleService,
  bleService,
};