const { test } = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');

function loadVitals() {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'vitals.json'), 'utf8');
  return JSON.parse(raw);
}

test('vitals.json exposes all calculator age groups', () => {
  const data = loadVitals();
  assert.equal(data.version, '1.0');
  assert.deepEqual(Object.keys(data.ageGroups), [
    'premie',
    '0-3mo',
    '3-6mo',
    '6-12mo',
    '1-3yr',
    '3-6yr',
    '6-12yr',
    '>12yr'
  ]);
});

test('vitals.json preserves key Harriet Lane ranges', () => {
  const groups = loadVitals().ageGroups;
  assert.equal(groups.premie.hr.awake, '120-170');
  assert.equal(groups.premie.spo2, '88-95% (target)');
  assert.equal(groups['0-3mo'].sbp, '65-85');
  assert.equal(groups['3-6mo'].rr, '30-45');
  assert.equal(groups['1-3yr'].weight, '10-15 kg');
  assert.equal(groups['6-12yr'].hr.sleeping, '50-85');
  assert.equal(groups['>12yr'].dbp, '65-85');
});

test('vitals.json entries have complete renderable fields', () => {
  const groups = loadVitals().ageGroups;
  Object.entries(groups).forEach(([key, group]) => {
    assert.ok(group.label, `${key}.label`);
    assert.ok(group.hr && group.hr.awake && group.hr.sleeping, `${key}.hr`);
    ['rr', 'sbp', 'dbp', 'temp', 'weight', 'spo2'].forEach((field) => {
      assert.ok(group[field], `${key}.${field}`);
    });
    assert.ok(Array.isArray(group.notes) && group.notes.length > 0, `${key}.notes`);
  });
});

test('resus-meds.json exposes all PALS medication formulas', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'resus-meds.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  assert.deepEqual(data.medications.map((m) => m.formula), [
    'adenosine',
    'amiodarone',
    'atropine',
    'calciumChloride',
    'calciumGluconate',
    'dextrose',
    'epinephrine',
    'hydrocortisone',
    'insulin',
    'lidocaine',
    'magnesiumSulfate',
    'naloxone',
    'sodiumBicarbonate'
  ]);
});

test('resus dose formulas preserve representative outputs', async () => {
  const { calculateResusDose } = await import('../public/js/calculators/resus.js');
  assert.equal(calculateResusDose('adenosine', 20).dose, '2 mg (0.1 mg/kg)');
  assert.equal(calculateResusDose('epinephrine', 10).dose, '0.1 mg IV/IO (0.01 mg/kg of 0.1 mg/mL = 1 mL) q3-5 min');
  assert.equal(calculateResusDose('magnesiumSulfate', 50).dose, '2000 mg (50 mg/kg)');
  assert.equal(calculateResusDose('sodiumBicarbonate', 8).extra, 'Dilute to 0.5 mEq/mL (use 4.2% solution) for neonates/small infants.');
});

test('fenton-lms.json preserves key LMS anchors', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'fenton-lms.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  assert.deepEqual(data.weightLms.male['22'], { L: 0.21, M: 496, S: 0.17 });
  assert.deepEqual(data.weightLms.male['40'], { L: 0.01, M: 3530, S: 0.12 });
  assert.deepEqual(data.weightLms.female['22'], { L: 0.23, M: 474, S: 0.17 });
  assert.deepEqual(data.weightLms.female['40'], { L: 0.01, M: 3340, S: 0.12 });
});

test('neonatal Fenton helpers preserve interpolation and classification', async () => {
  const neonatal = await import('../public/js/calculators/neonatal.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'fenton-lms.json'), 'utf8');
  const data = JSON.parse(raw).weightLms;
  assert.deepEqual(neonatal.interpolateLMS(data.male, 30), { L: 0.18, M: 1430, S: 0.14 });
  assert.equal(Math.round(neonatal.interpolateLMS(data.female, 30.5).M), 1415);
  assert.equal(neonatal.classifyGA(36, 6).label, 'Late Preterm');
  assert.equal(neonatal.classifyBirthWeight(900).label, 'Extremely Low Birth Weight (ELBW)');
  assert.equal(neonatal.classifyWeight(50).label, 'AGA');
});

test('equipment.json preserves equipment age groups and anchors', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'equipment.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  assert.deepEqual(Object.keys(data.ageGroups), [
    'premie',
    'newborn',
    '6mo',
    '1yr',
    '2-3yr',
    '4-6yr',
    '7-10yr',
    '11-15yr',
    '16yr'
  ]);
  assert.equal(data.ageGroups.newborn.ett, '3.0-3.5');
  assert.equal(data.ageGroups['1yr'].lma, '2');
  assert.equal(data.ageGroups['4-6yr'].blade, 'Miller 2 / MAC 2');
  assert.equal(data.ageGroups['16yr'].foley, '12 Fr');
});

