'use strict';

// Phase 10 rewrite: drives only the public BaseNodeAdapter surface.
// The pre-refactor _loadConfig / _setupClass private methods are gone —
// config build is exposed via buildDomainConfig (override hook in
// CONTRACTS.md §2), and engine selection is observable via
// `inst.source.engine instanceof Reactor_CSTR | Reactor_PFR` after a
// full `new nodeClass(...)` construction.

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

const nodeClass = require('../../src/nodeClass');
const { Reactor_CSTR, Reactor_PFR } = require('../../src/specificClass');
const { makeUiConfig } = require('../helpers/factories');

function makeRED() { return { nodes: { getNode: () => null } }; }

function makeNode(id = 'reactor-1') {
  const sends = [];
  const statuses = [];
  const handlers = {};
  return {
    id, sends, statuses, handlers,
    send(arr)  { sends.push(arr); },
    status(b)  { statuses.push(b); },
    on(ev, fn) { handlers[ev] = fn; },
    warn() {}, error() {},
  };
}

function closeNode(node) {
  if (node.handlers.close) node.handlers.close(() => {});
}

test('buildDomainConfig coerces numeric fields and builds initial state vector', () => {
  const node = makeNode();
  const inst = new nodeClass(makeUiConfig(), makeRED(), node, 'reactor');
  try {
    const dc = inst.buildDomainConfig(
      makeUiConfig({
        volume: '12.5',
        length: '9',
        resolution_L: '7',
        alpha: '0.5',
        n_inlets: '3',
        timeStep: '2',
        S_O_init: '1.1',
      }),
    );

    assert.equal(dc.reactor.volume, 12.5);
    assert.equal(dc.reactor.length, 9);
    assert.equal(dc.reactor.resolution_L, 7);
    assert.equal(dc.reactor.alpha, 0.5);
    assert.equal(dc.reactor.n_inlets, 3);
    assert.equal(dc.reactor.timeStep, 2);
    assert.equal(Object.keys(dc.initialState).length, 13);
    assert.equal(dc.initialState.S_O, 1.1);
  } finally {
    closeNode(node);
  }
});

test('Reactor wrapper instantiates CSTR engine when configured as CSTR', () => {
  const node = makeNode();
  const inst = new nodeClass(makeUiConfig({ reactor_type: 'CSTR' }), makeRED(), node, 'reactor');
  try {
    assert.ok(inst.source.engine instanceof Reactor_CSTR);
  } finally {
    closeNode(node);
  }
});

test('Reactor wrapper instantiates PFR engine when configured as PFR', () => {
  const node = makeNode();
  const inst = new nodeClass(makeUiConfig({ reactor_type: 'PFR' }), makeRED(), node, 'reactor');
  try {
    assert.ok(inst.source.engine instanceof Reactor_PFR);
  } finally {
    closeNode(node);
  }
});