import { SerialPort } from 'serialport';
import { ReadlineParser } from '@serialport/parser-readline';
import { Submit } from 'node-pdu';
import EventEmitter from 'events';
import fs from 'fs';
import path from 'path';
import logger from './logger.js';

class ModemManager extends EventEmitter {
  constructor(config, mobileDataConfig = {}) {
    super();
    this.config = config;
    this.mobileDataConfig = {
      cid: this.normalizeMobileDataCid(mobileDataConfig.cid)
    };
    this.port = null;
    this.parser = null;
    this.ready = false;
    this.modelInfo = {
      manufacturer: '未知',
      model: '未知',
      version: '未知'
    };
    this.mobileData = {
      cid: this.mobileDataConfig.cid,
      desiredEnabled: false,
      enabled: false,
      targetEnabled: false,
      anyActive: false,
      status: 'disabled',
      mode: 'unknown',
      contexts: [],
      lastCheckedAt: null,
      error: ''
    };
  }

  /**
   * 打开串口并初始化模组
   */
  async open() {
    try {
      const portPath = await this.resolvePortPath();

      logger.info(`准备打开串口: ${portPath} (${this.config.baudRate})`);

      // 打开串口
      this.port = new SerialPort({
        path: portPath,
        baudRate: this.config.baudRate,
        dataBits: 8,
        stopBits: 1,
        parity: 'none',
        autoOpen: false
      });

      // 设置行解析器
      this.parser = this.port.pipe(new ReadlineParser({ delimiter: '\r\n' }));

      // 监听串口事件
      this.port.on('error', (err) => {
        logger.error('串口错误:', err);
        this.emit('error', err);
      });

      this.port.on('close', () => {
        logger.warn('串口已关闭');
        this.ready = false;
        this.emit('close');
      });

      // 监听URC（主动上报）消息
      this.setupURCListener();

      // 等待串口打开
      await new Promise((resolve, reject) => {
        this.port.open((err) => {
          if (err) {
            reject(err);
            return;
          }

          resolve();
        });
      });
      this.config.path = portPath;
      logger.info(`串口已打开: ${portPath}`);

      // 初始化模组
      await this.init();

    } catch (err) {
      logger.error('打开串口失败:', err);
      throw err;
    }
  }

  /**
   * 自动探测能响应AT命令的串口；可通过 serial.autoDetect=false 关闭。
   */
  async resolvePortPath() {
    const manualPath = this.normalizePortPath(this.config.path);

    if (this.config.autoDetect === false) {
      return manualPath;
    }

    const candidates = await this.getSerialProbeCandidates(manualPath);
    if (candidates.length === 0) {
      throw new Error('未发现可探测的串口设备');
    }

    logger.info(`开始自动探测AT串口: ${this.formatProbeCandidateList(candidates)}`);

    const timeout = this.config.probeTimeout || 1200;
    const failures = [];

    for (const candidate of candidates) {
      const result = await this.probeATPort(candidate.path, timeout);
      if (result.ok) {
        logger.info(`✓ 自动探测到AT串口: ${candidate.path}`);
        return candidate.path;
      }

      failures.push(result);
      logger.debug(`串口探测未通过: ${candidate.path} (${this.formatProbeFailure(result)})`);
    }

    const summary = failures
      .slice(0, 8)
      .map(item => `${item.path}: ${this.formatProbeFailure(item)}`)
      .join('; ');

    throw new Error(`未找到可响应AT的串口，已探测 ${failures.length} 个端口${summary ? ` (${summary})` : ''}`);
  }

  normalizePortPath(portPath) {
    if (!portPath) {
      return null;
    }

    const normalized = String(portPath).trim();
    if (process.platform === 'win32' && /^\d+$/.test(normalized)) {
      return `COM${normalized}`;
    }

    return normalized;
  }

