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

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

test('setpoint rejects negative inputs without throwing', async () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));
  await assert.doesNotReject(async () => {
    await machine.setpoint(-1);
  });
});

test('setpoint is constrained to safe movement/curve bounds', async () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));
  const requested = [];
  machine.state.moveTo = async (target) => {
    requested.push(target);
  };

  const stateMin = machine.state.movementManager.minPosition;
  const stateMax = machine.state.movementManager.maxPosition;
  const curveMin = machine.predictFlow.currentFxyXMin;
  const curveMax = machine.predictFlow.currentFxyXMax;
  const min = Math.max(stateMin, curveMin);
  const max = Math.min(stateMax, curveMax);

  await machine.setpoint(min - 100);
  await machine.setpoint(max + 100);

  assert.equal(requested.length, 2);
  assert.equal(requested[0], min);
  assert.equal(requested[1], max);
});

test('nodeClass _updateNodeStatus returns error status on internal failure', () => {
  const inst = Object.create(NodeClass.prototype);
  const node = makeNodeStub();
  inst.node = node;
  inst.source = {
    currentMode: 'auto',
    state: {
      getCurrentState() {
        throw new Error('boom');
      },
    },
  };

  const status = inst._updateNodeStatus();
  assert.equal(status.text, 'Status Error');
  assert.equal(node._errors.length, 1);
});

test('measurement handlers reject incompatible units', () => {
  const machine = new Machine(makeMachineConfig(), makeStateConfig({ state: { current: 'operational' } }));

  assert.equal(machine.isUnitValidForType('flow', 'm3/h'), true);
  assert.equal(machine.isUnitValidForType('flow', 'mbar'), false);

  machine.updateMeasuredFlow(100, 'downstream', {
    timestamp: Date.now(),
    unit: 'mbar',
    childName: 'bad-ft',
  });

  const measuredFlow = machine.measurements
    .type('flow')
    .variant('measured')
    .position('downstream')
    .getCurrentValue();

  assert.equal(measuredFlow, null);
});