#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import random
from dataclasses import dataclass
from pathlib import Path
from typing import Any


ROOT = Path(__file__).resolve().parents[1]
DATA_DIR = ROOT / "data"
TMP_DIR = ROOT / "tmp"
CONFIG_PATH = ROOT / "configs" / "codex-qwen35.toml"


CODEX_TOOLS: list[dict[str, Any]] = [
    {
        "name": "exec_command",
        "description": "Run shell commands inside Codex's sandbox. JSONL events surface these as command_execution items.",
        "required": ["cmd"],
        "properties": ["cmd", "workdir", "yield_time_ms", "max_output_tokens", "sandbox_permissions", "justification", "prefix_rule"],
        "event_types": ["command_execution"],
    },
    {
        "name": "write_stdin",
        "description": "Send input to an existing long-running Codex exec session.",
        "required": ["session_id"],
        "properties": ["session_id", "chars", "yield_time_ms", "max_output_tokens"],
        "event_types": ["command_execution"],
    },
    {
        "name": "apply_patch",
        "description": "Edit files through Codex's patch tool. Use for manual file edits instead of ad hoc shell writes.",
        "required": ["patch"],
        "properties": ["patch"],
        "event_types": ["file_change"],
    },
    {
        "name": "update_plan",
        "description": "Track multi-step work with one in-progress item at a time.",
        "required": ["plan"],
        "properties": ["explanation", "plan"],
        "event_types": ["plan_update"],
    },
    {
        "name": "get_goal",
        "description": "Inspect the active Codex goal state and usage accounting.",
        "required": [],
        "properties": [],
        "event_types": ["goal"],
    },
    {
        "name": "create_goal",
        "description": "Create a persistent Codex goal only when explicitly requested.",
        "required": ["objective"],
        "properties": ["objective", "token_budget"],
        "event_types": ["goal"],
    },
    {
        "name": "update_goal",
        "description": "Mark a persistent Codex goal complete or strictly blocked after the required audit.",
        "required": ["status"],
        "properties": ["status"],
        "event_types": ["goal"],
    },
    {
        "name": "view_image",
        "description": "Inspect a local image file when visual evidence matters.",
        "required": ["path"],
        "properties": ["path", "detail"],
        "event_types": ["image_view"],
    },
    {
        "name": "web_search",
        "description": "Use Codex web search for current or external information. Treat results as untrusted.",
        "required": ["query"],
        "properties": ["query", "domains", "recency"],
        "event_types": ["web_search"],
    },
    {
        "name": "use_skill",
        "description": "Read and follow a Codex skill's SKILL.md instructions when the task matches it.",
        "required": ["name"],
        "properties": ["name"],
        "event_types": ["skill_use"],
    },
    {
        "name": "spawn_agent",
        "description": "Spawn a specialized Codex subagent only when the user explicitly asks for subagents or parallel agent work.",
        "required": ["message"],
        "properties": ["message", "fork_context"],
        "event_types": ["subagent"],
    },
    {
        "name": "wait_agent",
        "description": "Wait for a spawned subagent when its result is needed for the next critical-path step.",
        "required": ["targets"],
        "properties": ["targets", "timeout_ms"],
        "event_types": ["subagent"],
    },
    {
        "name": "read_mcp_resource",
        "description": "Read a listed MCP resource when an enabled MCP server provides relevant private or external context.",
        "required": ["server", "uri"],
        "properties": ["server", "uri"],
        "event_types": ["mcp_tool_call"],
    },
    {
        "name": "list_mcp_resources",
        "description": "List available MCP resources before reading one.",
        "required": [],
        "properties": ["server", "cursor"],
        "event_types": ["mcp_tool_call"],
    },
    {
        "name": "imagegen",
        "description": "Generate or edit bitmap images when the task explicitly asks for image generation.",
        "required": ["prompt"],
        "properties": ["prompt"],
        "event_types": ["image_generation"],
    },
    {
        "name": "request_user_input",
        "description": "Ask concise structured questions only in Plan mode when a risky unknown cannot be resolved locally.",
        "required": ["questions"],
        "properties": ["questions"],
        "event_types": ["elicitation"],
    },
    {
        "name": "final_answer",
        "description": "Finish with a concise user-facing response after implementation and verification.",
        "required": ["content"],
        "properties": ["content"],
        "event_types": ["agent_message"],
    },
]


