#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const net = require('net');
const {
  FRAME_LENGTH,
  JhmDecoder,
  additiveChecksum,
} = require('./decoder');

const DEFAULT_FRAMES_FILE = path.join(__dirname, '数据模拟.md');
const DEFAULT_INTERVAL_MS = 1000;
const DEFAULT_AL_MODEL_FILE = path.join(__dirname, 'alModel.json');
const BUILTIN_SCENARIOS = {
  jihua20260414: {
    name: '2026-04-14 真实业务抓包',
    description: '按历史抓包循环回放透析机固定帧数据。',
    framesFile: path.join(__dirname, 'jihua20260414.txt'),
    cycleLength: 17,
  },
};

function parseArgs(argv) {
  const options = {
    host: '127.0.0.1',
    port: 9000,
    intervalMs: DEFAULT_INTERVAL_MS,
    framesFile: DEFAULT_FRAMES_FILE,
    scenario: '',
    repeat: 0,
    localAddress: '',
    mode: 'file',
    bpSystolic: 120,
    bpDiastolic: 80,
    bpPulse: 89,
    bpTime: '',
    bpIncludeTime: true,
  };

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

    if (arg === '--host' && value) {
      options.host = value;
      index += 1;
    } else if (arg === '--port' && value) {
      options.port = Number(value);
      index += 1;
    } else if (arg === '--interval' && value) {
      options.intervalMs = Number(value);
      index += 1;
    } else if (arg === '--frames' && value) {
      options.framesFile = path.resolve(value);
      index += 1;
    } else if (arg === '--scenario' && value) {
      options.scenario = value.trim();
      index += 1;
    } else if (arg === '--repeat' && value) {
      options.repeat = Number(value);
      index += 1;
    } else if (arg === '--local-address' && value) {
      options.localAddress = value;
      index += 1;
    } else if (arg === '--mode' && value) {
      options.mode = value.trim().toLowerCase();
      index += 1;
    } else if (arg === '--blood-pressure' || arg === '--bp') {
      options.mode = 'blood-pressure';
    } else if (arg === '--bp-systolic' && value) {
      options.bpSystolic = Number(value);
      index += 1;
    } else if (arg === '--bp-diastolic' && value) {
      options.bpDiastolic = Number(value);
      index += 1;
    } else if (arg === '--bp-pulse' && value) {
      options.bpPulse = Number(value);
      index += 1;
    } else if (arg === '--bp-time' && value) {
      options.bpTime = value.trim();
      index += 1;
    } else if (arg === '--bp-no-time') {
      options.bpIncludeTime = false;
    } else if (arg === '--help' || arg === '-h') {
      options.help = true;
    }
  }

  return options;
}

function printHelp() {
  console.log(`JHM TCP simulator

Usage:
  node tcp-simulator.js --host 127.0.0.1 --port 9000
  node tcp-simulator.js --scenario jihua20260414 --host 127.0.0.1 --port 9000 --repeat 1
  node tcp-simulator.js --bp --host 127.0.0.1 --port 9000 --bp-systolic 120 --bp-diastolic 80 --bp-pulse 89
  node tcp-simulator.js --bp --host 127.0.0.1 --port 9000 --bp-time "2026-04-15 09:30"

Options:
  --host <ip>             target TCP server, default 127.0.0.1
  --port <number>         target TCP port, default 9000
  --interval <ms>         interval between frames, default 1000ms
  --frames <path>         hex frame file, default ./数据模拟.md
  --scenario <name>       built-in scenario: ${Object.keys(BUILTIN_SCENARIOS).join(', ')}
  --repeat <number>       send rounds, 0 means infinite loop, default 0
  --local-address <ip>    bind local IP to simulate source device IP
  --mode <file|blood-pressure>
  --blood-pressure, --bp  shorthand for --mode blood-pressure
  --bp-systolic <n>       blood pressure systolic value, default 120
  --bp-diastolic <n>      blood pressure diastolic value, default 80
  --bp-pulse <n>          blood pressure pulse value, default 89
  --bp-time "<text>"      custom time, format YYYY-MM-DD HH:mm, default current local time
  --bp-no-time            send zeroed time bytes
  --help, -h              show help
`);
}