test('equipment.json entries have complete renderable fields', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'equipment.json'), 'utf8');
  const groups = JSON.parse(raw).ageGroups;
  Object.entries(groups).forEach(([key, group]) => {
    ['label', 'bvm', 'nasal', 'oral', 'blade', 'ett', 'lma', 'glidescope', 'iv', 'cvl', 'ngt', 'chest', 'foley'].forEach((field) => {
      assert.ok(group[field], `${key}.${field}`);
    });
  });
});

test('bhutani-zones.json preserves risk-zone curves', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bhutani-zones.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  assert.deepEqual(Object.keys(data.zones), ['p95', 'p75', 'p40']);
  assert.equal(data.zones.p95['24'], 9.6);
  assert.equal(data.zones.p75['48'], 12.6);
  assert.equal(data.zones.p40['120'], 13.2);
});

test('bilirubin helpers preserve Bhutani interpolation and classification', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bhutani-zones.json'), 'utf8');
  const zones = JSON.parse(raw).zones;
  assert.equal(bilirubin.interpolateThreshold(zones.p95, 21), 9.05);
  assert.equal(bilirubin.classifyBhutaniRisk(zones, 24, 10).zone, 'High-Risk Zone');
  assert.equal(bilirubin.classifyBhutaniRisk(zones, 24, 8).zone, 'High-Intermediate Zone');
  assert.equal(bilirubin.classifyBhutaniRisk(zones, 24, 7).zone, 'Low-Intermediate Zone');
  assert.equal(bilirubin.classifyBhutaniRisk(zones, 24, 5).zone, 'Low-Risk Zone');
});

test('aap-bilirubin-thresholds.json preserves treatment threshold anchors', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  assert.deepEqual(Object.keys(data.phototherapy.noRisk), ['35', '36', '37', '38', '39', '40']);
  assert.deepEqual(Object.keys(data.phototherapy.risk), ['35', '36', '37', '38']);
  assert.deepEqual(Object.keys(data.exchange.noRisk), ['35', '36', '37', '38']);
  assert.deepEqual(Object.keys(data.exchange.risk), ['35', '36', '37', '38']);
  assert.equal(data.phototherapy.noRisk['35']['24'], 10.6);
  assert.equal(data.phototherapy.noRisk['40']['48'], 17.0);
  assert.equal(data.phototherapy.risk['38']['72'], 16.6);
  assert.equal(data.exchange.noRisk['38']['96'], 27.0);
  assert.equal(data.exchange.risk['35']['24'], 16.1);
});

test('bilirubin helpers preserve AAP 2022 GA plateau selection and interpolation', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(bilirubin.interpolateThreshold(data.phototherapy.noRisk['35'], 12.5), 8.6);
  assert.equal(bilirubin.selectAapBilirubinThresholdTables(data, 41, 'none').phototherapy['48'], 17.0);
  assert.equal(bilirubin.selectAapBilirubinThresholdTables(data, 39, 'none').phototherapy['48'], 16.6);
  assert.equal(bilirubin.selectAapBilirubinThresholdTables(data, 41, 'medium').phototherapy['48'], 14.0);
  assert.equal(bilirubin.selectAapBilirubinThresholdTables(data, 40, 'none').exchange['48'], 24.0);
});

test('AAP bilirubin sample calculation below phototherapy threshold', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  const assessment = bilirubin.calculateAapBilirubinAssessment(data, 40, 48, 16.0, 'none');
  assert.equal(assessment.phototherapyThreshold, 17.0);
  assert.equal(assessment.exchangeThreshold, 24.0);
  assert.equal(assessment.phototherapyMargin, -1.0);
  assert.equal(assessment.exchangeMargin, -8.0);
  assert.equal(assessment.abovePhototherapy, false);
  assert.equal(assessment.aboveExchange, false);
  assert.equal(assessment.status, 'below');
});