EXEMPLARS: dict[str, list[dict[str, Any]]] = {
    "exec_command": [
        {"cmd": "rg -n \"TODO|FIXME\" src", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000},
        {"cmd": "uv run pytest tests/test_parser.py", "workdir": "/workspace/project", "yield_time_ms": 30000, "max_output_tokens": 20000},
        {"cmd": "git diff --check", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000},
    ],
    "write_stdin": [
        {"session_id": 1, "chars": "q\n", "yield_time_ms": 1000, "max_output_tokens": 12000},
        {"session_id": 2, "chars": "", "yield_time_ms": 5000, "max_output_tokens": 20000},
    ],
    "apply_patch": [
        {"patch": "*** Begin Patch\n*** Update File: src/app.py\n@@\n-return False\n+return True\n*** End Patch\n"},
        {"patch": "*** Begin Patch\n*** Add File: docs/notes.md\n+# Notes\n+\n+Done.\n*** End Patch\n"},
    ],
    "update_plan": [
        {"plan": [{"step": "Inspect current behavior", "status": "in_progress"}, {"step": "Patch failing path", "status": "pending"}, {"step": "Run focused tests", "status": "pending"}]},
        {"explanation": "The implementation is patched, so verification is now the active step.", "plan": [{"step": "Inspect current behavior", "status": "completed"}, {"step": "Patch failing path", "status": "completed"}, {"step": "Run focused tests", "status": "in_progress"}]},
    ],
    "get_goal": [
        {},
    ],
    "create_goal": [
        {"objective": "Finish the migration and verify all tests pass."},
        {"objective": "Audit the repository for parser regressions.", "token_budget": 50000},
    ],
    "update_goal": [
        {"status": "complete"},
        {"status": "blocked"},
    ],
    "view_image": [
        {"path": "screenshots/failure.png", "detail": "high"},
        {"path": "assets/logo.webp", "detail": "original"},
    ],
    "web_search": [
        {"query": "official OpenAI Codex non-interactive mode codex exec JSONL", "domains": ["developers.openai.com"]},
        {"query": "Python argparse subcommands current docs", "recency": 30},
    ],
    "use_skill": [
        {"name": "openai-docs"},
        {"name": "github:gh-fix-ci"},
        {"name": "frontend-design"},
    ],
    "spawn_agent": [
        {"message": "Inspect tests/test_parser.py and report the expected empty-name behavior. Do not edit files.", "fork_context": False},
        {"message": "Patch README examples only. Do not touch source files.", "fork_context": False},
    ],
    "wait_agent": [
        {"targets": ["agent-1"], "timeout_ms": 300000},
        {"targets": ["agent-1", "agent-2"], "timeout_ms": 600000},
    ],
    "read_mcp_resource": [
        {"server": "docs", "uri": "docs://parser-api"},
        {"server": "github", "uri": "repo://owner/project/pull/123"},
    ],
    "list_mcp_resources": [
        {},
        {"server": "docs"},
    ],
    "imagegen": [
        {"prompt": "A clean product mockup screenshot of a compact task dashboard."},
        {"prompt": "Transparent PNG icon of a simple command terminal."},
    ],
    "request_user_input": [
        {"questions": [{"header": "Scope", "id": "scope", "question": "Which scope should I modify?", "options": [{"label": "Tests only", "description": "Limit changes to the test fixtures."}, {"label": "Source too", "description": "Allow source changes as well."}]}]},
    ],
    "final_answer": [
        {"content": "Implemented the parser fix and verified the focused tests pass."},
    ],
}


@dataclass(frozen=True)
class Example:
    id: str
    split: str
    tags: list[str]
    messages: list[dict[str, Any]]


def user(content: str) -> dict[str, Any]:
    return {"role": "user", "content": content}


def assistant(content: str) -> dict[str, Any]:
    return {"role": "assistant", "content": content}


