const test = require('node:test');
const assert = require('node:assert/strict');

const Machine = require('../../src/specificClass');
const { makeMachineConfig, makeStateConfig } = require('../helpers/factories');

test('calcEfficiency runs through coolprop path without mocks', () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  machine.measurements.type('pressure').variant('measured').position('downstream').value(1200, Date.now(), 'mbar');
  machine.measurements.type('pressure').variant('measured').position('upstream').value(800, Date.now(), 'mbar');
  machine.measurements.type('flow').variant('predicted').position('atEquipment').value(120, Date.now(), 'm3/h');
  machine.measurements.type('power').variant('predicted').position('atEquipment').value(12, Date.now(), 'kW');

  assert.doesNotThrow(() => {
    machine.calcEfficiency(12, 120, 'predicted');
  });

  const eff = machine.measurements.type('efficiency').variant('predicted').position('atEquipment').getCurrentValue();
  assert.equal(typeof eff, 'number');
  assert.ok(eff > 0);

  const pressureDiffPa = (1200 - 800) * 100; // mbar -> Pa
  const flowM3s = 120 / 3600; // m3/h -> m3/s
  const expectedHydraulicPower = pressureDiffPa * flowM3s;
  const expectedHydraulicEfficiency = expectedHydraulicPower / 12000; // 12kW -> W

  const hydraulicPower = machine.measurements.type('hydraulicPower').variant('predicted').position('atEquipment').getCurrentValue('W');
  const hydraulicEfficiency = machine.measurements.type('nHydraulicEfficiency').variant('predicted').position('atEquipment').getCurrentValue();
  const head = machine.measurements.type('pumpHead').variant('predicted').position('atEquipment').getCurrentValue('m');

  assert.ok(Number.isFinite(hydraulicPower));
  assert.ok(Number.isFinite(hydraulicEfficiency));
  assert.ok(Number.isFinite(head));
  assert.ok(Math.abs(hydraulicPower - expectedHydraulicPower) < 1);
  assert.ok(Math.abs(hydraulicEfficiency - expectedHydraulicEfficiency) < 0.01);
});

test('predictions use initialized medium pressure and not the minimum-pressure fallback', () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  const mediumUpstreamMbar = 700;
  const mediumDownstreamMbar = 1100;
  machine.updateMeasuredPressure(mediumUpstreamMbar, 'upstream', { timestamp: Date.now(), unit: 'mbar', childName: 'test-pt-up' });
  machine.updateMeasuredPressure(mediumDownstreamMbar, 'downstream', { timestamp: Date.now(), unit: 'mbar', childName: 'test-pt-down' });

  const pressureStatus = machine.getPressureInitializationStatus();
  assert.equal(pressureStatus.initialized, true);
  assert.equal(pressureStatus.hasDifferential, true);

  const rawDiff = (mediumDownstreamMbar - mediumUpstreamMbar) * 100; // mbar -> Pa = 40000
  // fDimension is clamped to [fValues.min, fValues.max]. The H05K curve's
  // minimum pressure slice is 70000 Pa (700 mbar). A 40000 Pa differential
  // is below the curve minimum, so it gets clamped to 70000.
  const curveMinPressure = 70000;
  const expected = Math.max(rawDiff, curveMinPressure);
  assert.equal(Math.round(machine.predictFlow.fDimension), expected);
  assert.ok(machine.predictFlow.fDimension > 0);
});