  async getSerialProbeCandidates(manualPath) {
    const candidates = new Map();

    const addCandidate = (path, portInfo = {}, manual = false) => {
      if (!path) {
        return;
      }

      const candidate = candidates.get(path) || {
        path,
        portInfo: {},
        manual: false
      };

      candidate.portInfo = { ...candidate.portInfo, ...portInfo };
      candidate.manual = candidate.manual || manual;
      candidate.metadata = this.getPortMetadata(path, candidate.portInfo);
      candidate.priority = this.getProbeCandidatePriority(path, candidate.portInfo, candidate.manual, candidate.metadata);
      candidates.set(path, candidate);
    };

    let ports = [];
    try {
      ports = await SerialPort.list();
    } catch (err) {
      logger.warn(`读取系统串口列表失败: ${err.message}`);
    }

    for (const portInfo of ports) {
      addCandidate(this.normalizePortPath(portInfo.path), portInfo);
    }

    addCandidate(manualPath, {}, true);

    return Array.from(candidates.values())
      .sort((a, b) => a.priority - b.priority || a.path.localeCompare(b.path));
  }

  getProbeCandidatePriority(portPath, portInfo, manual, metadata) {
    const interfaceName = (metadata.interfaceName || '').toLowerCase();
    const interfaceNumber = metadata.interfaceNumber;

    if (interfaceName.includes('at interface') || /\bat\b/.test(interfaceName)) {
      return interfaceNumber === null ? 0 : interfaceNumber;
    }

    if (portInfo.vendorId === '2ecc' && portInfo.productId === '3012') {
      // ML307A: if02/if03 are AT interfaces; if04 is Diag; if00/if01 are RNDIS.
      if (interfaceNumber === 2 || interfaceNumber === 3) {
        return interfaceNumber;
      }

      return 40 + (interfaceNumber ?? 9);
    }

    if (interfaceName.includes('diag')) {
      return 40;
    }

    if (interfaceName.includes('rndis') || interfaceName.includes('network')) {
      return 50;
    }

    if (portInfo.vendorId || portInfo.productId || /usb|acm/i.test(portPath)) {
      return 20;
    }

    if (/^COM\d+$/i.test(portPath)) {
      return 30;
    }

    if (manual) {
      return 35;
    }

    return 80;
  }

  getPortMetadata(portPath, portInfo) {
    const metadata = {
      interfaceName: '',
      interfaceNumber: this.parseUSBInterfaceNumber(portInfo.pnpId)
    };

    if (process.platform !== 'linux') {
      return metadata;
    }

    const ttyName = this.getTTYName(portPath);
    if (!ttyName) {
      return metadata;
    }

    try {
      const ttyDevicePath = fs.realpathSync(`/sys/class/tty/${ttyName}/device`);
      const usbInterfacePath = path.dirname(ttyDevicePath);
      metadata.interfaceName = this.readFirstLine(path.join(usbInterfacePath, 'interface')) || '';

      const sysfsInterfaceNumber = this.readFirstLine(path.join(usbInterfacePath, 'bInterfaceNumber'));
      if (sysfsInterfaceNumber) {
        metadata.interfaceNumber = Number.parseInt(sysfsInterfaceNumber, 16);
      }
    } catch (err) {
      // Some platforms expose serial ports without Linux USB sysfs metadata.
    }

    return metadata;
  }

  parseUSBInterfaceNumber(pnpId) {
    const match = String(pnpId || '').match(/if(\d+)/i);
    if (!match) {
      return null;
    }

    return Number.parseInt(match[1], 10);
  }

  getTTYName(portPath) {
    try {
      return path.basename(fs.realpathSync(portPath));
    } catch (err) {
      return path.basename(portPath);
    }
  }

  readFirstLine(filePath) {
    try {
      return fs.readFileSync(filePath, 'utf8').split('\n')[0].trim();
    } catch (err) {
      return '';
    }
  }

