"""TerminalBench-DockerLess evaluation harness.

A Terminal-Bench trial is: build the environment, let the agent work in it, then
run a verifier that decides success. Docker normally provides the environment;
here each row carries a `dockerless.setup` script that builds the same state in a
throwaway directory, so a trial needs only bash, git and python.

    $TB_ROOT/
        workspace/   <- the agent's cwd (the container's /workspace)
        home/        <- HOME
        tmp/         <- TMPDIR
        bin/         <- prepended to PATH (holds a python3 shim)
        tests/       <- the verifier, uploaded read-only-ish after the agent runs

Usage
-----
    python run_harness.py --solution                 # oracle, expect 4/4
    python run_harness.py --baseline                 # do nothing, expect 0/4
    python run_harness.py --predictions preds.jsonl  # {"task_id", "agent_script"}

A task is resolved when every verifier test passes (reward 1.0), which is the
Terminal-Bench rule.
"""

import argparse
import json
import os
import re
import shutil
import subprocess
import sys
import tempfile
import time
from pathlib import Path

RESULT_RE = re.compile(
    r"^(test_[A-Za-z0-9_]+\.py::[A-Za-z0-9_\[\]\-\.]+)\s+(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)"
)

PYTHON_SHIM = '#!/bin/sh\nexec python "$@"\n'

_BASH_CACHE = []


def find_bash():
    """Resolve a usable POSIX shell.

    On Windows ``bash`` on PATH is often the WSL launcher, which may be blocked
    or simply start a different filesystem; prefer Git's own bash and prove the
    candidate works before trusting it.
    """
    if _BASH_CACHE:
        return _BASH_CACHE[0]

    candidates = []
    override = os.environ.get("TBDL_BASH")
    if override:
        candidates.append(override)
    exepath = os.environ.get("EXEPATH")
    if exepath:
        candidates.append(os.path.join(exepath, "bash.exe"))
    git = shutil.which("git")
    if git:
        git_bin = Path(git).resolve().parent
        candidates.append(str(git_bin.parent / "bin" / "bash.exe"))
        candidates.append(str(git_bin.parent / "usr" / "bin" / "bash.exe"))
    if os.name == "nt":
        candidates.append(r"C:\Program Files\Git\bin\bash.exe")
        candidates.append(r"C:\Program Files\Git\usr\bin\bash.exe")
    candidates.append(shutil.which("bash") or "bash")

    for candidate in candidates:
        if not candidate or not Path(candidate).exists():
            continue
        try:
            probe = subprocess.run(
                [candidate, "-c", "echo tbdl-ok"],
                capture_output=True,
                text=True,
                timeout=20,
            )
        except (OSError, subprocess.SubprocessError):
            continue
        if probe.returncode == 0 and "tbdl-ok" in probe.stdout:
            _BASH_CACHE.append(candidate)
            return candidate

    _BASH_CACHE.append("bash")
    return "bash"


def write_files(files, dest):
    for rel, content in files.items():
        path = dest / rel
        path.parent.mkdir(parents=True, exist_ok=True)
        with open(path, "w", encoding="utf-8", newline="\n") as handle:
            handle.write(content)


def sandbox_env(root):
    env = os.environ.copy()
    env.update(
        {
            "TB_ROOT": str(root),
            "TB_WORK": str(root / "workspace"),
            "HOME": str(root / "home"),
            "TMPDIR": str(root / "tmp"),
            "TEMP": str(root / "tmp"),
            "TMP": str(root / "tmp"),
            "PATH": str(root / "bin") + os.pathsep + env.get("PATH", ""),
            "PYTHONIOENCODING": "utf-8",
            "PYTHONDONTWRITEBYTECODE": "1",
            "GIT_CONFIG_NOSYSTEM": "1",
            "GIT_AUTHOR_NAME": "tbdl",
            "GIT_AUTHOR_EMAIL": "tbdl@example.invalid",
            "GIT_COMMITTER_NAME": "tbdl",
            "GIT_COMMITTER_EMAIL": "tbdl@example.invalid",
            "GIT_AUTHOR_DATE": "2026-10-30T12:00:00+0000",
            "GIT_COMMITTER_DATE": "2026-10-30T12:00:00+0000",
            "TB_BASH": find_bash(),
        }
    )
    return env


def build_sandbox(row, root):
    for name in ("workspace", "home", "tmp", "bin", "tests"):
        (root / name).mkdir(parents=True, exist_ok=True)
    shim = root / "bin" / "python3"
    shim.write_text(PYTHON_SHIM, encoding="utf-8", newline="\n")
    write_files(row["dockerless"]["files"], root / "workspace")
    write_files(row["tests"], root / "tests")
    env = sandbox_env(root)

    setup = row["dockerless"].get("setup", "")
    if setup.strip():
        script = root / "setup.sh"
        script.write_text(setup, encoding="utf-8", newline="\n")
        proc = subprocess.run(
            [find_bash(), str(script)],
            cwd=str(root / "workspace"),
            capture_output=True,
            text=True,
            encoding="utf-8",
            env=env,
            timeout=row["dockerless"].get("setup_timeout_sec", 120),
        )
        if proc.returncode != 0:
            raise RuntimeError(
                "setup failed for %s\n%s\n%s" % (row["task_id"], proc.stdout[-3000:], proc.stderr[-3000:])
            )
    return env


