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

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

test('pressure initialization combinations are handled explicitly', () => {
  const createMachine = () => new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  // nothing
  let machine = createMachine();
  let status = machine.getPressureInitializationStatus();
  assert.equal(status.initialized, false);
  assert.equal(status.source, null);
  const noPressureValue = machine.getMeasuredPressure();
  assert.equal(noPressureValue, 0);
  // With no pressure injected, fDimension is clamped to the curve minimum
  // (70000 Pa for H05K). Previously a schema default at pressure "1" made
  // fValues.min=1 — that was a data-poisoning bug, now fixed.
  assert.ok(machine.predictFlow.fDimension >= 70000);

  // upstream only
  machine = createMachine();
  const upstreamOnly = 850;
  machine.measurements.type('pressure').variant('measured').position('upstream').value(upstreamOnly, Date.now(), 'mbar');
  status = machine.getPressureInitializationStatus();
  assert.equal(status.initialized, true);
  assert.equal(status.hasUpstream, true);
  assert.equal(status.hasDownstream, false);
  assert.equal(status.hasDifferential, false);
  assert.equal(status.source, 'upstream');
  const upstreamValue = machine.getMeasuredPressure();
  assert.equal(Math.round(upstreamValue), upstreamOnly * 100);
  assert.equal(Math.round(machine.predictFlow.fDimension), upstreamOnly * 100);

  // downstream only
  machine = createMachine();
  const downstreamOnly = 1150;
  machine.measurements.type('pressure').variant('measured').position('downstream').value(downstreamOnly, Date.now(), 'mbar');
  status = machine.getPressureInitializationStatus();
  assert.equal(status.initialized, true);
  assert.equal(status.hasUpstream, false);
  assert.equal(status.hasDownstream, true);
  assert.equal(status.hasDifferential, false);
  assert.equal(status.source, 'downstream');
  const downstreamValue = machine.getMeasuredPressure();
  assert.equal(Math.round(downstreamValue), downstreamOnly * 100);
  assert.equal(Math.round(machine.predictFlow.fDimension), downstreamOnly * 100);

  // downstream and upstream — pick values whose differential (Pa) is above
  // the curve's minimum pressure slice (70000 Pa = 700 mbar for H05K).
  // 200 mbar upstream + 1100 mbar downstream → diff = 900 mbar = 90000 Pa.
  machine = createMachine();
  const upstream = 200;
  const downstream = 1100;
  machine.measurements.type('pressure').variant('measured').position('upstream').value(upstream, Date.now(), 'mbar');
  machine.measurements.type('pressure').variant('measured').position('downstream').value(downstream, Date.now(), 'mbar');
  status = machine.getPressureInitializationStatus();
  assert.equal(status.initialized, true);
  assert.equal(status.hasUpstream, true);
  assert.equal(status.hasDownstream, true);
  assert.equal(status.hasDifferential, true);
  assert.equal(status.source, 'differential');
  const differentialValue = machine.getMeasuredPressure();
  assert.equal(Math.round(differentialValue), (downstream - upstream) * 100);
  assert.equal(Math.round(machine.predictFlow.fDimension), (downstream - upstream) * 100);
});

test('real pressure child data has priority over simulated dashboard pressure', async () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  machine.updateSimulatedMeasurement('pressure', 'upstream', 900, { unit: 'mbar', timestamp: Date.now() });
  machine.updateSimulatedMeasurement('pressure', 'downstream', 1200, { unit: 'mbar', timestamp: Date.now() });
  assert.equal(Math.round(machine.getMeasuredPressure()), 30000);

  const upstreamChild = makeChildMeasurement({ id: 'pt-up-real', name: 'PT Up', positionVsParent: 'upstream', type: 'pressure', unit: 'mbar' });
  const downstreamChild = makeChildMeasurement({ id: 'pt-down-real', name: 'PT Down', positionVsParent: 'downstream', type: 'pressure', unit: 'mbar' });

  await machine.childRegistrationUtils.registerChild(upstreamChild, 'upstream');
  await machine.childRegistrationUtils.registerChild(downstreamChild, 'downstream');

  upstreamChild.measurements.type('pressure').variant('measured').position('upstream').value(700, Date.now(), 'mbar');
  downstreamChild.measurements.type('pressure').variant('measured').position('downstream').value(1300, Date.now(), 'mbar');

  assert.equal(Math.round(machine.getMeasuredPressure()), 60000);
  const status = machine.getPressureInitializationStatus();
  assert.equal(status.source, 'differential');
  assert.equal(status.initialized, true);
});