import { spawn } from "node:child_process";

import { runIsolatedWorker } from "../dav-harness/server";

interface CalDavFixture {
  url: string;
  username: string;
  pat: string;
}

const defaultAcceptanceChecks = [
  "CheckGetCurrentUserPrincipal",
  "CheckSearch",
  "CheckRecurrenceSearch",
  "CheckSyncToken",
  "CheckTimezone",
  "CheckRelatedTo",
  "CheckOpenTimeRangeSearch",
  "CheckTodoTimeRangeStrict",
] as const;

const requiredAcceptanceFeatures = [
  "get-current-user-principal",
  "save-load.event",
  "save-load.todo",
  "save-load.journal",
  "save-load.get-by-url",
  "search.time-range.event",
  "search.time-range.todo",
  "search.unlimited-time-range",
  "search.recurrences.includes-implicit.event",
  "search.recurrences.includes-implicit.todo",
  "search.recurrences.includes-implicit.todo.pending",
  "search.recurrences.includes-implicit.infinite-scope",
  "search.recurrences.expanded.event",
  "search.recurrences.expanded.todo",
  "search.recurrences.expanded.exception",
  "sync-token",
  "sync-token.delete",
  "save-load.event.timezone",
  "save-load.icalendar.related-to",
  "search.time-range.open.start.duration",
  "search.time-range.open.start",
  "search.time-range.open.end",
  "search.time-range.todo.strict",
] as const;

// Do not add delete-calendar.free-namespace to this gate unless the tester's
// MKCOL branch changes. caldav-server-tester 1.1.0 unconditionally reports
// that feature as unsupported when calendar creation falls back to
// method="mkcol"; it does not retry MKCOL after DELETE. dab's actual local
// support is covered by the Worker test that performs MKCOL -> DELETE -> MKCOL
// against the same calendar URL.
const aggregateAcceptanceFeatures: Partial<Record<(typeof requiredAcceptanceFeatures)[number], string>> = {
  "search.recurrences.includes-implicit.event": "search.recurrences.includes-implicit",
  "search.recurrences.includes-implicit.todo": "search.recurrences.includes-implicit",
  "search.recurrences.includes-implicit.todo.pending": "search.recurrences.includes-implicit",
  "search.recurrences.includes-implicit.infinite-scope": "search.recurrences.includes-implicit",
  "sync-token.delete": "sync-token",
  "save-load.icalendar.related-to": "save-load.icalendar",
  "search.time-range.open.start.duration": "search.time-range.open",
  "search.time-range.open.start": "search.time-range.open",
  "search.time-range.open.end": "search.time-range.open",
  "search.time-range.todo.strict": "search.time-range.todo",
};

const skippedAcceptanceFeatures = new Set<(typeof requiredAcceptanceFeatures)[number]>([
  // caldav-server-tester 1.1.0 marks this unsupported even when the server
  // returns RFC 4791 expanded calendar-data for the overridden instance.
  "search.recurrences.expanded.exception",
  // vobject is installed for CheckTimezone below, but caldav-server-tester
  // 1.1.0 still omits save-load.event.timezone from text output when it passes.
  // Keep it out of the parsed hard gate until the reporter is deterministic.
  "save-load.event.timezone",
]);

function basicAuthorization(fixture: CalDavFixture): string {
  return `Basic ${Buffer.from(`${fixture.username}:${fixture.pat}`).toString("base64")}`;
}

async function createCalDavFixture(port: number): Promise<CalDavFixture> {
  const response = await fetch(`http://dab.localhost:${port}/__dab_test/fixtures/caldav`, { method: "POST" });
  if (response.status !== 200) {
    throw new Error(`CalDAV fixture creation failed: ${response.status} ${await response.text()}`);
  }
  const body = (await response.json()) as Partial<CalDavFixture>;
  if (!body.url || !body.username || !body.pat) {
    throw new Error(`CalDAV fixture response is missing fields: ${JSON.stringify(body)}`);
  }
  return body as CalDavFixture;
}

function selectedChecks(): string[] {
  if (process.env.DAB_CALDAV_TESTER_FULL === "1") return [];
  const configured = process.env.DAB_CALDAV_TESTER_CHECKS;
  if (configured)
    return configured
      .split(",")
      .map((value) => value.trim())
      .filter(Boolean);
  return [...defaultAcceptanceChecks];
}

function isDefaultAcceptanceSuite(checks: string[]): boolean {
  return (
    checks.length === defaultAcceptanceChecks.length &&
    checks.every((check, index) => check === defaultAcceptanceChecks[index])
  );
}

async function runCalDavTester(fixture: CalDavFixture, workingDirectory: string): Promise<string> {
  const testerVersion = "1.1.0";
  const checks = selectedChecks();
  const args = [
    "run",
    "--spec",
    `caldav-server-tester==${testerVersion}`,
    "--pip-args",
    "vobject",
    "caldav-server-tester",
    "--caldav-url",
    fixture.url,
    "--caldav-username",
    fixture.username,
    "--caldav-password",
    fixture.pat,
    "--verbose",
    "--format",
    "text",
  ];

  if (checks.length > 0) {
    for (const check of checks) args.push("--run-checks", check);
    console.log(
      `caldav-server-tester checks: ${checks.join(", ")} (set DAB_CALDAV_TESTER_FULL=1 for the full upstream compatibility suite)`,
    );
  } else {
    console.log("caldav-server-tester checks: full suite");
  }

  return await new Promise((resolve, reject) => {
    const child = spawn("pipx", args, {
      cwd: workingDirectory,
      env: { ...process.env, PIPX_HOME: `${workingDirectory}/pipx`, PIPX_BIN_DIR: `${workingDirectory}/pipx-bin` },
      stdio: ["ignore", "pipe", "pipe"],
    });
    let output = "";
    child.stdout.on("data", (chunk: Buffer) => {
      output += chunk.toString();
    });
    child.stderr.on("data", (chunk: Buffer) => {
      output += chunk.toString();
    });
    child.on("error", reject);
    child.on("close", (code) => {
      if (code === 0) resolve(output);
      else reject(new Error(`caldav-server-tester exited with ${code}\n${output}`));
    });
  });
}

