import { readFileSync, writeFileSync } from "node:fs";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as NetService from "@t3tools/shared/Net";
import { expect } from "e2e";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Path from "effect/Path";
import { APP_DIR, T3_HOME } from "../e2e.config.ts";
import { prepareHome, start } from "./start-app.ts";
import { makeState, test, WEB } from "./t3.ts";

const A_HOME = `${T3_HOME}-preferred`;
const A_ID = "00000000-0000-4000-8000-00000000000a";
const runA = Effect.fn("scenario.preferredServer")(function* (
  devUrl: string,
  paired: (target: { host: string; token: string }) => void,
  existingPort?: number,
) {
  const path = yield* Path.Path;
  const node = yield* HostProcess.ExecutablePath;
  const env = yield* HostProcess.Environment;
  const port = existingPort ?? (yield* (yield* NetService.NetService).reserveLoopbackPort());
  if (existingPort === undefined) {
    yield* prepareHome(A_HOME);
    writeFileSync(`${A_HOME}/userdata/environment-id`, A_ID);
    for (const command of ["hostnamectl", "scutil"]) {
      const shim = `${A_HOME}/bin/${command}`;
      writeFileSync(shim, readFileSync(shim, "utf8").replaceAll("Scenario", "Server A"));
    }
  }
  const token = yield* Deferred.make<string>();
  yield* start({
    cwd: APP_DIR,
    command: node,
    args: [
      "apps/server/src/bin.ts",
      "serve",
      "--host",
      "127.0.0.1",
      "--port",
      String(port),
      "--base-dir",
      A_HOME,
      "--dev-url",
      devUrl,
    ],
    env: {
      PATH: `${path.join(A_HOME, "bin")}:${env.PATH ?? ""}`,
      HOME: env.HOME,
      T3CODE_DEV_SEED: "0",
      T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD: "0",
    },
    onLine: (line) => {
      const value = /^Token:\s*(\S+)/.exec(line)?.[1];
      return value === undefined ? Effect.void : Deferred.succeed(token, value).pipe(Effect.asVoid);
    },
  });
  paired({ host: `http://127.0.0.1:${port}`, token: yield* Deferred.await(token) });
  return yield* Effect.never;
});

async function shared(
  state: ReturnType<typeof makeState>,
  name: string,
  repository = "pingdotgg/t3code",
) {
  const project = await state.state.project(name, {
    ".git/config": `[remote "origin"]\n  url = https://github.com/${repository}.git\n  fetch = +refs/heads/*:refs/remotes/origin/*\n`,
  });
  return project;
}

test(
  "Shared repository remains visible when its preferred environment stops",
  WEB,
  async ({ t3, app, screen, browser }) => {
    const pairing = Promise.withResolvers<{ host: string; token: string }>();
    let server = Effect.runFork(
      runA(app.baseUrl ?? "", pairing.resolve).pipe(
        Effect.scoped,
        Effect.provide([NodeServices.layer, NetService.layer]),
      ),
    );
    server.addObserver(() => pairing.reject(new Error("Preferred server stopped")));
    try {
      const { host, token } = await pairing.promise;
      await shared(makeState(T3_HOME), "Shared repository B");
      const stateA = makeState(A_HOME);
      const projectA = await shared(stateA, "Shared repository A");
      await shared(stateA, "A-only repository", "pingdotgg/uploadthing");
      await stateA.state.thread({ project: projectA, title: "Work on A", messages: ["first"] });
      await t3.open("/settings/connections");
      await screen.getByRole("button", "Add environment").tap();
      const dialog = screen.getByRole("dialog");
      await dialog.getByPlaceholder("backend.example.com").fill(host);
      await dialog.getByPlaceholder("PAIRCODE").fill(token);
      await dialog.getByRole("button", "Add environment").tap();
      await screen
        .getByRole("button", "More actions for Server A")
        .waitFor({ state: "visible", timeout: 60000 });
      await screen.getByText("Work on A").first().waitFor({ state: "visible", timeout: 60000 });
      await app.open("/pull-requests");
      const rows = browser.locator("[data-pull-request-key]");
      await rows
        .filter({ hasText: "Server A" })
        .filter({ hasText: "pingdotgg/t3code" })
        .first()
        .waitFor({ state: "visible", timeout: 120000 });
      await app.screenshot("both-online");
      await Effect.runPromise(Fiber.interrupt(server));
      await screen.getByRole("button", "Refresh pull requests").tap();
      await screen.getByRole("searchbox", "Search pull requests").fill("keybinding");
      // A fresh query prevents the earlier page's cached rows from disguising the failure.
      let failure: unknown;
      try {
        await expect(rows.filter({ hasText: /keybinding/i }).first()).toBeVisible({
          timeout: 60000,
        });
      } catch (error) {
        failure = error;
      } finally {
        await app.screenshot("preferred-offline-fresh-search");
      }
      const failureMessage = screen
        .getByText(/Server A: Failed to fetch remote environment endpoint/)
        .first();
      await failureMessage.scrollIntoView({ timeout: 60000 });
      await app.screenshot("a-only-failure-retained");
      const primary = (await fetch(`${app.baseUrl}/.well-known/t3/environment`).then((r) =>
        r.json(),
      )) as { environmentId: string };
      await app.open(
        `/pull-requests?involvement=all&state=open&q=keybinding&environmentId=${primary.environmentId}`,
      );
      await rows
        .filter({ hasText: /keybinding/i })
        .first()
        .waitFor({ state: "visible", timeout: 60000 });
      await app.screenshot("online-server-only-control");
      await app.open("/pull-requests?involvement=all&state=open&q=keybinding");
      const restarted = Promise.withResolvers<{ host: string; token: string }>();
      server = Effect.runFork(
        runA(app.baseUrl ?? "", restarted.resolve, Number(new URL(host).port)).pipe(
          Effect.scoped,
          Effect.provide([NodeServices.layer, NetService.layer]),
        ),
      );
      server.addObserver(() => restarted.reject(new Error("Restarted server stopped")));
      await restarted.promise;
      await app.open("/pull-requests?involvement=all&state=open&q=keybinding");
      await rows
        .filter({ hasText: "Server A" })
        .filter({ hasText: "pingdotgg/t3code" })
        .first()
        .waitFor({ state: "visible", timeout: 120000 });
      await app.screenshot("preferred-server-reconnected");
      if (failure) throw failure;
    } finally {
      await Effect.runPromise(Fiber.interrupt(server));
    }
  },
);