  formatProbeCandidateList(candidates) {
    const paths = candidates.map(item => item.path);
    if (paths.length <= 12) {
      return paths.join(', ');
    }

    return `${paths.slice(0, 12).join(', ')} ... 共${paths.length}个`;
  }

  async probeATPort(path, timeout = 1200) {
    return new Promise((resolve) => {
      let buffer = '';
      let settled = false;

      const port = new SerialPort({
        path,
        baudRate: this.config.baudRate,
        dataBits: 8,
        stopBits: 1,
        parity: 'none',
        autoOpen: false
      });

      const done = (result) => {
        if (settled) {
          return;
        }

        settled = true;
        clearTimeout(timer);
        port.removeListener('data', onData);
        port.removeListener('error', onError);

        const finalResult = {
          path,
          ...result,
          response: buffer
        };

        if (port.isOpen) {
          port.close(() => resolve(finalResult));
          return;
        }

        resolve(finalResult);
      };

      const onData = (data) => {
        buffer += data.toString('utf8');
        if (buffer.includes('OK')) {
          done({ ok: true, reason: 'ok' });
        } else if (buffer.includes('ERROR')) {
          done({ ok: false, reason: 'error_response' });
        }
      };

      const onError = (err) => {
        done({ ok: false, reason: 'error', error: err.message });
      };

      const timer = setTimeout(() => {
        done({ ok: false, reason: 'timeout' });
      }, timeout);

      port.on('data', onData);
      port.on('error', onError);

      port.open((err) => {
        if (err) {
          done({ ok: false, reason: 'open_error', error: err.message });
          return;
        }

        port.write('AT\r\n', (writeErr) => {
          if (writeErr) {
            done({ ok: false, reason: 'write_error', error: writeErr.message });
          }
        });
      });
    });
  }

  formatProbeFailure(result) {
    if (result.error) {
      return `${result.reason}: ${result.error}`;
    }

    return result.reason;
  }

  normalizeMobileDataCid(value) {
    const cid = Number.parseInt(value, 10);
    if (Number.isInteger(cid) && cid > 0 && cid <= 15 && cid !== 8) {
      return cid;
    }

    return 1;
  }

  getMobileDataMode() {
    return this.isML307Family() ? 'mipcall' : 'cgact';
  }

  getMobileDataCommand(mode = this.getMobileDataMode(), enabled = false, cid = this.mobileDataConfig.cid) {
    if (mode === 'mipcall') {
      return `AT+MIPCALL=${enabled ? 1 : 0},${cid}`;
    }

    return `AT+CGACT=${enabled ? 1 : 0},${cid}`;
  }

  getMobileDataStatusCommand(mode = this.getMobileDataMode()) {
    return mode === 'mipcall' ? 'AT+MIPCALL?' : 'AT+CGACT?';
  }

  getCachedMobileDataStatus() {
    return {
      ...this.mobileData,
      contexts: this.mobileData.contexts.map(item => ({ ...item }))
    };
  }

  async getMobileDataStatus() {
    const mode = this.getMobileDataMode();
    const command = this.getMobileDataStatusCommand(mode);

    try {
      const resp = await this.sendATCommand(command, 5000);
      const status = this.parseMobileDataStatusResponse(resp, mode);
      this.updateMobileDataStatus(status);
      return this.getCachedMobileDataStatus();
    } catch (err) {
      logger.warn(`查询移动数据状态失败: ${err.message}`);
      this.updateMobileDataStatus({
        mode,
        cid: this.mobileDataConfig.cid,
        status: 'unknown',
        enabled: false,
        targetEnabled: false,
        anyActive: false,
        contexts: [],
        error: err.message
      });
      return this.getCachedMobileDataStatus();
    }
  }

