const assert = require('node:assert');
const fs = require('fs');
const os = require('os');
const path = require('path');
const translator = require('./pipeline/translator');
const { normalize } = require('./pipeline/normalizer');

function run() {
  const entry = {
    instrument_id: 'inst1',
    config: { location: 'default-lab' },
    translator: {
      engine: 'overrides',
      forceInstrumentId: true,
      meta: { direction: 'mono' }
    }
  };

  const rawPayload = '<STX>ABC|123<ETX>';
  const canonicalSeed = {
    instrument_id: entry.instrument_id,
    sample_id: 'raw-1',
    result_time: new Date().toISOString(),
    results: [{ test_code: 'RAW', value: rawPayload }],
    meta: { raw_payload: rawPayload }
  };

  const translated = translator.translate(entry, canonicalSeed, 'astm-serial', entry.translator.engine);
  const normalized = normalize(translated);

  assert.strictEqual(normalized.instrument_id, 'inst1');
  assert.strictEqual(normalized.results[0].test_code, 'RAW');
  assert.strictEqual(normalized.results[0].value, rawPayload);

  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tinylink-map-'));
  const mapFilePath = path.join(tempDir, 'inst1.map');
  fs.writeFileSync(mapFilePath, [
    '# smoke test map',
    'HEADER = H|{instrument_id}|{connector}',
    'ORDER = O|{sample_id}|{order_tests}'
  ].join('\n'));

  const templateEntry = {
    ...entry,
    files: { config: path.join(process.cwd(), 'config', 'app.yaml') },
    translator: {
      engine: 'template',
      file: mapFilePath,
      messages: ['HEADER', 'ORDER'],
      forceInstrumentId: true
    }
  };

  const templateTranslated = translator.translate(templateEntry, canonicalSeed, 'astm-serial', templateEntry.translator.engine);
  const templateNormalized = normalize(templateTranslated);

  assert.strictEqual(templateNormalized.meta.rendered_messages.length, 2);
  assert.strictEqual(templateNormalized.meta.rendered_messages[0].body, 'H|inst1|astm-serial');
  assert.strictEqual(templateNormalized.meta.rendered_messages[1].body, 'O|raw-1|^^^RAW');

  const advancedMapFilePath = path.join(tempDir, 'jokoh.map');
  fs.writeFileSync(advancedMapFilePath, [
    '# human-friendly sections',
    '# HEADER',
    '<VT>H|{instrument_id}|{sample_id}<CR>',
    '',
    '# RESULTS',
    '<<',
    '@for R',
    'R|{R[3]}|{R[4]}<CR>',
    '@end',
    '>>',
    '',
    '# TERMINATOR',
    'L|1|N<FS><CR>'
  ].join('\n'));

  const advancedEntry = {
    ...entry,
    files: { config: path.join(process.cwd(), 'config', 'app.yaml') },
    translator: {
      engine: 'template',
      file: advancedMapFilePath,
      forceInstrumentId: true
    }
  };

  const advancedSeed = {
    ...canonicalSeed,
    meta: {
      raw_payload: '\u000bH|\\^&|||WST^P1\rR|1|GLU|5.6\rR|2|HGB|13.2\u001c\r'
    }
  };

  const advancedTranslated = translator.translate(advancedEntry, advancedSeed, 'hl7-tcp', advancedEntry.translator.engine);
  const advancedNormalized = normalize(advancedTranslated);

  assert.strictEqual(advancedNormalized.meta.rendered_messages.length, 3);
  assert.strictEqual(advancedNormalized.meta.rendered_messages[0].body, '\u000bH|inst1|raw-1\r');
  assert.strictEqual(advancedNormalized.meta.rendered_messages[1].body, 'R|GLU|5.6\r\nR|HGB|13.2\r');
  assert.strictEqual(advancedNormalized.meta.rendered_messages[2].body, 'L|1|N\u001c\r');

  const fixedWidthMapFilePath = path.join(tempDir, 'jokoh-fixed.map');
  fs.writeFileSync(fixedWidthMapFilePath, [
    '# fixed-width jokoh sections',
    '# RESULT',
    '<<',
    '<STX>,{datetime:14:""},{skip:5:""},{sampleid:17:""},{sampletype:2:""},',
    '@for i in 1..3',
    '({testid:2:""},{result:5:""},{skip:2:""})',
    '@end',
    ',<ETX>',
    '>>'
  ].join('\n'));

  const fixedWidthEntry = {
    ...entry,
    files: { config: path.join(process.cwd(), 'config', 'app.yaml') },
    translator: {
      engine: 'template',
      file: fixedWidthMapFilePath,
      forceInstrumentId: true
    }
  };

  const fixedWidthRawBody = [
    '20241008181025',
    '00000',
    '000000120169050  ',
    '02',
    'A1',
    '12.34',
    '  ',
    'B2',
    ' 9.8 ',
    '  ',
    'C3',
    '07.01',
    '  '
  ].join('');
  const fixedWidthSeed = {
    ...canonicalSeed,
    meta: {
      raw_payload: `\u0002${fixedWidthRawBody}\u0003`
    }
  };

  const fixedWidthTranslated = translator.translate(
    fixedWidthEntry,
    fixedWidthSeed,
    'astm-serial',
    fixedWidthEntry.translator.engine
  );
  const fixedWidthNormalized = normalize(fixedWidthTranslated);

  assert.strictEqual(fixedWidthNormalized.meta.rendered_messages.length, 1);
  assert.strictEqual(
    fixedWidthNormalized.meta.rendered_messages[0].body,
    '\u0002,20241008181025,,000000120169050  ,02,\n(A1,12.34,)\n(B2, 9.8 ,)\n(C3,07.01,)\n,\u0003'
  );

  fs.rmSync(tempDir, { recursive: true, force: true });
  console.log('Raw pipeline smoke test passed');
}

run();