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, runPromise, test, WEB } from "./t3.ts";

const SECOND_HOME = `${T3_HOME}-second-environment`;

/** A second server on its own T3 home, running until interrupted. `--dev-url` admits the web
 * origin through CORS and registers the replay agent; `paired` gets the Add environment input. */
const runSecondServer = Effect.fn("scenario.secondServer")(function* (
  devUrl: string,
  paired: (target: { readonly host: string; readonly token: string }) => void,
) {
  const path = yield* Path.Path;
  const node = yield* HostProcess.ExecutablePath;
  const hostEnvironment = yield* HostProcess.Environment;
  const port = yield* (yield* NetService.NetService).reserveLoopbackPort();
  yield* prepareHome(SECOND_HOME);
  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",
      SECOND_HOME,
      "--dev-url",
      devUrl,
    ],
    env: {
      PATH: `${path.join(SECOND_HOME, "bin")}:${hostEnvironment.PATH ?? ""}`,
      HOME: hostEnvironment.HOME,
      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;
});

test(
  "Projects respect the environment scope and retain it when opened",
  WEB,
  async ({ t3, app, screen, browser }) => {
    await t3.project("primary-only-proj");
    const second = makeState(SECOND_HOME);
    const pairing = Promise.withResolvers<{ host: string; token: string }>();
    const server = Effect.runFork(
      runSecondServer(app.baseUrl ?? "", pairing.resolve).pipe(
        Effect.scoped,
        Effect.provide([NodeServices.layer, NetService.layer]),
      ),
    );
    server.addObserver(() => pairing.reject(new Error("The second server stopped.")));
    try {
      const { host, token } = await pairing.promise;
      await second.state.project("remote-only-proj");
      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 Scenario").waitFor({ state: "visible", timeout: 60000 });
      await app.open("/settings/projects");
      await screen.getByRole("button", "Environment scope: All environments").tap();
      const environments = screen.getByRole("menuitemradio").filter({ hasText: "Scenario" });
      const names = await environments.allTextContents();
      await environments.nth(names.findIndex((name) => !name.includes(new URL(host).host))).tap();
      await app.screenshot("environment-project-list");
      // Capture both defects before asserting, so base records the complete interaction.
      const remoteRow = screen.getByRole('region', 'Settings content').getByRole('button').filter({ hasText: "remote-only-proj" });
      const remoteCount = await remoteRow.count();
      await screen.getByRole('region', 'Settings content').getByRole('button').filter({ hasText: "primary-only-proj" }).tap();
      await app.screenshot("opened-project-scope");
      await expect(browser).toHaveURL(/machine=/);
      await expect(remoteCount).toBe(0);
    } finally {
      await Effect.runPromise(Fiber.interrupt(server));
    }
  },
);
