#!/usr/bin/env python3

"""Read-only Oak probes against a real hosted repo (default oak/oak).

Companion to agent_loop_hosted_v1 for read-side steps on realistic history

that the harness must not write to. One counting proxy lives for the whole

sequence so a proxied clone's stored remote stays valid for later steps.

Performs no remote writes: clone, log --remote, branch review --remote,

branch diff --remote, fetch, and pull on a never-pushed local branch.

"""

from __future__ import annotations

import argparse

import json

import os

import shutil

import subprocess

import sys

import time

from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))

from agent_loop_hosted import oak_token, serial_rounds  # noqa: E402

from oakbench.httpcount import HttpCountingProxy  # noqa: E402

from oakbench.runlock import measurement_lock  # noqa: E402

def main(argv=None) -> int:

    ap = argparse.ArgumentParser()

    ap.add_argument("--oak-bin", required=True)

    ap.add_argument("--repo", default="oak/oak")

    ap.add_argument("--review-branch", required=True)

    ap.add_argument("--workdir", required=True, type=Path)

    ap.add_argument("--results", required=True, type=Path)

    ap.add_argument("--mode", choices=("proxied", "direct"), default="proxied")

    ap.add_argument("--steps", default="clone_shallow,log_remote,review_remote,diff_remote,fetch,pull_after_shallow,pull_noop,clone_full")

    ap.add_argument("--trial", type=int, default=0)

    a = ap.parse_args(argv)

    tok = oak_token()

    a.workdir.mkdir(parents=True, exist_ok=True)

    a.results.mkdir(parents=True, exist_ok=True)

    rows = []

    with measurement_lock("agent_loop_readonly_probe"):

        proxy = HttpCountingProxy("oak.space").start() if a.mode == "proxied" else None

        env = dict(os.environ, OAK_NO_UPDATE_CHECK="1", NO_COLOR="1")

        env.pop("OAK_REMOTE", None)

        rarg = []

        if proxy:

            env.update(OAK_API_KEY=tok, OAK_REMOTE=proxy.url, HTTPS_PROXY=proxy.url, https_proxy=proxy.url,

                       NO_PROXY="127.0.0.1,localhost", no_proxy="127.0.0.1,localhost")

            rarg = ["-r", proxy.url]

        ws = a.workdir / f"ro-{a.mode}-{a.trial}"

        full = a.workdir / f"ro-full-{a.mode}-{a.trial}"

        for d in (ws, full):

            if d.exists():

                shutil.rmtree(d)

        b = a.oak_bin

        cmds = {

            "clone_shallow": ([b, "clone", "--shallow", a.repo, str(ws)] + rarg, a.workdir),

            "log_remote": ([b, "log", "--remote", "--branch", "main", "-n", "20", "--json"], ws),

            "review_remote": ([b, "branch", "review", a.review_branch, "--remote", "--json"], ws),

            "diff_remote": ([b, "branch", "diff", a.review_branch, "--remote", "--json"], ws),

            "fetch": ([b, "fetch"], ws),

            "pull_after_shallow": ([b, "pull"], ws),

            "pull_noop": ([b, "pull"], ws),

            "clone_full": ([b, "clone", a.repo, str(full)] + rarg, a.workdir),

        }

        for step in a.steps.split(","):

            cmd, cwd = cmds[step]

            if proxy:

                proxy.reset()

            t = time.monotonic()

            r = subprocess.run(cmd, cwd=cwd, env=env, capture_output=True)

            wall = time.monotonic() - t

            row = {"lane": "agent_loop_hosted", "scenario": "agent_loop_hosted_v1.readonly", "subject": "oak", "repo": a.repo,

                   "remote_repo": a.repo, "remote_server": "oak.space", "remote_transport": "network", "mode": a.mode,

                   "trial": a.trial, "step": step, "operation": f"readonly.{step}", "wall_s": wall, "elapsed_ms": wall * 1000.0,

                   "rc": r.returncode, "returncode": r.returncode, "output_bytes": len(r.stdout) + len(r.stderr),

                   "measurement_source": "httpcount_proxy+git_trace_curl" if proxy else "wall_clock_only"}

            if proxy:

                time.sleep(0.05)

                s = proxy.snapshot()

                row.update(http_requests=s.requests, http_request_bytes=s.request_bytes, http_response_bytes=s.response_bytes,

                           serial_rounds=serial_rounds(s.records), tunnel_bytes=s.tunnel_bytes, tunnel_connections=len(s.tunnels),

                           routes=s.by_route())

            if r.returncode != 0:

                row["tail"] = (r.stdout[-300:] + r.stderr[-500:]).decode(errors="replace").replace(tok, "<redacted>")

            rows.append(row)

            print(f"{a.repo} {a.mode} {step:20} rc={r.returncode} {wall:8.3f}s req={row.get('http_requests')} rounds={row.get('serial_rounds')} "

                  f"down={row.get('http_response_bytes')} tun={row.get('tunnel_bytes')}", file=sys.stderr, flush=True)

            if r.returncode != 0:

                print("   ", row["tail"][-400:], file=sys.stderr)

        if proxy:

            proxy.stop()

    out = a.results / f"agent_loop_readonly-{a.repo.replace('/', '_')}-{a.mode}-{a.trial}-{time.strftime('%H%M%S', time.gmtime())}.jsonl"

    with out.open("w") as fh:

        for r in rows:

            fh.write(json.dumps(r) + "\n")

    print(out, file=sys.stderr)

    return 0

if __name__ == "__main__":

    raise SystemExit(main())