import { readFileSync } from "node:fs";
import {
    hostOwnerId,
    labelHostname,
    panelFromHost,
    portHostname,
    portLabel,
    portSlotFromHost,
    portUrl,
    previewHostname,
    previewLabel,
    previewUrl,
    publicSlotFromHost,
    sandboxHostname,
    sandboxIdFromUrl,
    sandboxIdOfDaemonUrl,
    syncFolder,
} from "./hostnames.js";

const ID = "abc123def456";

// The cases netd's Rust router is held to as well (_sandbox/netd, route.rs), read from the one file both run.
interface HostCase {
    readonly host: string;
    readonly sandboxId?: string;
    readonly panel?: string;
    readonly port?: string;
    readonly public?: string;
    // The sandbox the name routes to (hostOwnerId), and the minted id it carries as a daemon's own address.
    readonly owner?: string;
    readonly daemon?: string;
}
const HOST_CASES = JSON.parse(readFileSync(new URL("./hostnames.fixture.json", import.meta.url), "utf8")) as HostCase[];

test.each(HOST_CASES)("the shared host cases parse as netd parses them: $host", (hostCase) => {
    expect({
        panel: panelFromHost(hostCase.host, hostCase.sandboxId),
        port: portSlotFromHost(hostCase.host, hostCase.sandboxId),
        public: publicSlotFromHost(hostCase.host, hostCase.sandboxId),
    }).toEqual({ panel: hostCase.panel, port: hostCase.port, public: hostCase.public });
});

test.each(HOST_CASES)("the shared host cases name their owner, and a daemon address its minted id: $host", (hostCase) => {
    expect({ owner: hostOwnerId(hostCase.host), daemon: sandboxIdOfDaemonUrl(hostCase.host) }).toEqual({
        owner: hostCase.owner,
        daemon: hostCase.daemon,
    });
});

test("a daemon address is read with or without its scheme, and an unparsable one names no sandbox", () => {
    expect(sandboxIdOfDaemonUrl(`https://sandbox-82789f4106b4.radarsu.com`)).toBe(`82789f4106b4`);
    expect(sandboxIdOfDaemonUrl(`sandbox-82789f4106b4.radarsu.com/`)).toBe(`82789f4106b4`);
    expect(sandboxIdOfDaemonUrl(`https://sandbox.example.com`)).toBeUndefined();
    expect(sandboxIdOfDaemonUrl(`http://[not a host`)).toBeUndefined();
});

test("preview and port hostnames round-trip through their Host-header parsers", () => {
    expect(panelFromHost(`${previewHostname("shop--web", ID, "example.com")}:443`, ID)).toBe("shop--web");
    expect(portSlotFromHost(`${portHostname("a", ID, "example.com")}:443`, ID)).toBe("a");
    // The id-less form (loopback tests / provider-deployed workspaces fronting the proxy themselves).
    expect(panelFromHost("preview-app.example.com", undefined)).toBe("app");
    expect(portSlotFromHost("port-a.example.com", undefined)).toBe("a");
});

test("the two schemes never bleed into each other, and stray/wrong-id hosts parse to nothing", () => {
    expect(portSlotFromHost(`preview-app-${ID}.example.com`, ID)).toBeUndefined();
    expect(panelFromHost(`port-a-${ID}.example.com`, ID)).toBeUndefined();
    expect(panelFromHost("app.example.com", ID)).toBeUndefined();
    expect(panelFromHost(`preview-app-000000000000.example.com`, ID)).toBeUndefined();
    expect(portSlotFromHost(`port-a-000000000000.example.com`, ID)).toBeUndefined();
    expect(panelFromHost(undefined, ID)).toBeUndefined();
});

test("labels are the mintable unit: hostname = <label>-<id>.<zone> for both schemes", () => {
    expect(labelHostname(previewLabel("app"), ID, "example.com")).toBe(previewHostname("app", ID, "example.com"));
    expect(labelHostname(portLabel("a"), ID, "example.com")).toBe(portHostname("a", ID, "example.com"));
});

test("the local sync folder carries the very id the sandbox's URL does", () => {
    const url = `https://${sandboxHostname(ID, "intentic.dev")}`;
    expect(sandboxIdFromUrl(url)).toBe(ID);
    expect(syncFolder("Radarsu Local", url)).toBe(`~/intentic/radarsu-local-${ID}`);
    // A bare host (no scheme) and a port are both accepted: the daemon/CLI and the browser pass different shapes.
    expect(sandboxIdFromUrl(`${sandboxHostname(ID, "intentic.dev")}:443`)).toBe(ID);
    // Own-Cloudflare: the owner's chosen subdomain IS the id, so the folder still matches what they browse to.
    expect(syncFolder("shop", "https://dev-box.example.com")).toBe("~/intentic/shop-dev-box");
});

test("sandbox ids that can't be read off a URL leave the folder named for the sandbox alone", () => {
    expect(sandboxIdFromUrl(undefined)).toBeUndefined();
    expect(sandboxIdFromUrl("")).toBeUndefined();
    expect(sandboxIdFromUrl("not a url")).toBeUndefined();
    expect(sandboxIdFromUrl("https://sandbox-.intentic.dev")).toBeUndefined();
    expect(syncFolder("My Repo", undefined)).toBe("~/intentic/my-repo");
    expect(syncFolder("", undefined)).toBe("~/intentic/sandbox");
});

test("preview/port URLs require both a zone and a sandbox id", () => {
    expect(previewUrl("app", "example.com", ID)).toBe(`https://preview-app-${ID}.example.com`);
    expect(portUrl("a", "example.com", ID)).toBe(`https://port-a-${ID}.example.com`);
    expect(portUrl("a", undefined, ID)).toBeUndefined();
    expect(portUrl("a", "", ID)).toBeUndefined();
    expect(portUrl("a", "example.com", undefined)).toBeUndefined();
});