'use strict';

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

const DashboardApi = require('../../src/specificClass.js');

function makeChild(i, softwareType = 'measurement', positionVsParent = 'downstream') {
  return {
    child: {
      config: {
        general: { id: `child-${i}`, name: `Child ${i}` },
        functionality: { softwareType, positionVsParent },
      },
    },
    softwareType,
    position: positionVsParent,
    registeredAt: Date.now(),
  };
}

function makeRoot(children) {
  const map = new Map();
  for (const c of children) map.set(c.child.config.general.id, c);
  return {
    config: {
      general: { id: 'root-1', name: 'Root' },
      functionality: { softwareType: 'dashboardapi', positionVsParent: 'atequipment' },
    },
    childRegistrationUtils: { registeredChildren: map },
  };
}

test('generateDashboardsForGraph composes 50 children in <500ms', () => {
  const api = new DashboardApi({});
  const children = Array.from({ length: 50 }, (_, i) => makeChild(i));
  const root = makeRoot(children);

  const t0 = process.hrtime.bigint();
  const dashboards = api.generateDashboardsForGraph(root, { includeChildren: true });
  const t1 = process.hrtime.bigint();

  const durationMs = Number(t1 - t0) / 1e6;
  assert.ok(durationMs < 500, `composition took ${durationMs.toFixed(1)}ms, expected <500ms`);
  assert.ok(dashboards.length >= 1, 'should produce at least the root dashboard');
});

test('uids are unique across all generated dashboards (no collision risk)', () => {
  const api = new DashboardApi({});
  const children = Array.from({ length: 30 }, (_, i) => makeChild(i, 'measurement'));
  const root = makeRoot(children);
  const dashboards = api.generateDashboardsForGraph(root);
  const uids = dashboards.map((d) => d.uid);
  const unique = new Set(uids);
  assert.equal(unique.size, uids.length, `expected ${uids.length} unique uids, got ${unique.size}`);
});

test('byte-identical composition under repeat (idempotency)', () => {
  const api = new DashboardApi({});
  const children = Array.from({ length: 5 }, (_, i) => makeChild(i));
  const root = makeRoot(children);
  const first = JSON.stringify(api.generateDashboardsForGraph(root).map((d) => d.dashboard));
  const second = JSON.stringify(api.generateDashboardsForGraph(root).map((d) => d.dashboard));
  assert.equal(first, second, 'two consecutive compositions should produce byte-identical JSON');
});

test('root dashboard links to every child dashboard', () => {
  const api = new DashboardApi({});
  const children = Array.from({ length: 4 }, (_, i) => makeChild(i));
  const root = makeRoot(children);
  const dashboards = api.generateDashboardsForGraph(root);
  const rootDash = dashboards[0].dashboard;
  assert.ok(Array.isArray(rootDash.links), 'root dashboard should have links array');
  assert.equal(rootDash.links.length, 4, 'one link per registered child');
});