import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { VIEW_CONTRACT } from "yt-dlp-transcript-common/views/names";
import type { CleanableChannel } from "yt-dlp-transcript-common/views/cleanable";
import type { CleanableChannelRow } from "../../cleanup/lib/loadCleanup";

// Run with:
//   pnpm -C editor exec tsx --test "app/**/*.test.ts"

const HERE = path.dirname(fileURLToPath(import.meta.url));

// THE OBSERVE CONTRACT, CHECKED AS TEXT.
//
// `VIEW_CONTRACT.pulse === "observe"` is a promise about what the handler does,
// and only the handler can keep it. The ban below is the same trick the corpus
// walk guard uses (common/controller/noCorpusWalkInRenderPaths.test.ts): read
// the file and refuse the names that construct. It is crude and it is the
// reason ~16 specs stopped flaking — a pulse poll that builds the registry, the
// settings or the worker pool races the singletons the page under test is
// setting up, on a 1-second timer, forever.
//
// The same ban covers the DISPATCHER (`[name]/route.ts`). The tempting
// optimisation is one shared constructor hoisted above the table "so every
// view gets its inputs for free" — which puts pulse on the constructing path
// again. Each handler in views.ts builds its own inputs; the dispatcher builds
// none, and this makes that a failing test rather than a comment.
//
// THE MATCH IS CONTEXT-BLIND, deliberately: a comment naming one of these with
// its parenthesis fails too. Reword the comment; do not loosen the test.
const CONSTRUCTORS = [
  "liveInputs(",
  "getRegistry(",
  "getSettings(",
  "getWorkerPool(",
];

test("the pulse view observes and never constructs", () => {
  const src = readFileSync(path.join(HERE, "pulseView.ts"), "utf8");
  assert.equal(VIEW_CONTRACT.pulse, "observe");
  // Guard the guard: if the file stops naming the observer, the ban below is
  // checking an empty claim.
  assert.ok(
    src.includes("observeInputs("),
    "pulseView.ts must read its inputs through observeInputs()",
  );
  for (const banned of CONSTRUCTORS) {
    assert.ok(
      !src.includes(banned),
      `pulseView.ts names ${banned} — the pulse view may not construct`,
    );
  }
});

test("the dispatcher constructs nothing before it picks a view", () => {
  const src = readFileSync(path.join(HERE, "[name]", "route.ts"), "utf8");
  // Guard the guard: this is the file that dispatches.
  assert.ok(src.includes("VIEWS[name]("), "[name]/route.ts must dispatch");
  for (const banned of CONSTRUCTORS) {
    assert.ok(
      !src.includes(banned),
      `[name]/route.ts names ${banned} — the dispatcher may not construct`,
    );
  }
});

// THE CLEANABLE ROW, ASSERTED AT COMPILE TIME.
//
// `common/views/cleanable.ts` re-declares the loader's row structurally rather
// than importing it, because a view may not reach into the app. That only keeps
// working while the two stay assignable, and tsc fails HERE — naming both
// types — instead of somewhere inside the handler table.
//
// Tuple-wrapped on both sides: a bare `A extends B ?` DISTRIBUTES over a union
// and a non-assignable member would collapse to `never`, making `true | never`
// = `true` (see common/views/streamAction.test.ts, which paid for that lesson).
type AssignableTo<A, B> = [A] extends [B] ? true : never;
const _rowIsAChannel: AssignableTo<CleanableChannelRow, CleanableChannel> = true;

test("CleanableChannelRow is assignable to the view's CleanableChannel", () => {
  assert.equal(_rowIsAChannel, true);
});