/// <reference lib="dom" />
import { expect } from "e2e";
import { test, WEB } from "./t3.ts";

test("Session permission messages remain unchanged", WEB, async ({ t3, app, screen, browser }) => {
  await t3.project("demo");
  await browser.addInitScript(() => {
    const nativeFetch = window.fetch.bind(window);
    const sockets = new Set<WebSocket>();
    let mode = "pending";
    let active = false;
    let offline = false;
    let release: (() => void) | undefined;
    const NativeSocket = window.WebSocket;
    window.WebSocket = class extends NativeSocket {
      constructor(url: string | URL, protocols?: string | string[]) {
        super(url, protocols);
        
        if (new URL(String(url), location.href).pathname !== "/ws") return;
        sockets.add(this);
        this.addEventListener("close", () => sockets.delete(this));
        if (offline) this.addEventListener("open", () => this.close());
      }
    };
    window.fetch = async (input, init) => {
      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
      if (!active || !url.includes("/api/auth/session")) return nativeFetch(input, init);
      if (mode === "pending") await new Promise<void>((resolve) => { release = resolve; });
      if (mode === "failed") throw new TypeError("Synthetic permission-check network failure");
      const response = await nativeFetch(input, init);
      if (mode !== "rejected") return response;
      const body = await response.json();
      return new Response(JSON.stringify({ ...body, authenticated: false }), {
        status: 200, headers: { "content-type": "application/json" },
      });
    };
    Object.assign(window, {
      permissionProof: {
        arm() { active = true; },
        setMode(next: string) { mode = next; release?.(); },
        disconnect() { offline = true; for (const socket of sockets) socket.close(); },
        reconnect() { offline = false; },
      },
    });
  });
  await t3.open("/settings/access");
  await browser.locator("summary").filter({ hasText: "Permissions" }).tap();
  await screen.getByText("These permissions apply to this client’s current connection.", { exact: true }).waitFor();
  await browser.evaluate(`(async () => {
    window.permissionProof.arm();
    const { environmentId } = await (await fetch('/.well-known/t3/environment')).json();
    const { appAtomRegistry } = await import('/src/rpc/atomRegistry.ts');
    const { environmentSession } = await import('/src/state/session.ts');
    appAtomRegistry.refresh(environmentSession.sessionStateAtom(environmentId));
    return null;
  })()`);
  const pending = screen.getByText("Checking permissions…", { exact: true });
  await pending.waitFor();
  await app.screenshot("1-connected-pending");
  await expect(pending).toBeVisible();
  await browser.evaluate("window.permissionProof.setMode('failed')");
  const failed = screen.getByText("Could not verify your permissions. Retrying automatically.", { exact: true });
  await failed.waitFor();
  await app.screenshot("2-connected-failed");
  await expect(failed).toBeVisible();
  await browser.evaluate("window.permissionProof.setMode('rejected')");
  const rejected = screen.getByText("This environment did not accept your session. Reconnect to try again.", { exact: true });
  await rejected.waitFor();
  await app.screenshot("3-connected-rejected");
  await expect(rejected).toBeVisible();
  await browser.evaluate("window.permissionProof.disconnect()");
  const disconnected = screen.getByText("Connect to this environment to view this session’s permissions.", { exact: true });
  await disconnected.waitFor();
  await app.screenshot("4-disconnected-after-rejection");
  await expect(disconnected).toBeVisible();
  await browser.evaluate("window.permissionProof.setMode('real'); window.permissionProof.reconnect()");
  await screen.getByText("These permissions apply to this client’s current connection.", { exact: true }).waitFor({ timeout: 90000 });
  await app.screenshot("5-reconnected-grants");
});