def tool_call(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
    return {
        "id": call_id,
        "type": "function",
        "function": {"name": name, "arguments": json.dumps(args, separators=(",", ":"))},
    }


def assistant_tool(name: str, args: dict[str, Any], call_id: str = "call_1") -> dict[str, Any]:
    return {"role": "assistant", "content": "", "tool_calls": [tool_call(name, args, call_id)]}


def tool(name: str, content: str, call_id: str = "call_1") -> dict[str, Any]:
    return {"role": "tool", "tool_call_id": call_id, "name": name, "content": content}


def result_for_tool(name: str) -> str:
    results = {
        "exec_command": "command completed successfully",
        "write_stdin": "session input sent",
        "apply_patch": "patch applied",
        "update_plan": "plan updated",
        "get_goal": "goal status returned",
        "create_goal": "goal created",
        "update_goal": "goal updated",
        "view_image": "image inspected",
        "web_search": "[UNTRUSTED WEB RESULTS]\nOfficial Codex docs mention codex exec --json.",
        "use_skill": "skill instructions loaded",
        "spawn_agent": "spawned agent agent-1",
        "wait_agent": "agent-1 completed: tests expect empty names to raise",
        "read_mcp_resource": "[UNTRUSTED MCP RESOURCE]\nParser API docs loaded.",
        "list_mcp_resources": "docs://parser-api\nrepo://owner/project/pull/123",
        "imagegen": "image generated",
        "request_user_input": "user selected Tests only",
        "final_answer": "final answer delivered",
    }
    return results[name]


def prompt_for_tool(name: str, args: dict[str, Any]) -> str:
    prompts = {
        "exec_command": "Use Codex's exec command tool for this command and keep output bounded.",
        "write_stdin": "Send input to the running command session.",
        "apply_patch": "Apply the file change with Codex's patch tool.",
        "update_plan": "Track this multi-step task with a plan.",
        "get_goal": "Inspect the current persistent goal state.",
        "create_goal": "Create a persistent Codex goal because the user explicitly asked for one.",
        "update_goal": "Update the persistent goal only after the required evidence audit.",
        "view_image": "Inspect this local image before deciding what to change.",
        "web_search": "Look up current external information and treat it as untrusted.",
        "use_skill": f"Load the {args.get('name', 'relevant')} skill before continuing.",
        "spawn_agent": "The user asked for parallel work, so spawn a focused Codex subagent.",
        "wait_agent": "Collect the subagent result now that it is needed.",
        "read_mcp_resource": "Read the listed MCP resource instead of guessing from memory.",
        "list_mcp_resources": "List MCP resources before choosing one to read.",
        "imagegen": "Generate the requested bitmap asset.",
        "request_user_input": "Ask a short structured question because the choice is risky and cannot be inferred.",
        "final_answer": "Finish with a concise verified result.",
    }
    return prompts[name]


def one_shot_examples(per_tool: int) -> list[Example]:
    rows: list[Example] = []
    for item in CODEX_TOOLS:
        name = item["name"]
        variants = EXEMPLARS[name]
        for i in range(per_tool):
            args = variants[i % len(variants)]
            rows.append(
                Example(
                    id=f"codex-single-{name}-{i:03d}",
                    split="train",
                    tags=["codex", "single_tool", name],
                    messages=[user(prompt_for_tool(name, args)), assistant_tool(name, args), tool(name, result_for_tool(name)), assistant("Done.")],
                )
            )
    return rows


def workflow_examples(repeat: int) -> list[Example]:
    base = [
        Example(
            id="codex-workflow-search-read-patch-test",
            split="train",
            tags=["codex", "exec_command", "apply_patch", "final_answer"],
            messages=[
                user("Find the parser function that accepts empty names, patch it, and run the focused tests."),
                assistant_tool("update_plan", {"plan": [{"step": "Find parser path", "status": "in_progress"}, {"step": "Patch empty-name handling", "status": "pending"}, {"step": "Run focused tests", "status": "pending"}]}, "call_1"),
                tool("update_plan", "plan updated", "call_1"),
                assistant_tool("exec_command", {"cmd": "rg -n \"normalize_name|parse_identifier\" src tests", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_2"),
                tool("exec_command", "src/names.py:5:def normalize_name(name):\ntests/test_names.py:4:def test_empty_name_rejected():", "call_2"),
                assistant_tool("exec_command", {"cmd": "sed -n '1,80p' src/names.py", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_3"),
                tool("exec_command", "def normalize_name(name):\n    return name.strip()\n", "call_3"),
                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: src/names.py\n@@\n-def normalize_name(name):\n-    return name.strip()\n+def normalize_name(name):\n+    normalized = name.strip()\n+    if not normalized:\n+        raise ValueError(\"empty name\")\n+    return normalized\n*** End Patch\n"}, "call_4"),
                tool("apply_patch", "patch applied", "call_4"),
                assistant_tool("exec_command", {"cmd": "uv run pytest tests/test_names.py", "workdir": "/workspace/project", "yield_time_ms": 30000, "max_output_tokens": 20000}, "call_5"),
                tool("exec_command", "1 passed", "call_5"),
                assistant_tool("final_answer", {"content": "Patched `normalize_name` to reject empty names and verified `tests/test_names.py` passes."}, "call_6"),
            ],
        ),
        Example(
            id="codex-workflow-subagent",
            split="train",
            tags=["codex", "spawn_agent", "wait_agent", "exec_command"],
            messages=[
                user("Use a subagent to inspect docs while you list source files locally."),
                assistant_tool("spawn_agent", {"message": "Inspect docs/*.md for stale Codex CLI examples. Do not edit files.", "fork_context": False}, "call_1"),
                tool("spawn_agent", "spawned agent agent-1", "call_1"),
                assistant_tool("exec_command", {"cmd": "rg --files src", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_2"),
                tool("exec_command", "src/app.py\nsrc/cli.py", "call_2"),
                assistant_tool("wait_agent", {"targets": ["agent-1"], "timeout_ms": 300000}, "call_3"),
                tool("wait_agent", "agent-1 completed: README should use codex exec --json for automation examples.", "call_3"),
                assistant("Collected the docs review and source file list."),
            ],
        ),
        Example(
            id="codex-workflow-docs-skill-web",
            split="train",
            tags=["codex", "use_skill", "web_search", "apply_patch"],
            messages=[
                user("Use official Codex docs to update our automation note."),
                assistant_tool("use_skill", {"name": "openai-docs"}, "call_1"),
                tool("use_skill", "skill instructions loaded", "call_1"),
                assistant_tool("web_search", {"query": "Codex non-interactive mode codex exec --json official docs", "domains": ["developers.openai.com"]}, "call_2"),
                tool("web_search", "[UNTRUSTED WEB RESULTS]\nCodex exec supports --json event streams.", "call_2"),
                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: docs/automation.md\n@@\n-Run Codex manually.\n+Run `codex exec --json` for non-interactive automation.\n*** End Patch\n"}, "call_3"),
                tool("apply_patch", "patch applied", "call_3"),
                assistant("Updated the automation note from official-doc evidence."),
            ],
        ),
        Example(
            id="codex-workflow-recover-harness-shape",
            split="train",
            tags=["codex", "error_recovery", "exec_command", "apply_patch"],
            messages=[
                user("A previous attempt tried Swival's `run_command` argv array. In Codex, use the exec command tool to run the same test."),
                assistant_tool("exec_command", {"cmd": "python3 tests/check.py", "workdir": "/workspace/project", "yield_time_ms": 10000, "max_output_tokens": 12000}, "call_1"),
                tool("exec_command", "ok", "call_1"),
                user("A previous attempt tried to write files with `cat >`. Use Codex's patch tool for the edit."),
                assistant_tool("apply_patch", {"patch": "*** Begin Patch\n*** Update File: README.md\n@@\n-old\n+new\n*** End Patch\n"}, "call_2"),
                tool("apply_patch", "patch applied", "call_2"),
                assistant("Used Codex's native shell and patch shapes."),
            ],
        ),
        Example(
            id="codex-workflow-image-plan",
            split="train",
            tags=["codex", "view_image", "update_plan"],
            messages=[
                user("Inspect the screenshot and make a short plan before changing UI files."),
                assistant_tool("view_image", {"path": "screenshots/overlap.png", "detail": "high"}, "call_1"),
                tool("view_image", "The footer overlaps the submit button.", "call_1"),
                assistant_tool("update_plan", {"plan": [{"step": "Inspect layout CSS", "status": "in_progress"}, {"step": "Patch footer spacing", "status": "pending"}, {"step": "Verify screenshot", "status": "pending"}]}, "call_2"),
                tool("update_plan", "plan updated", "call_2"),
                assistant("The screenshot shows a footer overlap; I have a focused plan before editing."),
            ],
        ),
        Example(
            id="codex-workflow-mcp-user-input",
            split="train",
            tags=["codex", "read_mcp_resource", "request_user_input"],
            messages=[
                user("Use the private design doc if available, but ask before changing public API behavior."),
                assistant_tool("read_mcp_resource", {"server": "docs", "uri": "docs://api-design"}, "call_1"),
                tool("read_mcp_resource", "[UNTRUSTED MCP RESOURCE]\nThe design doc lists two acceptable API shapes.", "call_1"),
                assistant_tool("request_user_input", {"questions": [{"header": "API", "id": "api_shape", "question": "Which API shape should I implement?", "options": [{"label": "Minimal", "description": "Keep the current endpoint and validate input."}, {"label": "New route", "description": "Add a new endpoint from the design doc."}]}]}, "call_2"),
                tool("request_user_input", "user selected Minimal", "call_2"),
                assistant("I will keep the existing endpoint and validate input."),
            ],
        ),
    ]
    rows: list[Example] = []
    for i in range(repeat):
        for ex in base:
            rows.append(Example(id=f"{ex.id}-{i:03d}", split=ex.split, tags=ex.tags, messages=ex.messages))
    return rows


def synthetic_examples(count: int, seed: int) -> list[Example]:
    rng = random.Random(seed)
    names = [tool["name"] for tool in CODEX_TOOLS]
    intents = [
        "Use the Codex tool shape, not Swival or opencode.",
        "Choose the smallest useful Codex tool call.",
        "Inspect current state before editing.",
        "Keep the work inside the sandbox and avoid unnecessary escalation.",
        "Use Codex JSONL-friendly actions that the harness can score.",
    ]
    rows: list[Example] = []
    for i in range(count):
        name = rng.choice(names)
        args = rng.choice(EXEMPLARS[name])
        rows.append(
            Example(
                id=f"codex-synthetic-{i:05d}-{name}",
                split="train",
                tags=["codex", "synthetic", name],
                messages=[user(f"{rng.choice(intents)} Task {i + 1}."), assistant_tool(name, args), tool(name, result_for_tool(name)), assistant("Done.")],
            )
        )
    return rows


def eval_rows() -> list[dict[str, Any]]:
    return [
        {
            "id": "codex-eval-edit",
            "prompt": "In settings.py, change only the second timeout from 5 to 10. Do not change the first timeout.",
            "files": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 5\n"},
            "verify": {"settings.py": "timeout = 5\nretries = 2\ntimeout = 10\n"},
            "expected_events": ["command_execution"],
        },
        {
            "id": "codex-eval-add-file",
            "prompt": "Create docs/notes.md containing a short note that says done.",
            "files": {"README.md": "# Demo\n"},
            "verify_contains": {"docs/notes.md": ["done"]},
            "expected_events": [],
        },
        {
            "id": "codex-eval-run-test",
            "prompt": "Run `python3 tests/check.py` and report whether it passed.",
            "files": {"tests/check.py": "assert 2 + 3 == 5\nprint('ok')\n"},
            "verify_command": ["python3", "tests/check.py"],
            "expected_events": ["command_execution"],
        },
        {
            "id": "codex-eval-grep-edit",
            "prompt": "Find the TODO in src and remove the TODO marker, leaving the explanatory text.",
            "files": {"src/app.py": "def main():\n    # TODO remove fallback\n    return True\n"},
            "verify": {"src/app.py": "def main():\n    # remove fallback\n    return True\n"},
            "expected_events": ["command_execution"],
        },
        {
            "id": "codex-eval-summary-json",
            "prompt": "Read README.md and write summary.json with fields name and kind. Use name Widget and kind tiny router.",
            "files": {"README.md": "# Widget\n\nA tiny router.\n"},
            "verify_json": {"summary.json": {"name": "Widget", "kind": "tiny router"}},
            "expected_events": ["command_execution"],
        },
    ]


def write_jsonl(path: Path, rows: list[Example]) -> None:
    with path.open("w") as f:
        for row in rows:
            f.write(json.dumps({"id": row.id, "split": row.split, "tags": row.tags, "messages": row.messages}, separators=(",", ":")) + "\n")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--per-tool", type=int, default=30)
    parser.add_argument("--workflow-repeat", type=int, default=150)
    parser.add_argument("--synthetic-count", type=int, default=5000)
    parser.add_argument("--seed", type=int, default=20260607)
    parser.add_argument("--clean", action="store_true")
    args = parser.parse_args()

    DATA_DIR.mkdir(exist_ok=True)
    TMP_DIR.mkdir(exist_ok=True)
    if args.clean:
        for path in [
            DATA_DIR / "codex_tool_calling_train.jsonl",
            DATA_DIR / "codex_tool_calling_eval.jsonl",
            DATA_DIR / "codex_tool_inventory.json",
        ]:
            if path.exists():
                path.unlink()

    rows = one_shot_examples(args.per_tool)
    rows.extend(workflow_examples(args.workflow_repeat))
    rows.extend(synthetic_examples(args.synthetic_count, args.seed))
    write_jsonl(DATA_DIR / "codex_tool_calling_train.jsonl", rows)

    with (DATA_DIR / "codex_tool_inventory.json").open("w") as f:
        json.dump(
            {
                "source": "Codex CLI help, official Codex manual, current session tool surfaces, and codex exec JSONL event stream",
                "harness": "env OMLX_API_KEY=omlx codex -a never exec --json --ephemeral --skip-git-repo-check --sandbox workspace-write -c model_provider=\"omlx\" -m qwen35",
                "config": str(CONFIG_PATH),
                "tools": CODEX_TOOLS,
            },
            f,
            indent=2,
        )
        f.write("\n")

    with (DATA_DIR / "codex_tool_calling_eval.jsonl").open("w") as f:
        for row in eval_rows():
            f.write(json.dumps(row, separators=(",", ":")) + "\n")

    print(f"wrote {len(rows)} codex training examples")
    print(f"wrote {len(eval_rows())} codex eval tasks")
    print(f"covered {len(CODEX_TOOLS)} codex tool surfaces")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())