import { mkdtempSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { describe, expect, it, beforeAll, afterAll } from "@effect/vitest";
import { Effect } from "effect";
import { createEmulator } from "@executor-js/emulate";

type LocalEmulator = Awaited<ReturnType<typeof createEmulator>>;

import { makeSelfHostAppsRuntime, type SelfHostAppsRuntime } from "../plugin/self-host-runtime";
import { makeAppsHttpRoutes } from "../http/routes";
import { registerAppsMcp, type McpServerLike } from "../mcp/register";
import { makeInMemoryAppsStore } from "./index";
import { makeGithubRestResolver } from "./github-resolver";
import { dailyBriefFileSet } from "./daily-brief";
import type { Bindings } from "../plugin/bindings";

// ---------------------------------------------------------------------------
// THE E2E PROOF (brief's proof artifact), runnable as one command:
//   bun run --filter='@executor-js/plugin-apps' test -- src/testing/e2e.test.ts
//
// It: boots the self-host apps runtime over real seam backings; stands up a
// real-shaped GitHub via the emulate package; publishes the daily-brief set
// OVER MCP (the apps_publish tool); binds a connection (the minted emulator
// token); invokes the tool OVER HTTP (hits the real emulator, writes the scope
// db); starts the workflow and sees it complete with a journal; fetches the ui
// resource OVER MCP + the raw bundle OVER HTTP; sees an SSE invalidation after a
// write; and lists + reads the skill OVER MCP.
// ---------------------------------------------------------------------------

const SCOPE = "rhys";
const CONNECTION = "rhys-github";

// A minimal in-memory McpServer stand-in capturing registered tools/resources
// so the test can invoke them exactly as an MCP client would.
class FakeMcpServer implements McpServerLike {
  readonly tools = new Map<string, (args: Record<string, unknown>) => unknown>();
  readonly resources = new Map<string, { uriTemplate: string; reader: (uri: URL) => unknown }>();
  registerTool(
    name: string,
    _config: unknown,
    handler: (args: Record<string, unknown>) => unknown,
  ) {
    this.tools.set(name, handler);
    return undefined;
  }
  registerResource(
    name: string,
    uri: string | { uriTemplate?: unknown },
    _metadata: unknown,
    reader: (uri: URL) => unknown,
  ) {
    this.resources.set(name, { uriTemplate: String(uri), reader });
    return undefined;
  }
}

const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect as never);