  parseMobileDataStatusResponse(resp, mode) {
    const contexts = [];
    const lines = resp.split('\n').map(line => line.trim()).filter(Boolean);

    for (const line of lines) {
      const payload = this.extractMobileDataPayload(line, mode);
      if (!payload) {
        continue;
      }

      const match = payload.match(/^(\d+)\s*,\s*(\d+)(.*)$/);
      if (!match) {
        continue;
      }

      const cid = Number.parseInt(match[1], 10);
      const state = Number.parseInt(match[2], 10);
      const addresses = [...match[3].matchAll(/"([^"]+)"/g)].map(item => item[1]).filter(Boolean);

      contexts.push({
        cid,
        active: state === 1,
        state,
        addresses
      });
    }

    const target = contexts.find(item => item.cid === this.mobileDataConfig.cid);
    const anyActive = contexts.some(item => item.active);
    const targetEnabled = target ? target.active : false;

    return {
      mode,
      cid: this.mobileDataConfig.cid,
      enabled: anyActive,
      targetEnabled,
      anyActive,
      status: anyActive ? 'enabled' : 'disabled',
      contexts,
      error: ''
    };
  }

  extractMobileDataPayload(line, mode) {
    if (mode === 'mipcall') {
      if (line.startsWith('+MIPCALL:')) {
        return line.slice('+MIPCALL:'.length).trim();
      }

      if (/^\d+\s*,\s*\d+/.test(line)) {
        return line;
      }
    }

    if (line.startsWith('+CGACT:')) {
      return line.slice('+CGACT:'.length).trim();
    }

    return '';
  }

  updateMobileDataStatus(status) {
    this.mobileData = {
      ...this.mobileData,
      ...status,
      cid: this.mobileDataConfig.cid,
      lastCheckedAt: new Date().toISOString(),
      contexts: Array.isArray(status.contexts) ? status.contexts : []
    };
  }

  getMobileDataTargetCids(status) {
    const cids = new Set([this.mobileDataConfig.cid]);
    for (const context of status.contexts || []) {
      if (context.active && context.cid !== 8) {
        cids.add(context.cid);
      }
    }

    return [...cids].filter(cid => this.normalizeMobileDataCid(cid) === cid);
  }

  async setMobileDataEnabled(enabled, options = {}) {
    this.mobileData.desiredEnabled = Boolean(enabled);
    if (enabled) {
      return await this.enableMobileData(options);
    }

    return await this.disableMobileData(options);
  }

  async enableMobileData(options = {}) {
    const mode = this.getMobileDataMode();
    const cid = this.mobileDataConfig.cid;
    const command = this.getMobileDataCommand(mode, true, cid);
    const label = mode === 'mipcall' ? '开启移动数据拨号' : '激活PDP数据连接';

    logger.warn(`准备开启移动数据(CID ${cid})，可能产生流量费用`);
    const resp = await this.sendATWithRetry(command, {
      timeout: 30000,
      retries: 1,
      label,
      required: false
    });

    const status = await this.waitForMobileDataState(true, options.timeout || 20000);
    if (!resp || !status.anyActive) {
      throw new Error('移动数据开启失败，未检测到已激活的数据连接');
    }

    logger.info(`✓ 已开启移动数据(CID ${cid})`);
    return status;
  }

  async disableMobileData(options = {}) {
    const mode = this.getMobileDataMode();
    const before = await this.getMobileDataStatus();
    const cids = this.getMobileDataTargetCids(before);
    const label = mode === 'mipcall' ? '关闭移动数据拨号' : '停用PDP数据连接';
    let commandSucceeded = false;

    logger.info(`${options.reason || '手动操作'}: 关闭移动数据，避免流量消耗`);

    for (const cid of cids) {
      const command = this.getMobileDataCommand(mode, false, cid);
      const resp = await this.sendATWithRetry(command, {
        timeout: 8000,
        retries: 1,
        label: `${label}(CID ${cid})`,
        required: false
      });

      commandSucceeded = commandSucceeded || Boolean(resp);
    }

    const status = await this.waitForMobileDataState(false, options.timeout || 8000);
    if (status.anyActive) {
      const message = `移动数据关闭后仍检测到活动连接: ${this.formatMobileDataContexts(status.contexts)}`;
      if (options.required === false) {
        logger.warn(message);
        return status;
      }

      throw new Error(message);
    }

    if (status.status === 'unknown') {
      const message = commandSucceeded ? '移动数据关闭命令已发送，但状态未确认' : '移动数据关闭命令未确认成功';
      if (options.required === false) {
        logger.warn(message);
        return status;
      }

      throw new Error(message);
    }

    if (!commandSucceeded && before.status === 'unknown' && options.required !== false) {
      throw new Error('移动数据关闭命令未确认成功');
    }

    logger.info('✓ 移动数据已关闭');
    return status;
  }

