#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const assert = require('assert');
const { JhmDecoder, additiveChecksum } = require('./decoder');
const { MqttService } = require('./mqtt-service');

const config = JSON.parse(fs.readFileSync(path.join(__dirname, 'config.json'), 'utf8'));
const decoder = new JhmDecoder({
  alModelPath: config.protocol.alModelPath,
  maxBufferBytes: config.tcp.maxBufferBytes,
});
const mqttService = new MqttService(config.mqtt, console);
const device = config.devices[0] || { deviceId: 'JHM-TEST', ip: '127.0.0.1', name: 'test-device' };

function buildFrame(command, payload) {
  const cy = (command + payload[0] + payload[1] + payload[2] + payload[3]) & 0xFF;
  return Buffer.from([0xEE, 0x55, command, ...payload, cy]);
}

function buildBloodPressureFrame({ systolic, diastolic, pulse, timeBytes }) {
  const frameWithoutChecksum = Buffer.from([
    0xAA,
    0x55,
    0x0E,
    0xBA,
    (systolic >> 8) & 0xFF,
    systolic & 0xFF,
    diastolic & 0xFF,
    pulse & 0xFF,
    ...timeBytes,
  ]);

  return Buffer.concat([
    frameWithoutChecksum,
    Buffer.from([additiveChecksum(frameWithoutChecksum)]),
  ]);
}

function payloadToHex(payload) {
  return payload.map((value) => `0x${value.toString(16).toUpperCase().padStart(2, '0')}`).join(' ');
}

const cases = [
  { command: 0x01, payload: [0x00, 0x00, 0x01, 0x77], expectedPublish: true, expectedMetric: { F: 37.5 }, note: 'temperature = 375 / 10' },
  { command: 0x02, payload: [0x00, 0x00, 0x01, 0x77], expectedPublish: false, reason: 'identifier-missing', note: 'set temperature not published' },
  { command: 0x03, payload: [0x00, 0x00, 0x04, 0xD2], expectedPublish: true, expectedMetric: { A: 1.234 }, note: 'ultrafiltration total = 1234mL => 1.234L' },
  { command: 0x04, payload: [0x00, 0x01, 0x00, 0x1E], expectedPublish: true, expectedMetric: { sysj: 90 }, note: 'remaining minutes = 1*60 + 30' },
  { command: 0x05, payload: [0x00, 0x00, 0x01, 0xF4], expectedPublish: true, expectedMetric: { C: 0.5 }, note: 'uf rate = 500mL => 0.5L' },
  { command: 0x06, payload: [0x00, 0x00, 0x00, 0xFA], expectedPublish: true, expectedMetric: { B: 0.25 }, note: 'uf volume = 250mL => 0.25L' },
  { command: 0x07, payload: [0x00, 0x00, 0x02, 0x58], expectedPublish: true, expectedMetric: { L: 600 }, note: 'dialysate flow = 600' },
  { command: 0x08, payload: [0x00, 0x00, 0x01, 0x40], expectedPublish: true, expectedMetric: { D: 320 }, note: 'effective blood flow = 320' },
  { command: 0x09, payload: [0x01, 0x00, 0x00, 0x64], expectedPublish: true, expectedMetric: { H: -100 }, note: 'venous pressure = -100' },
  { command: 0x0A, payload: [0x00, 0x00, 0x00, 0x78], expectedPublish: true, expectedMetric: { o: 120 }, note: 'arterial pressure = 120' },
  { command: 0x0B, payload: [0x01, 0x00, 0x00, 0x50], expectedPublish: true, expectedMetric: { J: -80 }, note: 'transmembrane pressure = -80' },
  { command: 0x0C, payload: [0x00, 0x00, 0x08, 0x00], expectedPublish: true, expectedMetric: { U: 2048 }, note: 'accumulated blood flow = 2048' },
  { command: 0x0D, payload: [0x00, 0x00, 0x00, 0x7B], expectedPublish: true, expectedMetric: { G: 12.3 }, note: 'conductivity = 123 / 10' },
  { command: 0x0E, payload: [0x00, 0x00, 0x00, 0x8C], expectedPublish: true, expectedMetric: { Na: 140 }, note: 'sodium concentration = 140' },
  { command: 0x0F, payload: [0x00, 0x00, 0x00, 0x19], expectedPublish: true, expectedMetric: { HCO3: 25 }, note: 'HCO3 concentration = 25' },
];

const bloodPressureCase = {
  frame: buildBloodPressureFrame({
    systolic: 120,
    diastolic: 80,
    pulse: 89,
    timeBytes: [0x1A, 0x04, 0x0F, 0x09, 0x1E],
  }),
  expectedMetric: {
    N: 120,
    O: 80,
    P: 89,
    M: '2026-04-15 09:30',
  },
};

function main() {
  const topic = mqttService.buildTopic(device);

  console.log(`verify device: ${device.deviceId} (${device.ip})`);
  console.log(`verify topic: ${topic}`);
  console.log('');

  for (const item of cases) {
    const result = decoder.push(buildFrame(item.command, item.payload))[0];

    assert.ok(result, `command 0x${item.command.toString(16).toUpperCase()} returned no result`);
    assert.strictEqual(result.publish, item.expectedPublish, `command 0x${item.command.toString(16).toUpperCase()} publish state mismatch`);

    if (item.expectedPublish) {
      assert.deepStrictEqual(result.metric, item.expectedMetric, `command 0x${item.command.toString(16).toUpperCase()} metric mismatch`);
      console.log(`[publish] command=0x${item.command.toString(16).toUpperCase().padStart(2, '0')} payload=${payloadToHex(item.payload)} topic=${topic} mqtt=${JSON.stringify(result.metric)} note=${item.note}`);
    } else {
      assert.strictEqual(result.reason, item.reason, `command 0x${item.command.toString(16).toUpperCase()} skip reason mismatch`);
      console.log(`[skip] command=0x${item.command.toString(16).toUpperCase().padStart(2, '0')} payload=${payloadToHex(item.payload)} reason=${result.reason} note=${item.note}`);
    }
  }

  const bloodPressureResult = decoder.push(bloodPressureCase.frame)[0];
  assert.ok(bloodPressureResult, 'blood pressure frame returned no result');
  assert.strictEqual(bloodPressureResult.publish, true, 'blood pressure frame should publish');
  assert.deepStrictEqual(bloodPressureResult.metric, bloodPressureCase.expectedMetric, 'blood pressure metric mismatch');
  console.log(`[publish] command=0xBA raw=${bloodPressureResult.rawHex} topic=${topic} mqtt=${JSON.stringify(bloodPressureResult.metric)} note=blood pressure frame`);

  console.log('');
  console.log('verify-all-commands passed');
}

main();