test('AAP bilirubin sample calculation above phototherapy threshold', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  const assessment = bilirubin.calculateAapBilirubinAssessment(data, 39, 48, 17.0, 'none');
  assert.equal(assessment.phototherapyThreshold, 16.6);
  assert.equal(assessment.exchangeThreshold, 24.0);
  assert.equal(Math.round(assessment.phototherapyMargin * 10) / 10, 0.4);
  assert.equal(assessment.abovePhototherapy, true);
  assert.equal(assessment.aboveExchange, false);
  assert.equal(assessment.status, 'phototherapy');
});

test('AAP bilirubin sample calculation above exchange threshold', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  const assessment = bilirubin.calculateAapBilirubinAssessment(data, 35, 24, 16.2, 'medium');
  assert.equal(assessment.phototherapyThreshold, 8.9);
  assert.equal(assessment.exchangeThreshold, 16.1);
  assert.equal(Math.round(assessment.phototherapyMargin * 10) / 10, 7.3);
  assert.equal(Math.round(assessment.exchangeMargin * 10) / 10, 0.1);
  assert.equal(assessment.abovePhototherapy, true);
  assert.equal(assessment.aboveExchange, true);
  assert.equal(assessment.status, 'exchange');
});

test('AAP bilirubin sample calculation interpolates fractional age', async () => {
  const bilirubin = await import('../public/js/calculators/bilirubin.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'aap-bilirubin-thresholds.json'), 'utf8');
  const data = JSON.parse(raw);
  const assessment = bilirubin.calculateAapBilirubinAssessment(data, 35, 12.5, 8.55, 'none');
  assert.equal(assessment.phototherapyThreshold, 8.6);
  assert.equal(assessment.abovePhototherapy, false);
  assert.equal(assessment.status, 'below');
});

test('bmi-lms.json exposes complete CDC BMI-for-age tables', () => {
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bmi-lms.json'), 'utf8');
  const data = JSON.parse(raw);
  assert.equal(data.version, '1.0');
  ['male', 'female'].forEach((sex) => {
    const ages = Object.keys(data.lms[sex]).map(Number).sort((a, b) => a - b);
    assert.equal(ages[0], 24);
    assert.equal(ages[ages.length - 1], 240);
    assert.equal(ages.length, 37);
    ages.forEach((age) => {
      const row = data.lms[sex][age];
      assert.equal(typeof row.L, 'number', `${sex}.${age}.L`);
      assert.equal(typeof row.M, 'number', `${sex}.${age}.M`);
      assert.equal(typeof row.S, 'number', `${sex}.${age}.S`);
    });
  });
});

test('BMI sample calculation preserves healthy-weight result', async () => {
  const bmi = await import('../public/js/calculators/bmi.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bmi-lms.json'), 'utf8');
  const data = JSON.parse(raw).lms;
  const assessment = bmi.calculateBMIAssessment(data, 'male', 10, 32, 140);
  assert.equal(assessment.ageMonths, 120);
  assert.equal(Number(assessment.bmi.toFixed(1)), 16.3);
  assert.equal(Number(assessment.z.toFixed(2)), -0.17);
  assert.equal(assessment.percentile, 43.42);
  assert.equal(assessment.classification.text, 'Healthy Weight');
});

test('BMI sample calculation preserves obesity classification', async () => {
  const bmi = await import('../public/js/calculators/bmi.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bmi-lms.json'), 'utf8');
  const data = JSON.parse(raw).lms;
  const assessment = bmi.calculateBMIAssessment(data, 'male', 12, 70, 150);
  assert.equal(Number(assessment.bmi.toFixed(1)), 31.1);
  assert.equal(assessment.percentile, 98.97);
  assert.equal(assessment.classification.text, 'Class 2 Severe Obesity');
  assert.equal(Number(assessment.classification.pctOf95.toFixed(0)), 128);
  assert.equal(Number(assessment.classification.bmi95.toFixed(1)), 24.2);
});

test('BMI sample calculation preserves fractional-age interpolation', async () => {
  const bmi = await import('../public/js/calculators/bmi.js');
  const raw = fs.readFileSync(path.join(__dirname, '..', 'public', 'data', 'calculators', 'bmi-lms.json'), 'utf8');
  const data = JSON.parse(raw).lms;
  const lms = bmi.interpolateLMS(data.male, 123);
  assert.equal(Number(lms.M.toFixed(4)), 16.7806);
  const assessment = bmi.calculateBMIAssessment(data, 'male', 10.5, 40, 145);
  assert.equal(assessment.ageMonths, 126);
  assert.equal(assessment.percentile, 79.26);
  assert.equal(assessment.classification.text, 'Healthy Weight');
});