function resolveScenario(options) {
  if (!options.scenario) {
    return { ...options, scenarioConfig: null };
  }

  const scenarioConfig = BUILTIN_SCENARIOS[options.scenario];

  if (!scenarioConfig) {
    throw new Error(`unknown scenario: ${options.scenario}`);
  }

  return {
    ...options,
    mode: 'file',
    framesFile: scenarioConfig.framesFile,
    scenarioConfig,
  };
}

function validateOptions(options) {
  if (!options.host) {
    throw new Error('host is required');
  }

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

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

  if (!Number.isInteger(options.repeat) || options.repeat < 0) {
    throw new Error('repeat must be an integer >= 0');
  }

  if (!['file', 'blood-pressure'].includes(options.mode)) {
    throw new Error(`unsupported mode: ${options.mode}`);
  }

  if (options.mode === 'file' && !fs.existsSync(options.framesFile)) {
    throw new Error(`frames file not found: ${options.framesFile}`);
  }

  if (options.mode === 'blood-pressure') {
    for (const [name, value] of [
      ['bp-systolic', options.bpSystolic],
      ['bp-diastolic', options.bpDiastolic],
      ['bp-pulse', options.bpPulse],
    ]) {
      if (!Number.isInteger(value) || value < 0 || value > 0xFFFF) {
        throw new Error(`${name} must be an integer between 0 and 65535`);
      }
    }

    if (options.bpIncludeTime && options.bpTime) {
      parseBloodPressureTimeText(options.bpTime);
    }
  }
}

