#!/usr/bin/env python3
"""Send every item to an OpenAI-compatible chat endpoint (llama-server, OpenRouter) under
one arm and append raw replies to a JSONL file. Resumable: (item, arm, model, sample)
keys already in the output are skipped. Every record carries the request hash and the
reply sha256.

usage: run_items.py --base URL --model NAME --arm A|B|C --out FILE [--date YYYY-MM-DD]
                    [--items id1,id2] [--max-tokens 4096] [--temperature T] [--seed N]
"""
import argparse
import hashlib
import json
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path

HERE = Path(__file__).resolve().parent
SYSTEM_A = "You are a coding assistant. Reply with complete code in fenced code blocks."


def calendar_context():
    """Arm C text: every calendar row as one line (date, title, fix label). The same text
    goes to every item; the model has to find the relevant row itself."""
    E = json.load(open(HERE / "calendar-entries-20261112.json"))["entries"]
    lines = []
    for r in sorted(E, key=lambda r: r["date"]):
        fix = r["fix"].get("label") or (r["fix"].get("text") or "")[:160]
        lines.append(f"- {r['date']} {r['title']}. Fix: {fix}".replace("\n", " "))
    return ("Breakage Calendar (cybernative.ai/breakage-calendar, data of 12 November 2026): "
            "dated upstream changes that break working software.\n" + "\n".join(lines))


def system_for(arm, date):
    if arm == "A":
        return SYSTEM_A
    s = SYSTEM_A + f"\nToday's date is {date}."
    if arm == "C":
        s += "\n\n" + calendar_context()
    return s


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--base", required=True)
    ap.add_argument("--model", required=True)
    ap.add_argument("--arm", choices="ABC", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--date", default=time.strftime("%Y-%m-%d", time.gmtime()))
    ap.add_argument("--items", default="")
    ap.add_argument("--max-tokens", type=int, default=4096)
    ap.add_argument("--temperature", type=float, default=None)
    ap.add_argument("--seed", type=int, default=None)
    ap.add_argument("--sample", type=int, default=0)
    ap.add_argument("--key-env", default="")
    a = ap.parse_args()

    items = [json.loads(l) for l in open(HERE / "items.jsonl")]
    if a.items:
        keep = set(a.items.split(","))
        items = [i for i in items if i["id"] in keep]
    out = Path(a.out)
    done = set()
    if out.exists():
        for l in open(out):
            r = json.loads(l)
            if not r.get("error"):  # failed calls are retried on the next pass
                done.add((r["item"], r["arm"], r["model"], r["sample"]))
    system = system_for(a.arm, a.date)
    headers = {"Content-Type": "application/json"}
    if a.key_env:
        import os
        headers["Authorization"] = "Bearer " + os.environ[a.key_env]
    for it in items:
        key = (it["id"], a.arm, a.model, a.sample)
        if key in done:
            continue
        body = {"model": a.model, "max_tokens": a.max_tokens,
                "messages": [{"role": "system", "content": system}, {"role": "user", "content": it["prompt"]}]}
        if a.temperature is not None:
            body["temperature"] = a.temperature
        if a.seed is not None:
            body["seed"] = a.seed
        raw = json.dumps(body).encode()
        t0 = time.time()
        req = urllib.request.Request(a.base.rstrip("/") + "/chat/completions", data=raw, headers=headers)
        try:
            with urllib.request.urlopen(req, timeout=900) as r:
                resp = json.load(r)
            msg = resp["choices"][0]["message"]
            reply = msg.get("content") or ""
            err = None
        except urllib.error.URLError as e:
            if isinstance(getattr(e, "reason", None), (ConnectionRefusedError, ConnectionResetError)) or "refused" in str(e):
                print("server unreachable, stopping without a record:", e, flush=True)
                return 3
            resp, reply, err, msg = None, "", repr(e)[:300], {}
        except Exception as e:  # recorded; retried on the next pass
            resp, reply, err, msg = None, "", repr(e)[:300], {}
        rec = {"item": it["id"], "arm": a.arm, "model": a.model, "sample": a.sample, "date": a.date,
               "requestSha256": hashlib.sha256(raw).hexdigest(), "systemSha256": hashlib.sha256(system.encode()).hexdigest(),
               "reply": reply, "reasoning": (msg.get("reasoning_content") or "")[:20000],
               "replySha256": hashlib.sha256(reply.encode()).hexdigest(), "seconds": round(time.time() - t0, 1),
               "finish": (resp or {}).get("choices", [{}])[0].get("finish_reason"), "usage": (resp or {}).get("usage"),
               "error": err, "at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())}
        with open(out, "a") as f:
            f.write(json.dumps(rec) + "\n")
        print(it["id"], a.arm, rec["finish"], rec["seconds"], err or "", flush=True)


if __name__ == "__main__":
    sys.exit(main())