// Scratch reproduction driver for #39797; not committed.
import * as NodeFS from "node:fs";
import * as Net from "node:net";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import { ChildProcess, ChildProcessSpawner } from "effect/process";
import { launchOrReuseRemoteServer } from "./src/tunnel.ts";

const home = process.argv[2]!;
const serverBin = process.argv[3]!;
const log = (m: string) => console.log(`[${new Date().toISOString()}] ${m}`);

const remoteShell = Layer.effect(
  ChildProcessSpawner.ChildProcessSpawner,
  Effect.gen(function* () {
    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
    return ChildProcessSpawner.make((command) => {
      if (command._tag !== "StandardCommand") return spawner.spawn(command);
      const key = /exec sh -s -- ([^"]+)"/u.exec(command.args.map(String).join(" "))?.[1] ?? "";
      // setsid: the launched server outlives the "ssh" session, as under sshd.
      return spawner.spawn(
        ChildProcess.make("setsid", ["-w", "sh", "-s", "--", ...key.split(" ")], {
          ...command.options,
          env: { PATH: process.env.PATH ?? "", HOME: home },
          extendEnv: false,
        }),
      );
    });
  }),
);

const target = { alias: "devbox", hostname: "devbox", username: null, port: null };
const launch = launchOrReuseRemoteServer(target, undefined, { nodeScriptPath: serverBin }).pipe(
  Effect.provide(remoteShell),
  Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);

const refused = (port: number) =>
  new Promise<boolean>((resolve) => {
    const s = Net.connect(port, "127.0.0.1");
    s.once("connect", () => (s.destroy(), resolve(false)));
    s.once("error", (e: NodeJS.ErrnoException) => resolve(e.code === "ECONNREFUSED"));
  });

const stateDir = () => {
  const root = `${home}/.t3/ssh-launch`;
  const dir = NodeFS.readdirSync(root).find((d) => !d.startsWith("."))!;
  return `${root}/${dir}`;
};

const main = async () => {
  log("launch 1: fresh connect");
  const first = await Effect.runPromise(launch);
  log(`launch 1 ok: ${JSON.stringify(first)}`);
  const pid = Number(NodeFS.readFileSync(`${stateDir()}/pid`, "utf8").trim());
  const port = first.remotePort;
  log(`server pid ${pid} port ${port}; sending SIGTERM`);
  process.kill(pid, "SIGTERM");
  // Freeze the server mid-teardown once its listener is closed, as a blocked
  // fsync in a worker thread does.
  for (let i = 0; i < 2000 && !(await refused(port)); i++) await new Promise((r) => setTimeout(r, 2));
  process.kill(pid, "SIGSTOP");
  const stat = NodeFS.readFileSync(`/proc/${pid}/stat`, "utf8").split(" ")[2];
  log(`froze pid ${pid} (state ${stat}); port refused: ${await refused(port)}`);
  log("process remains alive: t3 serve; listener is closed");
  for (const attempt of [2, 3]) {
    const start = Date.now();
    log(`launch ${attempt}: reconnect`);
    const result = await Effect.runPromise(Effect.result(launch));
    const secs = ((Date.now() - start) / 1000).toFixed(1);
    log(
      result._tag === "Success"
        ? `launch ${attempt} ok after ${secs}s: ${JSON.stringify(result.success)}`
        : `launch ${attempt} FAILED after ${secs}s: ${(result.failure as Error).message}`,
    );
  }
  log("releasing the frozen server");
  process.kill(pid, "SIGCONT");
  process.kill(pid, "SIGKILL");
};
main().catch((e) => {
  console.error(e);
  process.exit(1);
});
