// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off - synchronous fixture writer used from plain and Effect tests alike.
import * as NodeFS from "node:fs";
import * as NodePath from "node:path";

import { HostProcessPlatform } from "@t3tools/shared/hostProcess";

export interface FakeCliOptions {
  /** Directory the launcher and its stub are written into. */
  readonly directory: string;
  /** Command name as callers spawn it, e.g. `codex`. */
  readonly name: string;
  /** ES module source the launcher runs with `node`. `process.argv.slice(2)` carries the CLI args. */
  readonly source: string;
  /** Environment set for the stub before it runs, on top of the inherited environment. */
  readonly env?: Readonly<Record<string, string>>;
  /**
   * Platform the launcher is shaped for. Effect callers should pass the value
   * they read from `HostProcessPlatform` so an injected override is honoured;
   * defaults to the real host for plain tests.
   */
  readonly platform?: NodeJS.Platform;
}

/**
 * Writes a fake CLI whose behaviour lives in a Node stub. On posix the
 * launcher is a `#!/bin/sh` script; on Windows it is a `.cmd` shim, since a
 * shebang file is not executable there and `resolveSpawnCommand` routes
 * `.cmd` through a shell. Returns the launcher path to hand to the code under
 * test, which on Windows carries the `.cmd` extension.
 */
export function writeFakeCli(options: FakeCliOptions): string {
  NodeFS.mkdirSync(options.directory, { recursive: true });
  const stubPath = NodePath.join(options.directory, `${options.name}-stub.mjs`);
  // The environment rides in a JSON sidecar the stub applies to itself, since
  // neither sh nor cmd.exe can quote every value (newlines, quotes, `%`) safely.
  const envPath = NodePath.join(options.directory, `${options.name}-env.json`);
  NodeFS.writeFileSync(envPath, JSON.stringify(options.env ?? {}), "utf8");
  NodeFS.writeFileSync(
    stubPath,
    [
      'import { readFileSync as readFakeCliEnv } from "node:fs";',
      `Object.assign(process.env, JSON.parse(readFakeCliEnv(${JSON.stringify(envPath)}, "utf8")));`,
      options.source,
    ].join("\n"),
    "utf8",
  );

  if ((options.platform ?? HostProcessPlatform.defaultValue()) === "win32") {
    const launcherPath = NodePath.join(options.directory, `${options.name}.cmd`);
    NodeFS.writeFileSync(
      launcherPath,
      ["@echo off", `node "%~dp0${options.name}-stub.mjs" %*`, "exit /b %ERRORLEVEL%", ""].join(
        "\r\n",
      ),
      "utf8",
    );
    return launcherPath;
  }

  const launcherPath = NodePath.join(options.directory, options.name);
  NodeFS.writeFileSync(
    launcherPath,
    ["#!/bin/sh", `exec node "$(dirname "$0")/${options.name}-stub.mjs" "$@"`, ""].join("\n"),
    "utf8",
  );
  NodeFS.chmodSync(launcherPath, 0o755);
  return launcherPath;
}

/**
 * Stub source that becomes `scriptPath`: after optionally requiring a leading
 * argv prefix, it imports the script into its own process so the stub is the
 * agent. Nothing sits between the code under test and the mock, so a kill or
 * a closed stdin reaches it directly and its exit log is faithful on every
 * host. The script must not read `process.argv`; the mock agents are driven
 * by environment and stdin.
 */
export function execScriptSource(options: {
  readonly scriptPath: string;
  readonly expectedArgs?: ReadonlyArray<string>;
  /** Tab-separated argv appended here per invocation, for launch-flag assertions. */
  readonly argvLogPath?: string;
  /** Wait before handing over, for tests that race a slow startup. */
  readonly delayMs?: number;
}): string {
  return [
    'import { appendFileSync } from "node:fs";',
    'import { pathToFileURL } from "node:url";',
    "const args = process.argv.slice(2);",
    ...(options.argvLogPath === undefined
      ? []
      : [
          `appendFileSync(${JSON.stringify(options.argvLogPath)}, args.join(${JSON.stringify("\t")}) + ${JSON.stringify("\n")});`,
        ]),
    ...(options.delayMs === undefined
      ? []
      : [`Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ${options.delayMs});`]),
    `const expected = ${JSON.stringify(options.expectedArgs ?? [])};`,
    "if (expected.some((value, index) => args[index] !== value)) {",
    '  process.stderr.write(`unexpected args: ${args.join(" ")}\\n`);',
    "  process.exit(11);",
    "}",
    `await import(pathToFileURL(${JSON.stringify(options.scriptPath)}).href);`,
    "",
  ].join("\n");
}