import { test } from "node:test";
import assert from "node:assert/strict";
import { parseScenario } from "../src/declaration/parse.ts";
import { assertSupported, UnsupportedError } from "../src/lifecycle/supported.ts";

/**
 * A declaration the runtime silently ignores is the fault this lab exists to catch —
 * novox/hq 04-ISSUES/003, where a firewall key is declared in five manifests and read by no
 * code. These tests exist so the lab never commits it, and they move as the runtime catches
 * up with the model.
 */

const withGateway = `scenario: x
segments:
  pub: { kind: public, cidr: [192.0.2.0/24] }
  home: { kind: private, cidr: [192.168.1.0/24], gateway: { to: pub, address: [192.0.2.5], nat: [v4] } }
machines: { a: { at: { segment: home, address: [192.168.1.9] } } }`;

test("a plain scenario is raisable", () => {
  const scenario = parseScenario(`scenario: x
segments: { net: { kind: public, cidr: [192.0.2.0/24] } }
machines: { a: { at: { segment: net, address: [192.0.2.1] } } }`);
  assert.doesNotThrow(() => assertSupported(scenario));
});

test("gateways are implemented — a router is materialised for them", () => {
  assert.doesNotThrow(() => assertSupported(parseScenario(withGateway)));
});

test("published ports and policy are implemented", () => {
  const scenario = parseScenario(`scenario: x
segments:
  pub: { kind: public, cidr: [192.0.2.0/24] }
  home: { kind: private, cidr: [192.168.1.0/24], gateway: { to: pub, address: [192.0.2.5], nat: [v4] } }
  iot: { kind: private, cidr: [192.168.30.0/24], gateway: { to: pub, address: [192.0.2.5], nat: [v4] } }
policy: [{ from: iot, to: home, allow: false }]
machines:
  a:
    at: { segment: home, address: [192.168.1.9] }
    published: [{ port: 443, on: home }]`);
  assert.doesNotThrow(() => assertSupported(scenario));
});

test("inbound: deny is implemented — a host firewall is applied and read back", () => {
  const scenario = parseScenario(`scenario: x
segments: { net: { kind: public, cidr: [192.0.2.0/24] } }
machines: { a: { at: { segment: net, address: [192.0.2.1] }, inbound: deny } }`);
  assert.doesNotThrow(() => assertSupported(scenario));
});

test("place is still refused — there is nothing to place yet", () => {
  const scenario = parseScenario(`scenario: x
segments: { net: { kind: public, cidr: [192.0.2.0/24] } }
machines: { a: { at: { segment: net, address: [192.0.2.1] } } }
place: { all: [host] }`);
  assert.throws(() => assertSupported(scenario), UnsupportedError);
});

test("the refusal explains what would silently be missing", () => {
  const scenario = parseScenario(`scenario: x
segments: { net: { kind: public, cidr: [192.0.2.0/24] } }
machines: { a: { at: { segment: net, address: [192.0.2.1] } } }
place: { all: [host] }`);
  try {
    assertSupported(scenario);
    assert.fail("should have refused");
  } catch (err) {
    assert.equal((err as UnsupportedError).missing.length, 1);
    assert.match(err instanceof Error ? err.message : "", /silently lacks them/);
  }
});

test("inbound: allow is not a gap — only deny needs enforcing", () => {
  const scenario = parseScenario(`scenario: x
segments: { net: { kind: public, cidr: [192.0.2.0/24] } }
machines: { a: { at: { segment: net, address: [192.0.2.1] }, inbound: allow } }`);
  assert.doesNotThrow(() => assertSupported(scenario));
});