import { NextDraw } from '../src/nextdraw.js';

import { EBBSimulator, VirtualClock } from '../src/sim/ebb-sim.js';

/** A connected-ready NextDraw wired to a simulated machine. */

export function makeMachine(simOptions = {}, configure = null) {

  const clock = new VirtualClock();

  const sim = new EBBSimulator({ clock, ...simOptions });

  const messages = [];

  const nd = new NextDraw({ transport: sim, clock, log: (m) => messages.push(m) });

  nd.interactive();

  configure?.(nd);

  return { nd, sim, clock, messages };

}

export async function connected(simOptions = {}, configure = null) {

  const m = makeMachine(simOptions, configure);

  const ok = await m.nd.connect();

  if (!ok) throw new Error(`connect failed: ${m.messages.join(' / ')}`);

  return m;

}

/** Deterministic PRNG (mulberry32) so failures are reproducible. */

export function rng(seed) {

  let a = seed >>> 0;

  return () => {

    a = (a + 0x6d2b79f5) >>> 0;

    let t = a;

    t = Math.imul(t ^ (t >>> 15), t | 1);

    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);

    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;

  };

}

function pointSegmentDistance(p, a, b) {

  const dx = b[0] - a[0];

  const dy = b[1] - a[1];

  const len2 = dx * dx + dy * dy;

  let t = len2 > 0 ? ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2 : 0;

  t = Math.max(0, Math.min(1, t));

  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));

}

export function distanceToPolylines(p, polylines) {

  let best = Infinity;

  for (const line of polylines) {

    if (line.length === 1) best = Math.min(best, Math.hypot(p[0] - line[0][0], p[1] - line[0][1]));

    for (let i = 1; i < line.length; i++) best = Math.min(best, pointSegmentDistance(p, line[i - 1], line[i]));

  }

  return best;

}

/** Two-sided (Hausdorff-style, vertex-sampled) distance between polyline sets. */

export function polylineSetDistance(a, b) {

  let worst = 0;

  for (const line of a) for (const p of line) worst = Math.max(worst, distanceToPolylines(p, b));

  for (const line of b) for (const p of line) worst = Math.max(worst, distanceToPolylines(p, a));

  return worst;

}

/** Commands sent, with status polling (QG) removed. */

export function commands(sim) {

  return sim.log.map((l) => l.cmd).filter((c) => c !== 'QG');

}