#!/usr/bin/env node

/**
 * JHM-2028 serial communication service.
 *
 * 当前项目正式运行入口是 `app.js`，通过 `tcp-service.js` 接收透传盒子的 TCP 数据。
 * 本文件保留为“串口直连调试参考脚本”，用于协议排查、串口联调和模拟数据验证。
 * 它不参与当前 TCP + MQTT 的生产主流程。
 *
 * Install:
 *   npm install serialport
 *
 * Serial mode:
 *   node jhm2028-service.js --port COM3 --baudRate 4800
 *
 * Simulation mode:
 *   node jhm2028-service.js --simulate "EE 55 01 00 00 01 72 74"
 */

let SerialPort;

const HEADER_1 = 0xEE;
const HEADER_2 = 0x55;
const FRAME_LENGTH = 8;
const DEFAULT_OPTIONS = {
  port: process.env.SERIAL_PORT || '',
  baudRate: Number(process.env.SERIAL_BAUD_RATE || 4800),
  dataBits: Number(process.env.SERIAL_DATA_BITS || 8),
  stopBits: Number(process.env.SERIAL_STOP_BITS || 1),
  parity: process.env.SERIAL_PARITY || 'none',
  raw: false,
  timestamp: true,
  simulate: '',
};

function loadSerialPort() {
  if (!SerialPort) {
    ({ SerialPort } = require('serialport'));
  }

  return SerialPort;
}

function parseArgs(argv) {
  const options = { ...DEFAULT_OPTIONS };

  for (let i = 2; i < argv.length; i += 1) {
    const arg = argv[i];
    const value = argv[i + 1];

    if (arg === '--port' && value) {
      options.port = value;
      i += 1;
    } else if (arg === '--baudRate' && value) {
      options.baudRate = Number(value);
      i += 1;
    } else if (arg === '--dataBits' && value) {
      options.dataBits = Number(value);
      i += 1;
    } else if (arg === '--stopBits' && value) {
      options.stopBits = Number(value);
      i += 1;
    } else if (arg === '--parity' && value) {
      options.parity = value;
      i += 1;
    } else if (arg === '--simulate' && value) {
      options.simulate = value;
      i += 1;
    } else if (arg === '--raw') {
      options.raw = true;
    } else if (arg === '--no-timestamp') {
      options.timestamp = false;
    } else if (arg === '--help' || arg === '-h') {
      printHelp();
      process.exit(0);
    }
  }

  return options;
}

function printHelp() {
  console.log(`JHM-2028 Node.js serial communication service

Usage:
  node jhm2028-service.js --port COM3 [options]
  node jhm2028-service.js --simulate "EE 55 01 00 00 01 72 74"

Options:
  --port <name>         Serial port name, e.g. COM3
  --baudRate <number>   Baud rate, default 4800
  --dataBits <number>   Data bits, default 8
  --stopBits <number>   Stop bits, default 1
  --parity <value>      none | even | odd, default none
  --raw                 Print raw incoming bytes in hex
  --no-timestamp        Omit timestamp in JSON output
  --simulate <hex>      Parse one or more hex bytes without opening a serial port
  --help, -h            Show this help

Protocol:
  Frame = EE 55 NN XX1 XX2 XX3 XX4 CY
  CY = (NN + XX1 + XX2 + XX3 + XX4) & 0xFF
`);
}

function toHex(value) {
  return `0x${value.toString(16).toUpperCase().padStart(2, '0')}`;
}

function bytesToHex(buffer) {
  return Array.from(buffer, toHex).join(' ');
}

function checksum(command, payload) {
  return (command + payload[0] + payload[1] + payload[2] + payload[3]) & 0xFF;
}

function uint32BE(bytes) {
  return ((bytes[0] * 0x1000000) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3]) >>> 0;
}

function uint16BE(high, low) {
  return ((high << 8) | low) >>> 0;
}

