// @vitest-environment node
import { readFile } from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it } from "vitest";
import {
  DASHBOARD_PLATFORM_PAGES,
  dashboardPath,
  parseDashboardPath,
} from "../src/dashboard-routes.js";

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

describe("the Dashboard's own top-level pages", () => {
  it("are exactly Settings and Account, frozen", () => {
    expect(Object.isFrozen(DASHBOARD_PLATFORM_PAGES)).toBe(true);
    expect(DASHBOARD_PLATFORM_PAGES).toEqual(["settings", "account"]);
  });
});

describe("parseDashboardPath", () => {
  it("makes the root the Overview", () => {
    expect(parseDashboardPath("/")).toEqual({ kind: "overview" });
  });

  it("names a module page by its id at the top level, tolerating one trailing slash", () => {
    expect(parseDashboardPath("/signage")).toEqual({ kind: "module", moduleId: "signage" });
    expect(parseDashboardPath("/signage/")).toEqual({ kind: "module", moduleId: "signage" });
    expect(parseDashboardPath("/people")).toEqual({ kind: "module", moduleId: "people" });
  });

  it("decodes a percent-encoded segment, so an id is compared as the server spells it", () => {
    expect(parseDashboardPath("/sign%61ge")).toEqual({ kind: "module", moduleId: "signage" });
  });

  it("never reads a platform page as a module page", () => {
    for (const pathname of ["/settings", "/settings/", "/account", "/account/appearance"]) {
      expect(parseDashboardPath(pathname), pathname).toEqual({ kind: "not-found" });
    }
  });

  it("treats every other shape as not found rather than guessing", () => {
    for (const pathname of [
      "",
      "//",
      "//signage",
      "/signage//",
      // A module's own sub-pages need a contract that does not exist yet (ADR 0057).
      "/signage/timelines",
      "/signage/timelines/abc",
      "/%E0%A4%A",
      "/settings/displays/add",
      "signage",
    ]) {
      expect(parseDashboardPath(pathname), pathname).toEqual({ kind: "not-found" });
    }
  });
});

describe("dashboardPath", () => {
  it("spells each route canonically, with no implementation prefix", () => {
    expect(dashboardPath({ kind: "overview" })).toBe("/");
    expect(dashboardPath({ kind: "module", moduleId: "signage" })).toBe("/signage");
  });

  it("encodes a module id so it can never escape its own segment", () => {
    expect(dashboardPath({ kind: "module", moduleId: "a/../b" })).toBe("/a%2F..%2Fb");
    expect(parseDashboardPath(dashboardPath({ kind: "module", moduleId: "a/../b" }))).toEqual({
      kind: "module",
      moduleId: "a/../b",
    });
  });

  it("round-trips through the parser", () => {
    for (const route of [
      { kind: "overview" } as const,
      { kind: "module", moduleId: "example" } as const,
    ]) {
      expect(parseDashboardPath(dashboardPath(route))).toEqual(route);
    }
  });
});

describe("the route locator is published for the API that serves the page", () => {
  it("is a narrow package subpath, not the shell root barrel", async () => {
    const manifest = JSON.parse(
      await readFile(path.join(packageDirectory, "package.json"), "utf8"),
    ) as { exports?: Record<string, unknown> };
    expect(manifest.exports?.["./dashboard-routes"]).toEqual({
      import: "./dist/dashboard-routes.js",
      types: "./dist/dashboard-routes.d.ts",
    });
  });
});