  async forceMobileDataOff(stage) {
    this.mobileData.desiredEnabled = false;
    try {
      return await this.disableMobileData({
        reason: stage,
        required: false,
        timeout: 5000
      });
    } catch (err) {
      logger.warn(`${stage}: 移动数据关闭未确认: ${err.message}`);
      return this.getCachedMobileDataStatus();
    }
  }

  async waitForMobileDataState(enabled, timeout = 10000) {
    const startedAt = Date.now();
    let status = await this.getMobileDataStatus();

    while (status.status !== 'unknown' && status.anyActive !== enabled && Date.now() - startedAt < timeout) {
      await this.sleep(1000);
      status = await this.getMobileDataStatus();
    }

    return status;
  }

  formatMobileDataContexts(contexts = []) {
    const active = contexts
      .filter(item => item.active)
      .map(item => `CID ${item.cid}`)
      .join(', ');

    return active || '无';
  }

  /**
   * 设置URC监听器
   */
  setupURCListener() {
    let waitingPDU = false;

    this.parser.on('data', (line) => {
      line = line.trim();

      // 调试输出
      if (line.length > 0 && !line.startsWith('AT')) {
        logger.debug(`<< ${line}`);
      }

      // 检测短信URC
      if (line.startsWith('+CMT:')) {
        logger.info('检测到短信URC，等待PDU数据...');
        waitingPDU = true;
      } else if (waitingPDU && this.isHexString(line)) {
        logger.info('收到PDU数据');
        waitingPDU = false;
        this.emit('sms', line); // 发射短信事件
      } else if (waitingPDU && line.length === 0) {
        // 跳过空行
      } else if (waitingPDU) {
        // 收到非PDU数据，返回等待状态
        waitingPDU = false;
      }

      // 检测网络注册状态变化
      if (line.startsWith('+CEREG:')) {
        this.emit('cereg', line);
      }
    });
  }

  /**
   * 检查是否为十六进制字符串
   */
  isHexString(str) {
    return /^[0-9A-Fa-f]+$/.test(str);
  }

  /**
   * 发送AT命令并等待响应
   */
  async sendATCommand(cmd, timeout = 2000) {
    return new Promise((resolve, reject) => {
      let buffer = '';
      const timer = setTimeout(() => {
        this.parser.removeListener('data', handler);
        reject(new Error(`AT命令超时: ${cmd}`));
      }, timeout);

      const handler = (line) => {
        buffer += line + '\n';
        if (line.includes('OK') || line.includes('ERROR')) {
          clearTimeout(timer);
          this.parser.removeListener('data', handler);
          resolve(buffer);
        }
      };

      this.parser.on('data', handler);

      logger.debug(`>> ${cmd}`);
      this.port.write(cmd + '\r\n');
    });
  }

  /**
   * 发送AT命令并等待OK
   */
  async sendATandWaitOK(cmd, timeout = 2000) {
    try {
      const resp = await this.sendATCommand(cmd, timeout);
      return resp.includes('OK');
    } catch (err) {
      return false;
    }
  }

