"""Write the cleaned trajectories as Codex rollout files, one file per trajectory row.

Reads  : trajectories.train.jsonl, trajectories.eval.jsonl   (cleaned output of build.py; raw logs are NOT read)
Writes : traces/train/<id>.jsonl, traces/test/<id>.jsonl

Why    : the Hugging Face Hub decodes raw Codex rollouts natively (harness "codex", tool calls, results) and lists them
         as agent traces. These files use the same record types as the original logs, so the Hub reads them the same way:

    session_meta                                   id, cwd, originator, model_provider, base_instructions
    event_msg/task_started, turn_context           turn id, model, effort, cwd
    response_item/message (user | assistant)       input_text / output_text content parts
    response_item/function_call                    name, arguments (JSON string), call_id
    response_item/function_call_output             call_id, output
    event_msg/user_message, event_msg/task_complete

What is NOT here: reasoning, token counts, rate limits, injected developer/permission messages and per-line timing.
They are absent from the cleaned data, and nothing is invented to fill them: every line carries the turn's start
timestamp. These are reconstructions of the cleaned trajectories, not the original rollout files. Trajectory metadata
that has no Codex field (segment, flags, task_source, ...) is kept under session_meta.payload["trajectory"].

Every file is read back and compared with its source row (system prompt, then user text, assistant text, tool calls
and tool outputs in order); any difference raises and the script exits non-zero. Idempotent: traces/ is recreated.

Usage  : python3 -I scripts/to_codex.py [--out DIR] [--ids ID[,ID...]]
"""
import argparse
import calendar
import json
import os
import shutil
import sys
import time

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SPLITS = {"train": "trajectories.train.jsonl", "test": "trajectories.eval.jsonl"}
META = ["segment", "segments_total", "compaction_summary_available", "thread_source", "agent_role", "task_source",
        "n_tool_calls", "n_failed_calls", "flags"]
MSG_KEYS = {"role", "content", "tool_calls", "tool_call_id"}


def epoch(ts):
    return calendar.timegm(time.strptime(ts.split(".")[0].rstrip("Z"), "%Y-%m-%dT%H:%M:%S"))


def convert_row(row):
    ts, turn_id, msgs = row["timestamp"], row["turn_id"], row["messages"]
    if not msgs or msgs[0]["role"] != "system":
        raise ValueError("row must start with a system message: " + row["id"])
    lines = []

    def rec(kind, payload):
        lines.append({"timestamp": ts, "type": kind, "payload": payload})

    meta = {"id": row["session_id"], "timestamp": ts, "cwd": row["cwd"], "originator": "Codex Desktop",
            "model_provider": "openai", "base_instructions": {"text": msgs[0]["content"]},
            "trajectory": {"id": row["id"], "turn_id": turn_id, **{k: row[k] for k in META}}}
    rec("session_meta", meta)
    rec("event_msg", {"type": "task_started", "turn_id": turn_id, "started_at": epoch(ts)})
    ctx = {"turn_id": turn_id, "cwd": row["cwd"]}
    if row["model"]:
        ctx["model"] = row["model"]
    if row["effort"]:
        ctx["effort"] = row["effort"]
    rec("turn_context", ctx)
    last_assistant = None
    for m in msgs[1:]:
        extra = set(m) - MSG_KEYS
        if extra:
            raise ValueError(f"unexpected message keys {sorted(extra)}")
        role, text = m["role"], m.get("content") or ""
        if role == "user":
            rec("response_item", {"type": "message", "role": "user", "content": [{"type": "input_text", "text": text}]})
            rec("event_msg", {"type": "user_message", "message": text, "images": [], "local_images": [], "text_elements": []})
        elif role == "assistant":
            if text:
                rec("response_item", {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": text}]})
                last_assistant = text
            for tc in m.get("tool_calls") or []:
                if set(tc) != {"id", "type", "function"} or tc["type"] != "function" or set(tc["function"]) != {"name", "arguments"}:
                    raise ValueError(f"unexpected tool call shape {sorted(tc)}")
                rec("response_item", {"type": "function_call", "name": tc["function"]["name"],
                                      "arguments": tc["function"]["arguments"], "call_id": tc["id"]})
        elif role == "tool":
            rec("response_item", {"type": "function_call_output", "call_id": m["tool_call_id"], "output": text})
        else:
            raise ValueError("unexpected role " + role)
    rec("event_msg", {"type": "task_complete", "turn_id": turn_id, "last_agent_message": last_assistant})
    return lines


def atoms_from_row(row):
    out = [("system", row["messages"][0]["content"])]
    for m in row["messages"][1:]:
        text = m.get("content") or ""
        if m["role"] == "user":
            out.append(("user", text))
        elif m["role"] == "assistant":
            if text:
                out.append(("assistant", text))
            for tc in m.get("tool_calls") or []:
                out.append(("call", tc["id"], tc["function"]["name"], tc["function"]["arguments"]))
        else:
            out.append(("output", m["tool_call_id"], text))
    return out


def atoms_from_lines(lines):
    out = [("system", lines[0]["payload"]["base_instructions"]["text"])]
    for r in lines:
        p = r["payload"]
        if r["type"] != "response_item":
            continue
        t = p["type"]
        if t == "message":
            (part,) = p["content"]
            out.append((p["role"], part["text"]))
        elif t == "function_call":
            out.append(("call", p["call_id"], p["name"], p["arguments"]))
        elif t == "function_call_output":
            out.append(("output", p["call_id"], p["output"]))
        else:
            raise ValueError("unexpected response_item " + t)
    return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--out", default=os.path.join(ROOT, "traces"))
    ap.add_argument("--ids", default="", help="comma-separated row ids; default: every row")
    args = ap.parse_args()
    out = os.path.abspath(args.out)
    only = {i for i in args.ids.split(",") if i}
    if os.path.exists(out):
        if os.path.basename(out) != "traces" and os.listdir(out):
            sys.exit("refusing to wipe a non-empty directory that is not named 'traces': " + out)
        shutil.rmtree(out)
    names, counts, total, biggest, n_calls = set(), {}, 0, 0, 0
    for split, fn in SPLITS.items():
        os.makedirs(os.path.join(out, split))
        counts[split] = 0
        with open(os.path.join(ROOT, fn), encoding="utf-8") as fh:
            for raw in fh:
                row = json.loads(raw)
                if only and row["id"] not in only:
                    continue
                lines = convert_row(row)
                name = row["id"].replace("#", "_") + ".jsonl"
                if name in names:
                    raise ValueError("duplicate file name " + name)
                names.add(name)
                path = os.path.join(out, split, name)
                body = "".join(json.dumps(x, ensure_ascii=False, separators=(",", ":")) + "\n" for x in lines)
                with open(path, "w", encoding="utf-8", newline="\n") as w:
                    w.write(body)
                size = len(body.encode("utf-8"))
                total, biggest = total + size, max(biggest, size)
                counts[split] += 1
                with open(path, encoding="utf-8") as r:
                    back = [json.loads(x) for x in r]
                assert back[0]["type"] == "session_meta" and back[0]["payload"]["id"] == row["session_id"], path
                assert atoms_from_lines(back) == atoms_from_row(row), "content differs: " + path
                n_calls += sum(len(m.get("tool_calls") or []) for m in row["messages"])
    print(json.dumps({"files": counts, "bytes_total": total, "bytes_largest_file": biggest,
                      "tool_calls_verified": n_calls, "verified_round_trip": True}, indent=1))


if __name__ == "__main__":
    main()