import { createEventBus } from './eventBus';
import { createBleState, BLE_STAGE } from './state';
import { createBleError, getBleErrorText, normalizeBleError } from './errors';
import { uint8ArrayToArrayBuffer, toUint8Array } from '../utils/bytes';
import { toFullUuid, uuidEquals, uuidInList } from '../utils/uuid';
import { runWithRetry } from './retry';
import { getBleProfile, DEVICE_PROFILE } from '../protocols/profiles';

// 把 uni 的 success/fail 回调风格统一成 Promise，便于串联 async 流程。
function promisifyUniApi(apiName, params = {}) {
  return new Promise((resolve, reject) => {
    uni[apiName]({
      ...params,
      success: (res) => resolve(res),
      fail: (err) => reject(err),
    });
  });
}

/**
 * BLE 核心能力封装：
 * 负责适配器生命周期、扫描、连接、服务/特征发现、读写与通知监听。
 */
export function createBleCore(options = {}) {
  const {
    reconnect = {
      enabled: true,
      retries: 2,
      delay: 1200,
    },
    logger = console,
    profileId = DEVICE_PROFILE.UNKNOWN,
  } = options;

  const eventBus = createEventBus();
  const state = createBleState();
  let currentProfile = getBleProfile(profileId);
  let deviceFoundHandler = null;
  let adapterStateHandler = null;
  let connectionStateHandler = null;
  let characteristicValueHandler = null;

  // 返回状态快照，避免调用方直接改写内部状态对象。
  function snapshotState() {
    return {
      ...state,
      auth: { ...state.auth },
      deviceMap: { ...state.deviceMap },
      characteristics: { ...state.characteristics },
    };
  }

  // 统一 patch 状态并广播 state:change，保证 UI 状态来源单一。
  function patchState(partialState) {
    Object.assign(state, partialState);
    eventBus.emit('state:change', snapshotState());
  }

  function setStage(stage) {
    patchState({ stage });
  }

  function setProfile(nextProfileId) {
    currentProfile = getBleProfile(nextProfileId);
    patchState({ profileId: currentProfile.id });
  }

  function getProfile() {
    return currentProfile;
  }

  function setAuthState(partialAuth = {}) {
    patchState({
      auth: {
        ...state.auth,
        ...partialAuth,
      },
    });
  }

  function emit(eventName, payload) {
    eventBus.emit(eventName, payload);
  }

  function emitError(error) {
    const normalized = normalizeBleError(error);
    patchState({ lastError: normalized });
    eventBus.emit('error', normalized);
    return normalized;
  }

  /** 打开蓝牙适配器，成功后标记可用并进入 ADAPTER_OPENED 阶段。 */
  async function openAdapter() {
    try {
      await promisifyUniApi('openBluetoothAdapter');
      patchState({ available: true });
      setStage(BLE_STAGE.ADAPTER_OPENED);
      return true;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 关闭蓝牙适配器并重置全部运行时状态。 */
  async function closeAdapter() {
    try {
      await promisifyUniApi('closeBluetoothAdapter');
    } catch (error) {
      logger.warn('[BLE] close adapter failed', error);
    }

    // 重置原生 handler 引用，以便 openAdapter 后 init() 可重新注册
    adapterStateHandler = null;
    connectionStateHandler = null;
    characteristicValueHandler = null;
    deviceFoundHandler = null;

    patchState({
      stage: BLE_STAGE.IDLE,
      available: false,
      discovering: false,
      connected: false,
      deviceId: '',
      serviceId: '',
      characteristics: {},
    });
  }

  /** 读取当前适配器状态（可用/搜索中），同步到内部状态。 */
  async function getAdapterState() {
    try {
      const result = await promisifyUniApi('getBluetoothAdapterState');
      patchState({
        available: Boolean(result.available),
        discovering: Boolean(result.discovering),
      });
      return result;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 注册适配器状态变更监听，蓝牙关闭时自动切换到 DISCONNECTED。 */
  function watchAdapterState() {
    if (adapterStateHandler) {
      return;
    }

    adapterStateHandler = (result) => {
      patchState({
        available: Boolean(result.available),
        discovering: Boolean(result.discovering),
      });
      eventBus.emit('adapter:state', result);

      if (!result.available) {
        setStage(BLE_STAGE.DISCONNECTED);
      }
    };

    uni.onBluetoothAdapterStateChange(adapterStateHandler);
  }

  /** 移除适配器状态变更监听。 */
  function unwatchAdapterState() {
    if (!adapterStateHandler) {
      return;
    }

    if (uni.offBluetoothAdapterStateChange) {
      uni.offBluetoothAdapterStateChange(adapterStateHandler);
    }

    adapterStateHandler = null;
  }

  /**
   * 启动设备扫描。
   * services 传入时会做 UUID 标准化，用于只扫描目标服务设备。
   */
  async function startDiscovery(params = {}) {
    const {
      services = [],
      allowDuplicatesKey = true,
      interval = 0,
      powerLevel = 'high',
    } = params;

    try {
      if (!state.available) {
        await openAdapter();
      }

      const options = {
        allowDuplicatesKey,
        interval,
      };

      if (services.length) {
        options.services = services.map((uuid) => toFullUuid(uuid) || uuid);
      }

      if (powerLevel) {
        options.powerLevel = powerLevel;
      }

      await promisifyUniApi('startBluetoothDevicesDiscovery', options);
      patchState({ discovering: true, deviceMap: {} });
      setStage(BLE_STAGE.DISCOVERING);
      return true;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 停止设备扫描。 */
  async function stopDiscovery() {
    try {
      await promisifyUniApi('stopBluetoothDevicesDiscovery');
    } catch (error) {
      logger.warn('[BLE] stop discovery failed', error);
    }

    patchState({ discovering: false });
  }

  /** 注册设备发现监听，按 deviceId 去重合并后广播 device:found。 */
  function watchDeviceFound() {
    if (deviceFoundHandler) {
      return;
    }

    deviceFoundHandler = (result) => {
      const list = Array.isArray(result.devices) ? result.devices : [result];
      const nextMap = { ...state.deviceMap };

      // 基于 deviceId 做去重与增量更新，避免列表无限叠加。
      list.forEach((device) => {
        if (!device || !device.deviceId) {
          return;
        }

        const previous = nextMap[device.deviceId] || {};
        nextMap[device.deviceId] = {
          ...previous,
          ...device,
          showName:
            device.name ||
            device.localName ||
            previous.showName ||
            '未命名设备',
        };
      });

      patchState({ deviceMap: nextMap });
      eventBus.emit('device:found', Object.values(nextMap));
    };

    uni.onBluetoothDeviceFound(deviceFoundHandler);
  }

  /** 移除设备发现监听。 */
  function unwatchDeviceFound() {
    if (!deviceFoundHandler) {
      return;
    }

    if (uni.offBluetoothDeviceFound) {
      uni.offBluetoothDeviceFound(deviceFoundHandler);
    }

    deviceFoundHandler = null;
  }

  /**
   * 建立BLE连接。
   * @param {string} deviceId 设备ID
   * @param {object} options
   * @param {number} options.timeout 连接超时(ms)，默认15000
   * @param {boolean} options.autoReconnect 是否自动重试，默认跟随初始化配置
   */
  async function connect(deviceId, options = {}) {
    if (!deviceId) {
      throw emitError(createBleError(10013, 'deviceId 不能为空'));
    }

    const { timeout = 15000, autoReconnect = reconnect.enabled } = options;

    const runConnect = async () => {
      setStage(BLE_STAGE.CONNECTING);
      await promisifyUniApi('createBLEConnection', { deviceId, timeout });
      patchState({ connected: true, deviceId });
      setStage(BLE_STAGE.CONNECTED);
      return true;
    };

    try {
      if (!autoReconnect) {
        return await runConnect();
      }

      return await runWithRetry(runConnect, {
        retries: reconnect.retries,
        delay: reconnect.delay,
        shouldRetry: (error) => {
          const normalized = normalizeBleError(error);
          return [10003, 10006, 10012].includes(normalized.code);
        },
      });
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 断开BLE连接并重置连接相关状态。 */
  async function disconnect(deviceId = state.deviceId) {
    if (!deviceId) {
      return;
    }

    try {
      await promisifyUniApi('closeBLEConnection', { deviceId });
    } catch (error) {
      logger.warn('[BLE] close connection failed', error);
    }

    patchState({
      connected: false,
      deviceId: '',
      serviceId: '',
      characteristics: {},
    });
    setStage(BLE_STAGE.DISCONNECTED);
  }

  /** 注册连接状态变更监听，断开时自动切换到 DISCONNECTED。 */
  function watchConnectionChange() {
    if (connectionStateHandler) {
      return;
    }

    connectionStateHandler = (result) => {
      if (state.deviceId && result.deviceId !== state.deviceId) {
        return;
      }

      patchState({ connected: Boolean(result.connected) });
      eventBus.emit('connection:change', result);

      if (!result.connected) {
        setStage(BLE_STAGE.DISCONNECTED);
      }
    };

    uni.onBLEConnectionStateChange(connectionStateHandler);
  }

  /** 移除连接状态变更监听。 */
  function unwatchConnectionChange() {
    if (!connectionStateHandler) {
      return;
    }

    if (uni.offBLEConnectionStateChange) {
      uni.offBLEConnectionStateChange(connectionStateHandler);
    }

    connectionStateHandler = null;
  }

  /** 获取候选服务UUID列表：profile主服务 + 兼容固件的 00F4/F400/FFF4。 */
  function getServiceCandidates() {
    const profileService = currentProfile?.uuids?.service;
    const candidates = [
      profileService,
      toFullUuid('00F4'),
      toFullUuid('F400'),
      toFullUuid('FFF4'),
    ];

    return candidates.filter(Boolean);
  }

  /**
   * 发现并锁定目标服务。
   * 文档主服务为 0x00F4，同时兼容部分固件 0xF400 / 0xFFF4。
   */
  async function discoverServices(deviceId = state.deviceId) {
    if (!deviceId) {
      throw emitError(createBleError(10013, 'discoverServices 缺少 deviceId'));
    }

    try {
      const result = await promisifyUniApi('getBLEDeviceServices', {
        deviceId,
      });
      const services = result.services || [];
      const candidates = getServiceCandidates();
      const targetService = services.find((service) =>
        candidates.some((uuid) => uuidEquals(service.uuid, uuid)),
      );

      if (!targetService) {
        throw createBleError(10004, '设备未暴露目标服务(00F4/F400/FFF4)');
      }

      patchState({ serviceId: targetService.uuid });
      setStage(BLE_STAGE.SERVICE_DISCOVERED);
      return {
        services,
        targetService,
      };
    } catch (error) {
      throw emitError(error);
    }
  }

  /**
   * 发现特征值并按业务用途缓存（wifi/key/cmd/msg/state/radar）。
   * @param {object} options 可选覆盖 deviceId/serviceId
   * @returns {object} characteristicMap 各业务特征 + all 全量列表
   */
  async function discoverCharacteristics(options = {}) {
    const deviceId = options.deviceId || state.deviceId;
    const serviceId = options.serviceId || state.serviceId;

    if (!deviceId || !serviceId) {
      throw emitError(
        createBleError(
          10013,
          'discoverCharacteristics 缺少 deviceId/serviceId',
        ),
      );
    }

    try {
      const result = await promisifyUniApi('getBLEDeviceCharacteristics', {
        deviceId,
        serviceId,
      });
      const list = result.characteristics || [];
      const profile = getProfile();

      // 缓存业务侧常用特征，减少后续每次操作时的查找成本。
      const characteristicMap = {
        wifi:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.wifi)) ||
          null,
        key:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.key)) || null,
        cmd:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.cmd)) || null,
        msg:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.msg)) || null,
        state:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.state)) ||
          null,
        radar:
          list.find((item) => uuidEquals(item.uuid, profile.uuids.radar)) ||
          null,
        all: list,
      };

      patchState({ characteristics: characteristicMap });
      return characteristicMap;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 读取指定特征值（触发 onBLECharacteristicValueChange 回调）。 */
  async function readCharacteristic(characteristicId, options = {}) {
    const deviceId = options.deviceId || state.deviceId;
    const serviceId = options.serviceId || state.serviceId;

    if (!deviceId || !serviceId || !characteristicId) {
      throw emitError(createBleError(10013, 'readCharacteristic 参数缺失'));
    }

    try {
      await promisifyUniApi('readBLECharacteristicValue', {
        deviceId,
        serviceId,
        characteristicId,
      });
      return true;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 向指定特征值写入数据，自动将输入转为 ArrayBuffer。 */
  async function writeCharacteristic(characteristicId, value, options = {}) {
    const deviceId = options.deviceId || state.deviceId;
    const serviceId = options.serviceId || state.serviceId;

    if (!deviceId || !serviceId || !characteristicId) {
      throw emitError(createBleError(10013, 'writeCharacteristic 参数缺失'));
    }

    // 取特征 properties，用于诊断写入类型是否匹配，并按需指定 writeType
    const chars = state.characteristics || {};
    const matched = Object.values(chars).find(
      (item) => item && uuidEquals(item.uuid, characteristicId),
    );
    const props = matched?.properties || {};
    const supportsWrite = Boolean(props.write);
    const supportsWriteNoResp = Boolean(props.writeWithoutResponse);
    // 默认优先有响应写入（可靠）；仅当不支持有响应时退化为无响应写入
    const writeType =
      options.writeType ||
      (supportsWrite
        ? 'write'
        : supportsWriteNoResp
          ? 'writeWithoutResponse'
          : undefined);

    try {
      console.debug('[BLE][WRITE]', characteristicId, {
        writeType,
        supportsWrite,
        supportsWriteNoResp,
        valueLen: value?.length
      });
      const params = {
        deviceId,
        serviceId,
        characteristicId,
        value: uint8ArrayToArrayBuffer(toUint8Array(value)),
      };
      if (writeType) {
        params.writeType = writeType;
      }
      await promisifyUniApi('writeBLECharacteristicValue', params);
      return true;
    } catch (error) {
      throw emitError(error);
    }
  }

  /** 订阅/取消订阅指定特征值的通知。 */
  async function notifyCharacteristic(
    characteristicId,
    stateFlag = true,
    options = {},
  ) {
    const deviceId = options.deviceId || state.deviceId;
    const serviceId = options.serviceId || state.serviceId;

    if (!deviceId || !serviceId || !characteristicId) {
      throw emitError(createBleError(10013, 'notifyCharacteristic 参数缺失'));
    }

    try {
      await promisifyUniApi('notifyBLECharacteristicValueChange', {
        deviceId,
        serviceId,
        characteristicId,
        state: Boolean(stateFlag),
      });
      return true;
    } catch (error) {
      throw emitError(error);
    }
  }

  function watchCharacteristicValue() {
    if (characteristicValueHandler) {
      return;
    }

    // 统一转为 Uint8Array，简化上层解析逻辑。
    characteristicValueHandler = (result) => {
      const value = toUint8Array(result.value);
      // 原始 trace：定位 notify 是否投递时，确认每个特征值变更的来源与内容
      try {
        const hex = Array.from(value)
          .map((b) => b.toString(16).padStart(2, '0'))
          .join(' ');
        console.debug('[BLE][RAW]', result.characteristicId, 'len=', value.length, 'hex=', hex);
      } catch (e) {
      }
      eventBus.emit('characteristic:value', {
        ...result,
        value,
      });
    };

    uni.onBLECharacteristicValueChange(characteristicValueHandler);
  }

  /** 移除特征值变更监听。 */
  function unwatchCharacteristicValue() {
    if (!characteristicValueHandler) {
      return;
    }

    if (uni.offBLECharacteristicValueChange) {
      uni.offBLECharacteristicValueChange(characteristicValueHandler);
    }

    characteristicValueHandler = null;
  }

  /** 返回已发现设备列表。 */
  function listDiscoveredDevices() {
    return Object.values(state.deviceMap);
  }

  /** 从已发现设备中，按广播服务UUID匹配并返回第一个设备。 */
  function pickDeviceByService(serviceUuid = currentProfile.uuids.service) {
    const list = listDiscoveredDevices();

    return (
      list.find((device) =>
        uuidInList(serviceUuid, device.advertisServiceUUIDs || []),
      ) || null
    );
  }

  async function cleanup() {
    // 清理顺序：先停扫描与连接，再移除监听，最后关闭适配器。
    await stopDiscovery();
    await disconnect();

    unwatchDeviceFound();
    unwatchAdapterState();
    unwatchConnectionChange();
    unwatchCharacteristicValue();

    await closeAdapter();
    eventBus.clear();
  }

  return {
    openAdapter,
    closeAdapter,
    getAdapterState,
    watchAdapterState,
    unwatchAdapterState,
    startDiscovery,
    stopDiscovery,
    watchDeviceFound,
    unwatchDeviceFound,
    connect,
    disconnect,
    watchConnectionChange,
    unwatchConnectionChange,
    discoverServices,
    discoverCharacteristics,
    readCharacteristic,
    writeCharacteristic,
    notifyCharacteristic,
    watchCharacteristicValue,
    unwatchCharacteristicValue,
    pickDeviceByService,
    listDiscoveredDevices,
    getState: snapshotState,
    setStage,
    setProfile,
    getProfile,
    setAuthState,
    emit,
    on: eventBus.on,
    once: eventBus.once,
    cleanup,
    getBleErrorText,
  };
}