  /**
   * 发送AT命令，失败时打印模组原始响应，便于排查型号差异
   */
  async sendATWithRetry(cmd, options = {}) {
    const {
      timeout = 2000,
      retries = 3,
      retryDelay = 1000,
      label = cmd,
      required = true
    } = options;

    for (let attempt = 1; attempt <= retries; attempt++) {
      try {
        const resp = await this.sendATCommand(cmd, timeout);
        if (resp.includes('OK')) {
          return resp;
        }

        logger.warn(`${label}失败(${attempt}/${retries}): ${this.formatATResponse(resp)}`);
      } catch (err) {
        logger.warn(`${label}失败(${attempt}/${retries}): ${err.message}`);
      }

      if (attempt < retries && retryDelay > 0) {
        await this.sleep(retryDelay);
      }
    }

    if (required) {
      throw new Error(`${label}失败`);
    }

    return null;
  }

  /**
   * 压缩AT响应，避免日志跨太多行
   */
  formatATResponse(resp) {
    return resp
      .split('\n')
      .map(line => line.trim())
      .filter(Boolean)
      .join(' | ');
  }

  /**
   * 初始化模组
   */
  async init() {
    logger.info('开始初始化4G模组...');

    // 1. AT握手
    let retries = 0;
    while (!(await this.sendATandWaitOK('AT', 1000)) && retries < 10) {
      logger.warn('AT未响应，重试...');
      retries++;
      await this.sleep(1000);
    }
    if (retries >= 10) {
      throw new Error('模组AT握手失败');
    }
    logger.info('✓ 模组AT响应正常');

    // 2. 查询模组信息
    try {
      const resp = await this.sendATCommand('ATI', 2000);
      const lines = resp.split('\n').map(l => l.trim()).filter(l => l && l !== 'ATI' && l !== 'OK');
      if (lines.length >= 3) {
        this.modelInfo.manufacturer = lines[0];
        this.modelInfo.model = lines[1];
        this.modelInfo.version = lines[2];
        logger.info(`模组信息: ${this.modelInfo.manufacturer} ${this.modelInfo.model} ${this.modelInfo.version}`);
      }
    } catch (err) {
      logger.warn('查询模组信息失败');
    }

    // 3. 按ML307A文档先确认SIM卡和协议栈状态
    await this.waitSIMReady();
    await this.ensureFullFunctionality();

    // 4. 启动保护：先关闭移动数据拨号，再等待短信所需的网络注册。
    await this.forceMobileDataOff('启动保护(CFUN=1后)');

    // 5. 等待网络注册
    retries = 0;
    while (!(await this.waitCEREG()) && retries < 30) {
      logger.info('等待网络注册...');
      retries++;
      await this.sleep(2000);
    }
    if (retries < 30) {
      logger.info('✓ 网络已注册');
      this.ready = true;
    } else {
      logger.error('网络注册超时（无SIM卡或信号差）');
      this.ready = false;
    }

    // 6. 驻网后再关一次，防止模组自动拨号在驻网完成后重新拉起。
    await this.forceMobileDataOff('启动保护(驻网后)');

    // 7. 按文档配置短信功能，并启用本项目需要的PDU模式
    await this.configureSMS();

    logger.info('模组初始化完成');
    this.emit('ready');
  }

  /**
   * 等待SIM卡完成初始化
   */
  async waitSIMReady() {
    for (let attempt = 1; attempt <= 10; attempt++) {
      try {
        const resp = await this.sendATCommand('AT+CPIN?', 2000);
        if (resp.includes('+CPIN: READY')) {
          logger.info('✓ SIM卡已就绪');
          return;
        }

        logger.warn(`SIM卡未就绪(${attempt}/10): ${this.formatATResponse(resp)}`);
      } catch (err) {
        logger.warn(`查询SIM卡状态失败(${attempt}/10): ${err.message}`);
      }

      await this.sleep(1000);
    }

    throw new Error('SIM卡未就绪');
  }

