// Scratch driver for issue 38676 (not committed): two servers, one shared fake grok, update both at once.
import * as NodeChildProcess from "node:child_process";
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";
import * as NodeWS from "@effect/platform-node/NodeWS";
import {
  ORCHESTRATION_PROTOCOL_HEADER,
  ORCHESTRATION_PROTOCOL_VERSION,
  ProviderDriverKind,
  ProviderInstanceId,
  WsRpcGroup,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
import { RpcClient, RpcSerialization } from "effect/rpc";
import { Socket } from "effect/socket";

const REPO_ROOT = process.env.REPRO_REPO!;
const RUN = process.argv[2]!;
const SHARED_BIN = NodePath.join(RUN, "shared/bin/grok");

NodeFS.mkdirSync(NodePath.dirname(SHARED_BIN), { recursive: true });
NodeFS.copyFileSync(process.argv[3]!, SHARED_BIN);
NodeFS.chmodSync(SHARED_BIN, 0o755);

const ports = [41871, 41872];
const startServer = (name: string, port: number) => {
  const baseDir = NodePath.join(RUN, name);
  NodeFS.mkdirSync(NodePath.join(baseDir, "userdata"), { recursive: true });
  NodeFS.mkdirSync(NodePath.join(baseDir, "workspace"), { recursive: true });
  NodeFS.writeFileSync(
    NodePath.join(baseDir, "userdata/settings.json"),
    JSON.stringify({
      providerInstances: {
        grok: { driver: "grok", config: { enabled: true, binaryPath: SHARED_BIN } },
      },
    }),
  );
  const log = NodeFS.openSync(NodePath.join(baseDir, "server.log"), "w");
  const child = NodeChildProcess.spawn(
    "node",
    ["apps/server/src/bin.ts", "serve", "--host", "127.0.0.1", "--port", String(port),
      "--base-dir", baseDir, "--no-browser", "--log-level", "info",
      NodePath.join(baseDir, "workspace")],
    { cwd: REPO_ROOT, stdio: ["ignore", log, log], env: { ...process.env, T3CODE_DEV_SEED: "0" } },
  );
  return { baseDir, port, child };
};

const servers = [startServer("server-a", ports[0]!), startServer("server-b", ports[1]!)];
process.on("exit", () => servers.forEach((s) => s.child.kill("SIGTERM")));

const connect = Effect.fn("connect")(function* (server: (typeof servers)[number]) {
  const origin = `http://127.0.0.1:${server.port}`;
  for (let i = 0; i < 240; i++) {
    const ok = yield* Effect.promise(() => fetch(`${origin}/.well-known/t3/environment`).then(() => true, () => false));
    if (ok) break;
    yield* Effect.sleep("500 millis");
  }
  const issued = NodeChildProcess.spawnSync(
    "node", ["apps/server/src/bin.ts", "auth", "session", "issue", "--base-dir", server.baseDir, "--token-only"],
    { cwd: REPO_ROOT, encoding: "utf8" },
  );
  const token = issued.stdout.split("\n").filter((l) => l.trim()).at(-1)!.trim();
  const http = (yield* HttpClient.HttpClient).pipe(
    HttpClient.mapRequest((r) => r.pipe(HttpClientRequest.bearerToken(token),
      HttpClientRequest.setHeader(ORCHESTRATION_PROTOCOL_HEADER, String(ORCHESTRATION_PROTOCOL_VERSION)))),
    HttpClient.filterStatusOk,
  );
  const ticket = yield* http.execute(HttpClientRequest.post(`${origin}/api/auth/websocket-ticket`)).pipe(
    Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Struct({ ticket: Schema.String }))));
  const protocol = yield* Layer.build(
    RpcClient.layerProtocolSocket().pipe(
      Layer.provide(Socket.layerWebSocket(
        `${origin.replace(/^http/, "ws")}/ws?orchestrationProtocol=${ORCHESTRATION_PROTOCOL_VERSION}&wsTicket=${encodeURIComponent(ticket.ticket)}`)),
      Layer.provide(RpcSerialization.layerJson),
      Layer.provide(NodeWS.layerWebSocketConstructor),
    ),
  );
  return yield* RpcClient.make(WsRpcGroup).pipe(Effect.provideContext(protocol));
});

const program = Effect.gen(function* () {
  console.log("Commit:", NodeChildProcess.execFileSync("git", ["rev-parse", "HEAD"], {cwd: REPO_ROOT, encoding:"utf8"}).trim());
  console.log("Environment: Linux; two real Node servers on loopback; fresh isolated databases; T3CODE_DEV_SEED=0");
  console.log("Request offset:", process.env.OFFSET_MS ?? "1000", "ms");
  const clients = yield* Effect.forEach(servers, connect, { concurrency: "unbounded" });
  yield* Effect.forEach(clients, c => c["server.refreshProviders"]({ instanceId: ProviderInstanceId.make("grok"), fresh: true }), {concurrency:"unbounded"});
  // Wait until both servers have probed grok and see an update.
  for (let i = 0; i < 120; i++) {
    const lists = yield* Effect.forEach(clients, (c) => c["server.getConfig"]({}).pipe(
      Effect.map((cfg: any) => cfg.providers.find((p: any) => p.instanceId === "grok")),
      Effect.orElseSucceed(() => undefined)));
    console.log(new Date().toISOString(), "probe", lists.map((p: any) => p && `${p.status} v${p.version} adv=${p.versionAdvisory?.status}`));
    if (lists.every((p: any) => p?.version)) break;
    yield* Effect.sleep("1 second");
  }
  console.log(new Date().toISOString(), "sending server.updateProvider to both");
  const results = yield* Effect.forEach(
    clients,
    (c, i) => Effect.sleep(i === 0 ? "0 millis" : `${process.env.OFFSET_MS ?? "1000"} millis`).pipe(Effect.andThen(c["server.updateProvider"]({ provider: ProviderDriverKind.make("grok"), instanceId: ProviderInstanceId.make("grok") }).pipe(
      Effect.tap((r) => Effect.sync(() => console.log(new Date().toISOString(), "server", i, "update state:", r.providers.find(p=>p.instanceId === "grok")?.updateState?.status))),
      Effect.map((r) => ({ server: i, rpcOk: true, update: r.providers.find((p) => p.instanceId === "grok")?.updateState })),
      Effect.catch((e) => Effect.sync(() => { console.log(new Date().toISOString(), "server", i, "update failed"); return ({ server: i, rpcOk: false, error: String((e as any).message ?? e) }); })),
    ))),
    { concurrency: "unbounded" },
  );
  for (const result of results) console.log(JSON.stringify(result));
  console.log("CLI CALL LOG:\n" + NodeFS.readFileSync(NodePath.join(RUN, "shared/calls.log"), "utf8"));
});

await Effect.runPromise(program.pipe(Effect.scoped, Effect.provide(FetchHttpClient.layer)));
process.exit(0);