def run_script(path, cwd, env, timeout, label):
    try:
        return subprocess.run(
            [find_bash(), str(path)],
            cwd=str(cwd),
            capture_output=True,
            text=True,
            encoding="utf-8",
            env=env,
            timeout=timeout,
        )
    except subprocess.TimeoutExpired:
        return subprocess.CompletedProcess([], 124, "", "%s timed out after %ss" % (label, timeout))


def parse_results(stdout):
    results = {}
    for raw in stdout.splitlines():
        match = RESULT_RE.match(raw.strip())
        if match:
            results[match.group(1)] = match.group(2)
    return results


def evaluate(row, agent_script, root, keep=False):
    env = build_sandbox(row, root)
    work = root / "workspace"

    note = "ok"
    if agent_script is not None and agent_script.strip():
        agent_path = root / "agent.sh"
        agent_path.write_text(agent_script, encoding="utf-8", newline="\n")
        proc = run_script(
            agent_path, work, env, row.get("max_agent_timeout_sec", 300), "agent"
        )
        if proc.returncode != 0:
            note = "agent script exited %d" % proc.returncode

    test_cmd = row["dockerless"]["test_cmd"]
    test_script = root / "tests" / "test.sh"
    if test_cmd and test_cmd.strip():
        test_path = root / "run-tests.sh"
        test_path.write_text(test_cmd, encoding="utf-8", newline="\n")
    else:
        test_path = test_script
    proc = run_script(
        test_path, work, env, row.get("max_test_timeout_sec", 120), "verifier"
    )

    results = parse_results(proc.stdout)
    passed = [name for name, outcome in results.items() if outcome == "PASSED"]
    failed = sorted(name for name, outcome in results.items() if outcome != "PASSED")
    resolved = bool(results) and not failed
    return {
        "task_id": row["task_id"],
        "reward": 1.0 if resolved else 0.0,
        "resolved": resolved,
        "tests_passed": len(passed),
        "tests_total": len(results),
        "failing": failed[:12],
        "note": note if results else "no tests collected",
        "seconds": 0.0,
    }, proc


def load_rows(path):
    return [json.loads(line) for line in open(path, encoding="utf-8") if line.strip()]


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dataset", default="TerminalBench-DockerLess.jsonl")
    parser.add_argument("--solution", action="store_true", help="run each task's oracle solution")
    parser.add_argument("--baseline", action="store_true", help="run no agent at all")
    parser.add_argument("--predictions", help="JSONL of {task_id, agent_script}")
    parser.add_argument("--only", help="restrict to one task_id")
    parser.add_argument("--out", help="write a JSON report here")
    args = parser.parse_args()

    rows = load_rows(args.dataset)
    if args.only:
        rows = [row for row in rows if row["task_id"] == args.only]
        if not rows:
            parser.error("unknown task_id: %s" % args.only)

    predictions = {}
    if args.predictions:
        for line in open(args.predictions, encoding="utf-8"):
            if line.strip():
                record = json.loads(line)
                predictions[record["task_id"]] = record.get("agent_script", "")

    started = time.time()
    results = []
    print("%-24s %-7s %-8s %s" % ("task_id", "reward", "tests", "note"))
    for row in rows:
        if args.solution:
            agent_script = row.get("solution") or row["dockerless"].get("solution", "")
        elif args.baseline:
            agent_script = ""
        else:
            agent_script = predictions.get(row["task_id"], "")

        root = Path(tempfile.mkdtemp(prefix="tbdl-%s-" % row["task_id"][:12]))
        begin = time.time()
        try:
            result, proc = evaluate(row, agent_script, root)
        finally:
            shutil.rmtree(root, ignore_errors=True)
        result["seconds"] = round(time.time() - begin, 2)
        results.append(result)
        print(
            "%-24s %-7.1f %d/%-6d %s"
            % (
                result["task_id"],
                result["reward"],
                result["tests_passed"],
                result["tests_total"],
                result["note"],
            )
        )
        if result["failing"] and args.baseline:
            for name in result["failing"]:
                print("     fail  %s" % name)

    solved = sum(1 for result in results if result["resolved"])
    elapsed = time.time() - started
    summary = {
        "dataset": Path(args.dataset).name,
        "mode": "solution" if args.solution else ("baseline" if args.baseline else "predictions"),
        "tasks": len(rows),
        "resolved": solved,
        "resolve_rate": round(solved / len(rows), 4) if rows else 0.0,
        "seconds": round(elapsed, 2),
        "results": results,
    }
    print(
        "\nresolved %d/%d (%.1f%%) in %.1fs"
        % (solved, len(rows), 100.0 * summary["resolve_rate"], elapsed)
    )
    if args.out:
        Path(args.out).parent.mkdir(parents=True, exist_ok=True)
        Path(args.out).write_text(json.dumps(summary, indent=2), encoding="utf-8")
        print("report -> %s" % args.out)


if __name__ == "__main__":
    main()