// Scratch for #37163: times a git probe launched beside a long-lived sibling via SpawnWorker.layer.
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Stream from "effect/Stream";
import * as ChildProcess from "effect/process/ChildProcess";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as SpawnWorker from "./src/process/SpawnWorker.ts";

const cwd = process.argv[2]!;
const rounds = Number(process.argv[3] ?? 20);
const layer = SpawnWorker.layer.pipe(Layer.provide(NodeServices.layer));
const text = <E>(s: Stream.Stream<Uint8Array, E>) => s.pipe(Stream.decodeText(), Stream.mkString);
const node = (script: string) => ChildProcess.make(process.execPath, ["-e", script]);

const program = Effect.gen(function* () {
  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
  // Warm workers holding children, as beside a running agent.
  for (let i = 0; i < 4; i++) {
    const h = yield* spawner.spawn(node("process.stdout.write('r');process.stdin.resume()"));
    yield* h.stdout.pipe(Stream.take(1), text);
  }
  const times: number[] = [];
  for (let r = 0; r < rounds; r++) {
    const t0 = performance.now();
    yield* Effect.all(
      [
        Effect.scoped(
          spawner
            .spawn(
              ChildProcess.make("git", ["rev-parse", "--is-inside-work-tree", "--show-toplevel", "--git-common-dir"], { cwd }),
            )
            .pipe(
              Effect.flatMap((c) => Effect.all([text(c.stdout), text(c.stderr)], { concurrency: "unbounded" })),
              Effect.tap(() => Effect.sync(() => times.push(Math.round(performance.now() - t0)))),
            ),
        ),
        Effect.scoped(spawner.spawn(node("setTimeout(()=>{},5000)")).pipe(Effect.flatMap((c) => c.exitCode))),
      ],
      { concurrency: "unbounded" },
    );
  }
  const sorted = [...times].sort((a, b) => a - b);
  console.log(JSON.stringify({ times, median: sorted[Math.floor(sorted.length / 2)], min: sorted[0], max: sorted.at(-1), over1s: times.filter((t) => t > 1000).length }));
}).pipe(Effect.scoped, Effect.provide(layer));

Effect.runPromise(program).then(() => process.exit(0));
