import { spawn } from "node:child_process";
import { mkdtemp, readFile, rm } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it } from "vitest";

const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
const scriptPath = path.join(repoRoot, "scripts/e2e/lib/run-with-pty.mjs");

function runPtyProbe(logPath: string): Promise<{ code: number | null; stdout: string; stderr: string }> {
  return new Promise((resolve, reject) => {
    const child = spawn(
      process.execPath,
      [
        scriptPath,
        logPath,
        "/bin/bash",
        "-lc",
        'printf "prompt\\n"; IFS= read -r value; printf "got:%s\\n" "$value"',
      ],
      { stdio: ["pipe", "pipe", "pipe"] },
    );
    let stdout = "";
    let stderr = "";
    const timeout = setTimeout(() => {
      child.kill("SIGTERM");
      reject(new Error("PTY probe timed out"));
    }, 10_000);

    child.stdout.setEncoding("utf8");
    child.stderr.setEncoding("utf8");
    child.stdout.on("data", (chunk) => {
      stdout += chunk;
    });
    child.stderr.on("data", (chunk) => {
      stderr += chunk;
    });
    child.on("error", (error) => {
      clearTimeout(timeout);
      reject(error);
    });
    child.on("close", (code) => {
      clearTimeout(timeout);
      resolve({ code, stdout, stderr });
    });
    child.stdin.end("abc\n");
  });
}

describe("run-with-pty", () => {
  it("forwards stdin through a PTY and writes the transcript log", async () => {
    const tempRoot = await mkdtemp(path.join(os.tmpdir(), "openclaw-run-with-pty-"));
    const logPath = path.join(tempRoot, "pty.log");
    try {
      const result = await runPtyProbe(logPath);
      const log = await readFile(logPath, "utf8");

      expect(result).toMatchObject({ code: 0, stderr: "" });
      expect(result.stdout).toContain("prompt");
      expect(result.stdout).toContain("got:abc");
      expect(log).toContain("prompt");
      expect(log).toContain("got:abc");
    } finally {
      await rm(tempRoot, { recursive: true, force: true });
    }
  });
});