function bufferToHex(buffer) {
  return Array.from(buffer, (value) => value.toString(16).toUpperCase().padStart(2, '0')).join(' ');
}

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

  if (hexPairs.length === 0) {
    return null;
  }

  return Buffer.from(hexPairs.map((pair) => {
    if (pair.length > 2) {
      throw new Error(`invalid byte: ${pair}`);
    }

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

function loadFramesByLines(content) {
  const lines = content.split(/\r?\n/);
  const frames = [];
  const framePattern = /^(?:0x)?[0-9a-fA-F]{2}(?:\s+(?:0x)?[0-9a-fA-F]{2})+$/;

  for (const line of lines) {
    const trimmed = line.trim();

    if (!trimmed || trimmed.startsWith('```') || trimmed.startsWith('#')) {
      continue;
    }

    if (!framePattern.test(trimmed)) {
      continue;
    }

    const frame = parseHexLine(trimmed);

    if (frame && frame.length > 0) {
      frames.push({ raw: trimmed, buffer: frame });
    }
  }

  return frames;
}

function loadFramesFromContinuousHex(content) {
  const bytes = (content.match(/[0-9a-fA-F]{2}/g) || []).map((pair) => Number.parseInt(pair, 16));
  const frames = [];

  for (let index = 0; index <= bytes.length - FRAME_LENGTH;) {
    if (bytes[index] === 0xEE && bytes[index + 1] === 0x55) {
      const buffer = Buffer.from(bytes.slice(index, index + FRAME_LENGTH));
      frames.push({ raw: bufferToHex(buffer), buffer });
      index += FRAME_LENGTH;
      continue;
    }

    index += 1;
  }

  return frames;
}

function loadFrames(framesFile) {
  const content = fs.readFileSync(framesFile, 'utf8');
  const lineFrames = loadFramesByLines(content);

  if (lineFrames.length > 0) {
    return {
      frames: lineFrames,
      mode: 'line',
    };
  }

  const continuousFrames = loadFramesFromContinuousHex(content);

  if (continuousFrames.length > 0) {
    return {
      frames: continuousFrames,
      mode: 'continuous',
    };
  }

  throw new Error('no sendable hex frames found in frames file');
}

function analyzeFrames(frames, scenarioConfig) {
  const decoder = new JhmDecoder({ alModelPath: DEFAULT_AL_MODEL_FILE });
  const analysis = {
    totalFrames: frames.length,
    publishableFrames: 0,
    unsupportedFrames: 0,
    snapshot: {},
    stateTransitions: [],
    fullCycles: 0,
    extraFrames: 0,
  };
  let lastState;

  for (let index = 0; index < frames.length; index += 1) {
    const results = decoder.push(frames[index].buffer);

    for (const result of results) {
      if (result.publish) {
        analysis.publishableFrames += 1;

        for (const [identifier, value] of Object.entries(result.metric || {})) {
          if (!(identifier in analysis.snapshot)) {
            analysis.snapshot[identifier] = value;
          }
        }

        if (Object.prototype.hasOwnProperty.call(result.metric || {}, 'o') && result.metric.o !== lastState) {
          analysis.stateTransitions.push({
            frameIndex: index + 1,
            value: result.metric.o,
          });
          lastState = result.metric.o;
        }
      }

      if (result.reason === 'unsupported-command') {
        analysis.unsupportedFrames += 1;
      }
    }
  }

  if (scenarioConfig && scenarioConfig.cycleLength) {
    analysis.fullCycles = Math.floor(frames.length / scenarioConfig.cycleLength);
    analysis.extraFrames = frames.length % scenarioConfig.cycleLength;
  }

  return analysis;
}

function formatSnapshot(snapshot) {
  const orderedKeys = ['F', 'A', 'sysj', 'C', 'B', 'L', 'D', 'H', 'o', 'J', 'U', 'G', 'Na', 'HCO3', 'N', 'O', 'P', 'M'];

  return orderedKeys
    .filter((key) => snapshot[key] !== undefined)
    .map((key) => `${key}=${snapshot[key]}`)
    .join(', ');
}

function parseBloodPressureTimeText(value) {
  const match = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})$/.exec(value);

  if (!match) {
    throw new Error(`invalid --bp-time format: ${value}. Expected YYYY-MM-DD HH:mm`);
  }

  const [, year, month, day, hour, minute] = match;

  return [
    Number(year) % 100,
    Number(month),
    Number(day),
    Number(hour),
    Number(minute),
  ];
}

function getCurrentBloodPressureTimeBytes() {
  const now = new Date();

  return [
    now.getFullYear() % 100,
    now.getMonth() + 1,
    now.getDate(),
    now.getHours(),
    now.getMinutes(),
  ];
}

function buildBloodPressureFrame(options) {
  const timeBytes = options.bpIncludeTime
    ? (options.bpTime ? parseBloodPressureTimeText(options.bpTime) : getCurrentBloodPressureTimeBytes())
    : [0, 0, 0, 0, 0];
  const frameWithoutChecksum = Buffer.from([
    0xAA,
    0x55,
    0x0E,
    0xBA,
    (options.bpSystolic >> 8) & 0xFF,
    options.bpSystolic & 0xFF,
    options.bpDiastolic & 0xFF,
    options.bpPulse & 0xFF,
    ...timeBytes,
  ]);
  const checksumByte = additiveChecksum(frameWithoutChecksum);
  const buffer = Buffer.concat([frameWithoutChecksum, Buffer.from([checksumByte])]);

  return {
    raw: bufferToHex(buffer),
    buffer,
  };
}

function prepareSimulation(options) {
  if (options.mode === 'blood-pressure') {
    const frame = buildBloodPressureFrame(options);
    const analysis = analyzeFrames([frame], null);

    return {
      frames: [frame],
      analysis,
      loadMode: 'blood-pressure',
      scenarioConfig: null,
    };
  }

  const loadResult = loadFrames(options.framesFile);
  const analysis = analyzeFrames(loadResult.frames, options.scenarioConfig);

  return {
    frames: loadResult.frames,
    analysis,
    loadMode: loadResult.mode,
    scenarioConfig: options.scenarioConfig,
  };
}

function startClient(options, prepared) {
  const socketOptions = {
    host: options.host,
    port: options.port,
  };

  if (options.localAddress) {
    socketOptions.localAddress = options.localAddress;
  }

  const socket = net.createConnection(socketOptions);
  let timer = null;
  let frameIndex = 0;
  let round = 0;
  let stopped = false;

  function stop(reason) {
    if (stopped) {
      return;
    }

    stopped = true;

    if (timer) {
      clearInterval(timer);
      timer = null;
    }

    if (!socket.destroyed) {
      socket.end();
      socket.destroy();
    }

    if (reason) {
      console.log(reason);
    }
  }

  function sendNextFrame() {
    const frame = prepared.frames[frameIndex];
    socket.write(frame.buffer);
    console.log(`[SIM] sent round=${round + 1} frame=${frameIndex + 1} -> ${frame.raw}`);

    frameIndex += 1;

    if (frameIndex >= prepared.frames.length) {
      frameIndex = 0;
      round += 1;

      if (options.repeat > 0 && round >= options.repeat) {
        stop(`[SIM] finished ${options.repeat} round(s)`);
      }
    }
  }

  socket.on('connect', () => {
    console.log(`[SIM] connected to ${options.host}:${options.port}`);

    if (options.localAddress) {
      console.log(`[SIM] local bind address ${options.localAddress}`);
    }

    if (prepared.scenarioConfig) {
      console.log(`[SIM] scenario ${options.scenario} -> ${prepared.scenarioConfig.name}`);
      console.log(`[SIM] scenario description: ${prepared.scenarioConfig.description}`);
    } else if (options.mode === 'blood-pressure') {
      console.log(`[SIM] mode blood-pressure systolic=${options.bpSystolic} diastolic=${options.bpDiastolic} pulse=${options.bpPulse}`);
      console.log(`[SIM] blood-pressure time ${options.bpIncludeTime ? (options.bpTime || 'current local time') : 'disabled / zero bytes'}`);
    } else {
      console.log(`[SIM] loaded frames file ${path.basename(options.framesFile)}`);
    }

    console.log(`[SIM] data mode ${prepared.loadMode} frames=${prepared.analysis.totalFrames} publishable=${prepared.analysis.publishableFrames} unsupported=${prepared.analysis.unsupportedFrames}`);

    if (prepared.analysis.fullCycles > 0 || prepared.analysis.extraFrames > 0) {
      console.log(`[SIM] scenario cycles fullCycles=${prepared.analysis.fullCycles} extraFrames=${prepared.analysis.extraFrames}`);
    }

    if (prepared.analysis.stateTransitions.length > 0) {
      const transitionText = prepared.analysis.stateTransitions
        .map((item) => `frame#${item.frameIndex}:o=${item.value}`)
        .join(' -> ');
      console.log(`[SIM] state transitions ${transitionText}`);
    }

    if (Object.keys(prepared.analysis.snapshot).length > 0) {
      console.log(`[SIM] snapshot ${formatSnapshot(prepared.analysis.snapshot)}`);
    }

    sendNextFrame();
    timer = setInterval(sendNextFrame, options.intervalMs);
  });

  socket.on('error', (error) => {
    stop(`[SIM] connection error: ${error.message}`);
    process.exitCode = 1;
  });

  socket.on('close', () => {
    if (!stopped) {
      stop('[SIM] connection closed');
    }
  });

  process.on('SIGINT', () => {
    stop('[SIM] received SIGINT, stopping');
    process.exit(0);
  });

  process.on('SIGTERM', () => {
    stop('[SIM] received SIGTERM, stopping');
    process.exit(0);
  });
}

function main() {
  const parsedOptions = parseArgs(process.argv);

  if (parsedOptions.help) {
    printHelp();
    return;
  }

  const options = resolveScenario(parsedOptions);
  validateOptions(options);
  const prepared = prepareSimulation(options);
  startClient(options, prepared);
}

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

module.exports = {
  BUILTIN_SCENARIOS,
  buildBloodPressureFrame,
  getCurrentBloodPressureTimeBytes,
  parseArgs,
  parseBloodPressureTimeText,
  prepareSimulation,
};