"""Task-local, bounded recorder for real Ollama OpenAI-compatible requests."""
import argparse
import datetime as dt
import hashlib
import http.client
import json
from pathlib import Path
import threading
import time
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

ROOT = Path(__file__).resolve().parent
LOCK = threading.Lock()


def utc():
    return dt.datetime.now(dt.timezone.utc).isoformat()


class Recorder(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, *_):
        pass

    def do_GET(self):
        self.record()

    def do_POST(self):
        self.record()

    def record(self):
        request_id = uuid.uuid4().hex
        folder = self.server.artifacts / request_id
        folder.mkdir()
        begun = time.perf_counter()
        entry = {"requestId": request_id, "case": self.server.case, "path": self.path, "method": self.command, "startedAt": utc(), "forwarded": False}
        body = b""
        output = b""
        status = 502
        conn = None
        try:
            allowed = (self.command == "POST" and self.path == "/v1/chat/completions") or (self.command == "GET" and self.path in ("/v1/models", "/api/version", "/api/tags", "/api/ps"))
            if not allowed:
                raise PermissionError("Only declared model/metadata routes are approved")
            length = int(self.headers.get("Content-Length", "0"))
            if not 0 <= length <= 2 * 1024 * 1024 or self.headers.get("Transfer-Encoding"):
                raise ValueError("Unsupported synthetic request framing")
            body = self.rfile.read(length)
            # Preserve actual input before an upstream timeout or process shutdown.
            (folder / "request.body.bin").write_bytes(body)
            if self.command == "POST":
                parsed = json.loads(body)
                if parsed.get("stream", False):
                    raise ValueError("Only complete non-streaming responses are recorded")
                with LOCK:
                    if self.server.completions >= self.server.limit:
                        raise RuntimeError("Harness completion budget reached")
                    self.server.completions += 1
                    entry["completionOrdinal"] = self.server.completions
                (folder / "request.json").write_text(json.dumps(parsed, ensure_ascii=False, indent=2), encoding="utf-8")
            entry["pending"] = True
            (folder / "metadata.json").write_text(json.dumps(entry, indent=2), encoding="utf-8")
            conn = http.client.HTTPConnection("127.0.0.1", 11437, timeout=80)
            conn.request(self.command, self.path, body=body or None, headers={"Content-Type": "application/json", "Accept": "application/json", "Connection": "close"})
            entry["forwarded"] = True
            (folder / "metadata.json").write_text(json.dumps(entry, indent=2), encoding="utf-8")
            response = conn.getresponse()
            status = response.status
            output = response.read()
            try:
                parsed_output = json.loads(output)
                (folder / "response.json").write_text(json.dumps(parsed_output, ensure_ascii=False, indent=2), encoding="utf-8")
                entry["usage"] = parsed_output.get("usage")
                entry["finishReasons"] = [choice.get("finish_reason") for choice in parsed_output.get("choices", [])]
            except (UnicodeError, ValueError, AttributeError):
                entry["jsonParsed"] = False
        except Exception as error:
            status = 403 if isinstance(error, PermissionError) else 429 if isinstance(error, RuntimeError) else 400 if isinstance(error, ValueError) else 502
            entry["error"] = {"type": type(error).__name__, "message": str(error)}
            output = json.dumps({"error": {"message": str(error), "type": "harness_policy"}}).encode()
            entry["errorOrigin"] = "upstreamTransport" if entry["forwarded"] else "harnessPolicy"
            (folder / "response.json").write_bytes(output)
        finally:
            if conn:
                conn.close()
            (folder / "request.body.bin").write_bytes(body)
            (folder / "response.body.bin").write_bytes(output)
            entry.update({"pending": False, "status": status, "finishedAt": utc(), "durationSeconds": time.perf_counter() - begun, "requestSha256": hashlib.sha256(body).hexdigest(), "responseSha256": hashlib.sha256(output).hexdigest(), "artifactDirectory": str(folder.relative_to(ROOT))})
            (folder / "metadata.json").write_text(json.dumps(entry, indent=2), encoding="utf-8")
            with LOCK, (self.server.artifacts / "requests.jsonl").open("a", encoding="utf-8") as index:
                index.write(json.dumps(entry) + "\n")
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(output)))
        self.send_header("Connection", "close")
        self.end_headers()
        try:
            self.wfile.write(output)
        except (BrokenPipeError, ConnectionResetError):
            pass


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--case", required=True, choices=("primary", "boundary"))
    parser.add_argument("--limit", type=int, default=8)
    args = parser.parse_args()
    server = ThreadingHTTPServer(("127.0.0.1", 11438), Recorder)
    server.daemon_threads = True
    server.case = args.case
    server.limit = min(max(args.limit, 1), 8)
    server.completions = 0
    server.artifacts = ROOT / args.case / "model-requests"
    server.artifacts.mkdir(parents=True, exist_ok=True)
    (server.artifacts / "proxy-provenance.json").write_text(json.dumps({"scriptSha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), "listen": "127.0.0.1:11438", "upstream": "127.0.0.1:11437", "case": args.case, "maxCompletions": server.limit, "durationDefinition": "Wall time from incoming request until complete upstream response", "headerSecretsRecorded": False}, indent=2), encoding="utf-8")
    try:
        server.serve_forever(poll_interval=0.25)
    finally:
        server.server_close()