  /**
   * 确保驻网前协议栈功能模式为CFUN=1
   */
  async ensureFullFunctionality() {
    const resp = await this.sendATCommand('AT+CFUN?', 2000);
    const match = resp.match(/\+CFUN:\s*(\d+)/);

    if (match && match[1] === '1') {
      logger.info('✓ 协议栈功能模式正常(CFUN=1)');
      return;
    }

    logger.warn(`当前CFUN状态不是1: ${this.formatATResponse(resp)}`);
    await this.sendATWithRetry('AT+CFUN=1', {
      timeout: 5000,
      retries: 3,
      label: '设置CFUN=1'
    });

    // 文档要求CFUN切换后等待模组完成协议栈恢复。
    await this.sleep(2000);
    logger.info('✓ 已设置协议栈功能模式(CFUN=1)');
  }

  /**
   * 按ML307A文档配置短信功能；项目接收逻辑依赖PDU模式下的+CMT上报。
   */
  async configureSMS() {
    if (this.modelInfo.version.includes('ML307A-DL')) {
      throw new Error('当前ML307A-DL型号不支持短信功能');
    }

    await this.sendATWithRetry('AT+CMGF=0', {
      timeout: 2000,
      retries: 3,
      label: '设置PDU模式'
    });
    logger.info('✓ PDU模式设置完成');

    await this.sendATWithRetry('AT+CNMI=2,2,0,2,0', {
      timeout: 2000,
      retries: 3,
      label: '设置CNMI短信上报'
    });
    logger.info('✓ CNMI参数设置完成');

    await this.sendATWithRetry('AT+CSCS="IRA"', {
      timeout: 2000,
      retries: 3,
      label: '设置短信字符集'
    });
    logger.info('✓ 短信字符集设置完成');

    await this.sendATWithRetry('AT+CSMP=33,167,0,0', {
      timeout: 2000,
      retries: 3,
      label: '设置短信发送参数'
    });
    logger.info('✓ 短信发送参数设置完成');
  }

  /**
   * 判断是否为ML307系列模组
   */
  isML307Family() {
    return this.modelInfo.model.startsWith('ML307') || this.modelInfo.version.startsWith('ML307');
  }

  /**
   * 检测网络注册状态
   */
  async waitCEREG() {
    try {
      const resp = await this.sendATCommand('AT+CEREG?', 2000);
      // +CEREG: 0,1 或 +CEREG: 0,5 表示已注册
      if (resp.includes('+CEREG:')) {
        if (resp.includes(',1') || resp.includes(',5')) {
          return true;
        }
      }
      return false;
    } catch (err) {
      return false;
    }
  }

  /**
   * 发送短信（PDU模式）
   */
  async sendSMS(phoneNumber, message) {
    logger.info(`准备发送短信到: ${phoneNumber}`);
    logger.info(`短信内容: ${message}`);

    try {
      // 编码PDU
      const submit = new Submit(phoneNumber, message);
      const parts = submit.getPartStrings();

      if (parts.length === 0) {
        throw new Error('PDU编码失败');
      }

      for (let i = 0; i < parts.length; i++) {
        const pduData = parts[i];
        const pduLength = this.getSubmitPduLength(pduData);

        logger.debug(`PDU分段: ${i + 1}/${parts.length}`);
        logger.debug(`PDU数据: ${pduData}`);
        logger.debug(`PDU长度: ${pduLength}`);

        const success = await this.sendPduPart(pduData, pduLength);
        if (!success) {
          logger.error(`✗ 短信分段发送失败: ${i + 1}/${parts.length}`);
          return false;
        }
      }

      logger.info('✓ 短信发送成功');
      return true;
    } catch (err) {
      logger.error('发送短信异常:', err);
      return false;
    }
  }

