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);
  assert.ok(machine.predictFlow.fDimension <= 1);

  // 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);
  assert.equal(Math.round(machine.predictFlow.fDimension), upstreamOnly);

  // 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);
  assert.equal(Math.round(machine.predictFlow.fDimension), downstreamOnly);

  // downstream and upstream
  machine = createMachine();
  const upstream = 700;
  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);
  assert.equal(Math.round(machine.predictFlow.fDimension), downstream - upstream);
});

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()), 300);

  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()), 600);
  const status = machine.getPressureInitializationStatus();
  assert.equal(status.source, 'differential');
  assert.equal(status.initialized, true);
});