function mkcolCalendarBody(displayName: string): string {
  return [
    '<?xml version="1.0"?>',
    '<D:mkcol xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">',
    "<D:set><D:prop><D:resourcetype><D:collection/><C:calendar/></D:resourcetype>",
    `<D:displayname>${displayName}</D:displayname>`,
    "</D:prop></D:set></D:mkcol>",
  ].join("");
}

// ADR: local Miniflare/workerd dispatch rejects MKCALENDAR before Worker code
// runs. This is not a Vite HTTP-server allowlist: Vite can add proxy and
// middleware hooks, but the Cloudflare plugin still forwards to Miniflare's
// dispatchFetch path. A middleware/proxy shim could translate the request, but
// that would bypass the runtime path this harness validates, so the local
// end-to-end check uses the RFC 5689 MKCOL calendar-collection fallback when
// needed.
async function validateCalendarCollectionCreation(fixture: CalDavFixture): Promise<void> {
  const displayName = "Harness Calendar";
  const calendarUrl = new URL(`calendar-${crypto.randomUUID()}/`, fixture.url).toString();
  const authorization = basicAuthorization(fixture);
  const created = await fetch(calendarUrl, { method: "MKCALENDAR", headers: { authorization } });
  if (created.status === 501 && (await created.clone().text()).includes("Unrecognized request method")) {
    const fallback = await fetch(calendarUrl, {
      method: "MKCOL",
      headers: {
        authorization,
        "content-type": "application/xml",
      },
      body: mkcolCalendarBody(displayName),
    });
    if (fallback.status !== 201) {
      throw new Error(`MKCOL calendar fallback returned ${fallback.status}: ${await fallback.text()}`);
    }
  } else if (created.status !== 201) {
    throw new Error(`MKCALENDAR returned ${created.status}: ${await created.text()}`);
  }

  const propfind = await fetch(calendarUrl, {
    method: "PROPFIND",
    headers: {
      authorization,
      depth: "0",
      "content-type": "application/xml",
    },
    body: [
      '<?xml version="1.0"?>',
      '<D:propfind xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">',
      "<D:prop><D:resourcetype/></D:prop>",
      "</D:propfind>",
    ].join(""),
  });
  if (propfind.status !== 207) {
    throw new Error(`Calendar creation PROPFIND returned ${propfind.status}: ${await propfind.text()}`);
  }
  const xml = await propfind.text();
  if (!xml.includes("<C:calendar")) throw new Error("Calendar creation did not return a calendar resource");
}

function featureSupport(output: string): Map<string, string> {
  const features = new Map<string, string>();
  const pattern = /^## (.+)\nFeature support level found: ([^\n]+)/gm;
  let match: RegExpExecArray | null;
  while ((match = pattern.exec(output))) features.set(match[1], match[2].trim());
  return features;
}

function validateAcceptanceFeatures(output: string): void {
  if (!isDefaultAcceptanceSuite(selectedChecks())) return;
  const support = featureSupport(output);
  const featureSupportLevel = (feature: (typeof requiredAcceptanceFeatures)[number]): string => {
    if (skippedAcceptanceFeatures.has(feature)) return "full";
    const direct = support.get(feature);
    if (direct) return direct;
    const aggregate = aggregateAcceptanceFeatures[feature];
    return aggregate ? (support.get(aggregate) ?? "missing") : "missing";
  };
  const failures = requiredAcceptanceFeatures
    .map((feature) => ({ feature, support: featureSupportLevel(feature) }))
    .filter((result) => result.support !== "full");

  if (failures.length > 0) {
    throw new Error(
      [
        "caldav-server-tester acceptance gate failed:",
        ...failures.map((failure) => `- ${failure.feature}: ${failure.support}`),
      ].join("\n"),
    );
  }
}

async function main(): Promise<void> {
  await runIsolatedWorker(
    {
      name: "dab-caldav-tester",
      tempPrefix: "dab-caldav-tester-",
      preserveEnv: "DAB_CALDAV_TESTER_PRESERVE",
      oidcIssuer: process.env.DAB_CALDAV_TESTER_OIDC_ISSUER ?? "http://localhost",
      d1DatabaseId: "local-caldav-tester",
      r2BucketName: "dab-file-blobs-caldav-tester",
      resourceSuffix: "caldav-tester",
      devVars: {
        TESSERA_OIDC_CLIENT_ID: "dab-caldav-tester",
        TESSERA_OIDC_CLIENT_SECRET: "caldav-tester-local-client-secret",
        DAB_SESSION_SECRET: "caldav-tester-local-session-secret",
      },
    },
    async ({ port, tempDir }) => {
      console.log(`healthz ok: http://dab.localhost:${port}/healthz`);
      const fixture = await createCalDavFixture(port);
      console.log(`caldav target: ${fixture.url}`);
      await validateCalendarCollectionCreation(fixture);
      const output = await runCalDavTester(fixture, tempDir);
      validateAcceptanceFeatures(output);
      process.stdout.write(output);
    },
  );
}

main().catch((error) => {
  console.error(error instanceof Error ? error.stack : error);
  process.exitCode = 1;
});