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

const NodeClass = require('../../src/nodeClass');
const { makeNodeStub } = require('../helpers/factories');

test('_tick emits source effluent on process output', () => {
  const inst = Object.create(NodeClass.prototype);
  const node = makeNodeStub();

  inst.node = node;
  inst.source = {
    get getEffluent() {
      return { topic: 'Fluent', payload: { inlet: 0, F: 1, C: [] }, timestamp: 1 };
    },
  };

  inst._tick();

  assert.equal(node._sent.length, 1);
  assert.equal(node._sent[0][0].topic, 'Fluent');
  assert.equal(node._sent[0][1], null);
  assert.equal(node._sent[0][2], null);
});

test('_startTickLoop schedules periodic tick after startup delay', () => {
  const inst = Object.create(NodeClass.prototype);
  const delays = [];
  const intervals = [];
  let tickCount = 0;

  inst._tick = () => {
    tickCount += 1;
  };

  const originalSetTimeout = global.setTimeout;
  const originalSetInterval = global.setInterval;

  global.setTimeout = (fn, ms) => {
    delays.push(ms);
    fn();
    return 10;
  };

  global.setInterval = (fn, ms) => {
    intervals.push(ms);
    fn();
    return 22;
  };

  try {
    inst._startTickLoop();
  } finally {
    global.setTimeout = originalSetTimeout;
    global.setInterval = originalSetInterval;
  }

  assert.deepEqual(delays, [1000]);
  assert.deepEqual(intervals, [1000]);
  assert.equal(inst._tickInterval, 22);
  assert.equal(tickCount, 1);
});

test('_attachCloseHandler clears tick interval and calls done callback', () => {
  const inst = Object.create(NodeClass.prototype);
  const node = makeNodeStub();
  inst.node = node;
  inst._tickInterval = 55;

  const cleared = [];
  const originalClearInterval = global.clearInterval;
  global.clearInterval = (id) => {
    cleared.push(id);
  };

  let doneCalled = 0;

  try {
    inst._attachCloseHandler();
    node._handlers.close(() => {
      doneCalled += 1;
    });
  } finally {
    global.clearInterval = originalClearInterval;
  }

  assert.deepEqual(cleared, [55]);
  assert.equal(doneCalled, 1);
});