  /**
   * 计算AT+CMGS需要的TPDU长度，不包含SMSC长度字段和SMSC内容。
   */
  getSubmitPduLength(pduData) {
    const smscLength = parseInt(pduData.slice(0, 2), 16);
    const totalLength = pduData.length / 2;
    const submitLength = totalLength - smscLength - 1;

    if (!Number.isFinite(submitLength) || submitLength <= 0) {
      throw new Error(`PDU长度无效: ${pduData}`);
    }

    return submitLength;
  }

  /**
   * 发送单个PDU分段。
   */
  async sendPduPart(pduData, pduLength) {
    const cmgsCmd = `AT+CMGS=${pduLength}`;
    this.port.write(cmgsCmd + '\r\n');

    const gotPrompt = await this.waitForPrompt();
    if (!gotPrompt) {
      throw new Error('未收到>提示符');
    }

    logger.debug('收到>提示符，发送PDU数据...');
    this.port.write(pduData + String.fromCharCode(0x1A));

    return await this.waitForCMGSResult();
  }

  /**
   * 等待CMGS输入提示符。提示符通常没有行结束符，所以直接监听原始串口数据。
   */
  waitForPrompt(timeout = 5000) {
    return new Promise((resolve) => {
      let buffer = '';
      const timer = setTimeout(() => {
        this.port.removeListener('data', handler);
        resolve(false);
      }, timeout);

      const handler = (chunk) => {
        buffer += chunk.toString('utf8');
        if (buffer.includes('>')) {
          clearTimeout(timer);
          this.port.removeListener('data', handler);
          resolve(true);
        }
      };

      this.port.on('data', handler);
    });
  }

  /**
   * 等待短信发送结果。
   */
  waitForCMGSResult(timeout = 30000) {
    return new Promise((resolve) => {
      const timer = setTimeout(() => {
        this.parser.removeListener('data', handler);
        resolve(false);
      }, timeout);

      const handler = (line) => {
        if (line.includes('OK')) {
          clearTimeout(timer);
          this.parser.removeListener('data', handler);
          resolve(true);
        } else if (line.includes('ERROR')) {
          clearTimeout(timer);
          this.parser.removeListener('data', handler);
          resolve(false);
        }
      };

      this.parser.on('data', handler);
    });
  }

  /**
   * 查询信号强度
   */
  async getSignalQuality() {
    try {
      const resp = await this.sendATCommand('AT+CSQ', 2000);
      const match = resp.match(/\+CSQ:\s*(\d+),(\d+)/);
      if (match) {
        const rssi = parseInt(match[1]);
        const ber = parseInt(match[2]);
        let quality = '未知';
        if (rssi === 99) {
          quality = '未知或不可检测';
        } else if (rssi >= 20) {
          quality = '很好';
        } else if (rssi >= 15) {
          quality = '好';
        } else if (rssi >= 10) {
          quality = '一般';
        } else {
          quality = '弱';
        }
        return { rssi, ber, quality };
      }
      return null;
    } catch (err) {
      logger.error('查询信号强度失败:', err);
      return null;
    }
  }

  /**
   * 查询运营商
   */
  async getOperator() {
    try {
      const resp = await this.sendATCommand('AT+COPS?', 2000);
      const match = resp.match(/\+COPS:\s*\d+,\d+,"([^"]+)"/);
      if (match) {
        return match[1];
      }
      return '未知';
    } catch (err) {
      logger.error('查询运营商失败:', err);
      return '未知';
    }
  }

  /**
   * 查询ICCID
   */
  async getICCID() {
    try {
      const resp = await this.sendATCommand('AT+CCID', 2000);
      const match = resp.match(/\+CCID:\s*(\d+)/);
      if (match) {
        return match[1];
      }
      return null;
    } catch (err) {
      logger.error('查询ICCID失败:', err);
      return null;
    }
  }

  /**
   * 关闭串口
   */
  async close() {
    if (this.port && this.port.isOpen) {
      await new Promise((resolve) => {
        this.port.close(resolve);
      });
      logger.info('串口已关闭');
    }
  }

  /**
   * 辅助函数：延时
   */
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

export default ModemManager;