function decodePayload(command, payload) {
  switch (command) {
    case 0x01: {
      const raw = uint32BE(payload);
      return {
        name: 'temperature',
        raw,
        value: raw / 10,
        unit: '°C',
        note: 'PDF example shows 0x00000172 => 370 => 37.0°C',
      };
    }

    case 0x03: {
      const raw = uint32BE(payload);
      return {
        name: 'value_0x03',
        raw,
        note: 'PDF indicates XX1<<24 + XX2<<16 + XX3<<8 + XX4',
      };
    }

    case 0x04: {
      const value1 = uint16BE(payload[0], payload[1]);
      const value2 = uint16BE(payload[2], payload[3]);
      return {
        name: 'dual_uint16_0x04',
        value1,
        value2,
        note: 'PDF indicates first two bytes and last two bytes are separate values',
      };
    }

    case 0x08: {
      const raw = uint32BE(payload);
      return {
        name: 'flow_rate',
        raw,
        unit: 'ml/min',
      };
    }

    case 0x09: {
      const mode = payload[0];
      const raw = uint32BE([0x00, payload[1], payload[2], payload[3]]);
      return {
        name: 'stateful_value_0x09',
        mode,
        raw,
        note: 'PDF indicates XX1 is a flag (0x00/0x01) and XX2-XX4 compose the value',
      };
    }

    case 0x0C: {
      const raw = uint32BE(payload);
      return {
        name: 'volume',
        raw,
        unit: 'ml',
      };
    }

    case 0x0D: {
      const flag = payload[0];
      const raw = uint32BE([0x00, payload[1], payload[2], payload[3]]);
      return {
        name: 'scaled_value_0x0D',
        flag,
        raw,
        value: raw / 10,
        note: 'PDF indicates XX1 is 0x00 and XX2-XX4 value should be divided by 10',
      };
    }

    default:
      return {
        name: `command_${toHex(command)}`,
        raw: uint32BE(payload),
        payload: Array.from(payload),
        note: 'Meaning not fully legible in source PDF; raw data preserved',
      };
  }
}

function buildParsedFrame(frame, includeTimestamp) {
  const command = frame[2];
  const payload = frame.slice(3, 7);
  const receivedChecksum = frame[7];
  const expectedChecksum = checksum(command, payload);
  const valid = receivedChecksum === expectedChecksum;

  const parsed = {
    rawHex: bytesToHex(frame),
    frameLength: frame.length,
    header: [toHex(frame[0]), toHex(frame[1])],
    command,
    commandHex: toHex(command),
    payloadHex: bytesToHex(payload),
    payload: Array.from(payload),
    checksum: {
      received: receivedChecksum,
      receivedHex: toHex(receivedChecksum),
      expected: expectedChecksum,
      expectedHex: toHex(expectedChecksum),
      valid,
    },
  };

  if (includeTimestamp) {
    parsed.timestamp = new Date().toISOString();
  }

  if (valid) {
    parsed.decoded = decodePayload(command, payload);
  } else {
    parsed.error = 'Checksum mismatch';
  }

  return parsed;
}

function parseHexInput(input) {
  const normalized = input.replace(/0x/gi, ' ').replace(/[^a-fA-F0-9]/g, ' ');
  const hexPairs = normalized.split(/\s+/).filter(Boolean);

  if (hexPairs.length === 0) {
    throw new Error('No hex bytes found in simulate input');
  }

  const values = hexPairs.map((pair) => {
    if (pair.length > 2) {
      throw new Error(`Invalid byte: ${pair}`);
    }

    return Number.parseInt(pair, 16);
  });

  return Buffer.from(values);
}

class Jhm2028Parser {
  constructor(options) {
    this.onFrame = options.onFrame;
    this.onRawChunk = options.onRawChunk || null;
    this.includeTimestamp = options.includeTimestamp !== false;
    this.buffer = Buffer.alloc(0);
  }

  push(chunk) {
    if (!Buffer.isBuffer(chunk) || chunk.length === 0) {
      return;
    }

    if (this.onRawChunk) {
      this.onRawChunk(chunk);
    }

    this.buffer = Buffer.concat([this.buffer, chunk]);

    while (this.buffer.length >= FRAME_LENGTH) {
      const headerIndex = this.findHeader();

      if (headerIndex === -1) {
        this.buffer = this.buffer.slice(Math.max(0, this.buffer.length - 1));
        return;
      }

      if (headerIndex > 0) {
        this.buffer = this.buffer.slice(headerIndex);
      }

      if (this.buffer.length < FRAME_LENGTH) {
        return;
      }

      const frame = this.buffer.slice(0, FRAME_LENGTH);
      this.buffer = this.buffer.slice(FRAME_LENGTH);
      this.onFrame(buildParsedFrame(frame, this.includeTimestamp));
    }
  }