describe("Executor apps e2e (self-host, real GitHub emulator)", () => {
  let github: LocalEmulator;
  let host: SelfHostAppsRuntime;
  let http: ReturnType<typeof makeAppsHttpRoutes>;
  let mcp: FakeMcpServer;
  let token: string;
  let owner: string;
  const base = "http://apps.test";

  beforeAll(async () => {
    // --- real-shaped GitHub (emulate) + seed a repo with two issues --------
    github = await createEmulator({ service: "github" });
    // oxlint-disable-next-line executor/no-double-cast -- test boundary: the emulator credential minter returns an opaque credential; this asserts the api-key shape it produces
    const cred = (await github.credentials.mint({
      type: "api-key",
    })) as unknown as {
      token: string;
      login: string;
    };
    token = cred.token;
    const ghHeaders = {
      authorization: `Bearer ${token}`,
      accept: "application/vnd.github+json",
      "content-type": "application/json",
    };
    const repoRes = await fetch(`${github.url}/user/repos`, {
      method: "POST",
      headers: ghHeaders,
      body: JSON.stringify({ name: "app" }),
    });
    const repo = (await repoRes.json()) as { owner: { login: string } };
    owner = repo.owner.login;
    // One fresh issue and one that will read as stale (we backdate via title only;
    // the workflow's stale filter uses updated_at, which the emulator sets to now,
    // so we assert the run completes + journals rather than a specific stale count).
    for (const title of ["Fresh bug", "Second bug"]) {
      await fetch(`${github.url}/repos/${owner}/app/issues`, {
        method: "POST",
        headers: ghHeaders,
        body: JSON.stringify({ title, labels: ["bug"] }),
      });
    }

    // --- boot the self-host apps runtime over the five seam backings -------
    const store = makeInMemoryAppsStore();
    const resolver = makeGithubRestResolver({
      baseUrl: github.url,
      tokens: { [CONNECTION]: token },
    });
    host = makeSelfHostAppsRuntime({
      dataDir: mkdtempSync(join(tmpdir(), "apps-e2e-")),
      store,
      resolver,
      inMemory: true,
    });
    http = makeAppsHttpRoutes({ runtime: host.runtime });
    mcp = new FakeMcpServer();
    registerAppsMcp(mcp, { runtime: host.runtime, scope: SCOPE });
  }, 60_000);

  afterAll(async () => {
    await host?.close();
    await github?.close();
  });

  it("publishes the daily-brief set over MCP", async () => {
    const publishTool = mcp.tools.get("apps_publish")!;
    const result = (await publishTool({
      files: Object.fromEntries(dailyBriefFileSet()),
    })) as {
      structuredContent: {
        tools: string[];
        workflows: string[];
        ui: string[];
        skills: string[];
      };
    };
    expect(result.structuredContent.tools.sort()).toEqual(["issues-sync", "search-all-mail"]);
    expect(result.structuredContent.workflows).toEqual(["morning-sync"]);
    expect(result.structuredContent.ui).toEqual(["dashboard"]);
    expect(result.structuredContent.skills).toEqual(["issues-brief"]);
  });

  const bindings: Bindings = {
    github: { kind: "single", connection: CONNECTION },
  };

  it("invokes the published tool over HTTP, hitting the real GitHub emulator", async () => {
    const res = await http.handler(
      new Request(`${base}/api/apps/${SCOPE}/tools/issues-sync`, {
        method: "POST",
        body: JSON.stringify({ args: {}, bindings }),
      }),
    );
    expect(res.status).toBe(200);
    const body = (await res.json()) as {
      result: { synced: number; repos: number };
    };
    expect(body.result.repos).toBe(1);
    expect(body.result.synced).toBe(2);

    // The emulator's request ledger proves the tool really called GitHub.
    const ledger = await github.ledger.list();
    expect(
      ledger.some((e) =>
        String(e.operationId ?? "")
          .toLowerCase()
          .includes("issue"),
      ),
    ).toBe(true);

    // The scope db now holds the two issues.
    const db = await run(host.scopeDb.forScope(SCOPE));
    const rows = await run(db.exec<{ n: number }>("SELECT COUNT(*) AS n FROM issues"));
    expect(Number(rows[0].n)).toBe(2);
  });

  it("starts the workflow and sees it complete with a journal", async () => {
    const res = await http.handler(
      new Request(`${base}/api/apps/${SCOPE}/workflows/morning-sync/start`, {
        method: "POST",
        body: JSON.stringify({ input: {}, bindings, runId: "e2e-morning" }),
      }),
    );
    expect(res.status).toBe(200);
    const body = (await res.json()) as {
      run: { status: string; output: unknown };
    };
    expect(body.run.status).toBe("completed");

    // History is queryable and the step.tool call is journaled.
    const histRes = await http.handler(
      new Request(`${base}/api/apps/${SCOPE}/workflows/runs/e2e-morning`, {
        method: "GET",
      }),
    );
    const hist = (await histRes.json()) as {
      steps: { name: string; status: string }[];
    };
    expect(hist.steps.some((s) => s.name === "tool:issues-sync" && s.status === "completed")).toBe(
      true,
    );
  });

  it("serves the ui view as an MCP-Apps HTML document and a raw bundle over HTTP", async () => {
    // MCP Apps resource: a complete, self-booting HTML document (ui:// + _meta),
    // the shape a real host mounts.
    const resource = mcp.resources.get("apps-ui")!;
    const read = (await resource.reader(new URL(`ui://${SCOPE}/dashboard`))) as {
      contents: Array<{
        mimeType: string;
        text: string;
        _meta?: { ui?: { title?: string } };
      }>;
    };
    expect(read.contents[0].mimeType).toContain("text/html");
    expect(read.contents[0].text).toContain("<!doctype html>"); // a real document
    expect(read.contents[0].text).toContain('<div id="root">'); // a mount point
    expect(read.contents[0]._meta?.ui?.title).toBe("GitHub Issues");

    // Raw bundle endpoint.
    const res = await http.handler(
      new Request(`${base}/api/apps/${SCOPE}/ui/dashboard`, { method: "GET" }),
    );
    expect(res.status).toBe(200);
    expect(res.headers.get("content-type")).toContain("javascript");
    expect(res.headers.get("x-ui-title")).toBe("GitHub Issues");
  });

  it("delivers an SSE invalidation after a scope-db write", async () => {
    const res = await http.handler(
      new Request(`${base}/api/apps/${SCOPE}/live`, { method: "GET" }),
    );
    expect(res.headers.get("content-type")).toContain("text/event-stream");
    const reader = res.body!.getReader();
    const decoder = new TextDecoder();

    // Read the initial `ready` frame.
    const first = await reader.read();
    expect(decoder.decode(first.value)).toContain("event: ready");

    // Trigger a write on the scope db -> version bump -> invalidation.
    const db = await run(host.scopeDb.forScope(SCOPE));
    await run(
      db.exec(
        "INSERT INTO issues (repo, number, title, labels, updated_at, url) VALUES ('acme/x', 99, 't', '[]', '2026-01-01', 'u')",
      ),
    );

    // The next SSE frame is the invalidation for the issues table.
    const invalidation = await Promise.race([
      reader.read().then((r) => decoder.decode(r.value)),
      // oxlint-disable-next-line executor/no-promise-reject, executor/no-error-constructor -- test boundary: race the SSE read against a wall-clock timeout so a hung stream fails fast
      new Promise<string>((_, reject) => setTimeout(() => reject(new Error("SSE timeout")), 5000)),
    ]);
    expect(invalidation).toContain("event: invalidate");
    expect(invalidation).toContain('"table":"issues"');
    await reader.cancel();
  });

  it("lists and reads the published skill over MCP", async () => {
    const listSkills = mcp.tools.get("apps_list_skills")!;
    const listed = (await listSkills({})) as {
      structuredContent: { skills: { name: string; description: string }[] };
    };
    expect(listed.structuredContent.skills.map((s) => s.name)).toEqual(["issues-brief"]);

    const readSkill = mcp.tools.get("apps_read_skill")!;
    const body = (await readSkill({ name: "issues-brief" })) as {
      content: { text: string }[];
    };
    expect(body.content[0].text).toContain("GitHub issues brief");
  });
});