  findHeader() {
    for (let i = 0; i <= this.buffer.length - 2; i += 1) {
      if (this.buffer[i] === HEADER_1 && this.buffer[i + 1] === HEADER_2) {
        return i;
      }
    }

    return -1;
  }
}

function validateOptions(options) {
  if (!options.simulate && !options.port) {
    throw new Error('Missing serial port. Example: node jhm2028-service.js --port COM3');
  }

  if (![5, 6, 7, 8].includes(options.dataBits)) {
    throw new Error('dataBits must be one of 5, 6, 7, 8');
  }

  if (![1, 1.5, 2].includes(options.stopBits)) {
    throw new Error('stopBits must be one of 1, 1.5, 2');
  }

  if (!['none', 'even', 'odd', 'mark', 'space'].includes(options.parity)) {
    throw new Error('parity must be one of none, even, odd, mark, space');
  }

  if (!Number.isInteger(options.baudRate) || options.baudRate <= 0) {
    throw new Error('baudRate must be a positive integer');
  }
}

function printJson(frame) {
  console.log(JSON.stringify(frame, null, 2));
}

function printStartup(options) {
  console.log('JHM-2028 serial service started');
  console.log(`Port: ${options.port}`);
  console.log(`Config: ${options.baudRate} baud, ${options.dataBits} data bits, ${options.stopBits} stop bit(s), parity=${options.parity}`);
  console.log(`Frame format: ${toHex(HEADER_1)} ${toHex(HEADER_2)} NN XX1 XX2 XX3 XX4 CY`);
  console.log('Waiting for data...');
}

function runSimulation(options) {
  const parser = new Jhm2028Parser({
    includeTimestamp: options.timestamp,
    onRawChunk: options.raw ? (chunk) => console.log(`[raw] ${bytesToHex(chunk)}`) : null,
    onFrame: printJson,
  });

  const buffer = parseHexInput(options.simulate);
  parser.push(buffer);

  if (buffer.length % FRAME_LENGTH !== 0) {
    console.error(`Warning: simulate input length is ${buffer.length} bytes, not a multiple of ${FRAME_LENGTH}`);
  }
}

function closePort(port) {
  if (!port || !port.isOpen) {
    process.exit(0);
    return;
  }

  console.log('\nClosing serial port...');
  port.close((error) => {
    if (error) {
      console.error('Failed to close serial port:', error.message);
      process.exit(1);
      return;
    }

    process.exit(0);
  });
}

function runSerialService(options) {
  const SerialPortClass = loadSerialPort();
  const port = new SerialPortClass({
    path: options.port,
    baudRate: options.baudRate,
    dataBits: options.dataBits,
    stopBits: options.stopBits,
    parity: options.parity,
    autoOpen: false,
  });

  const parser = new Jhm2028Parser({
    includeTimestamp: options.timestamp,
    onRawChunk: options.raw ? (chunk) => console.log(`[raw] ${bytesToHex(chunk)}`) : null,
    onFrame: printJson,
  });

  port.on('open', () => {
    printStartup(options);
  });

  port.on('data', (chunk) => {
    parser.push(chunk);
  });

  port.on('error', (error) => {
    console.error('Serial port error:', error.message);
  });

  port.on('close', () => {
    console.log('Serial port closed');
  });

  process.on('SIGINT', () => {
    closePort(port);
  });

  process.on('SIGTERM', () => {
    closePort(port);
  });

  port.open((error) => {
    if (error) {
      console.error('Failed to open serial port:', error.message);
      process.exit(1);
    }
  });
}

function main() {
  try {
    const options = parseArgs(process.argv);
    validateOptions(options);

    if (options.simulate) {
      runSimulation(options);
      return;
    }

    runSerialService(options);
  } catch (error) {
    console.error(error.message);
    console.error('Use --help to see available options.');
    process.exit(1);
  }
}

if (require.main === module) {
  main();
}

module.exports = {
  Jhm2028Parser,
  buildParsedFrame,
  checksum,
  decodePayload,
  parseHexInput,
  uint16BE,
  uint32BE,
};