#!/usr/bin/env python3
"""Persist a five-minute machine-readable heartbeat for the Codex SDK sweep."""

from __future__ import annotations

import argparse
import json
import os
import subprocess
import time
from datetime import datetime, timezone
from pathlib import Path

from ptb_codex_sdk_status import MODELS, ROOT, SWEEP, TASKS, classify

INITIAL_JOB = {
    (model, task): str(402112 + model_i * len(TASKS) + task_i)
    for model_i, model in enumerate(MODELS)
    for task_i, task in enumerate(TASKS)
}
TERMINAL_FAILURES = {
    "BOOT_FAIL", "CANCELLED", "DEADLINE", "FAILED", "NODE_FAIL", "OUT_OF_MEMORY",
    "PREEMPTED", "REVOKED", "TIMEOUT",
}


def current_jobs() -> dict[tuple[str, str], str]:
    """Overlay recovery job IDs recorded after an initial cell failure."""
    jobs = dict(INITIAL_JOB)
    path = ROOT / "RECOVERY_JOBS.json"
    if path.is_file():
        for key, job in json.loads(path.read_text()).items():
            model, task = key.split("|", 1)
            jobs[(model, task)] = str(job)
    return jobs


def scheduler_states(jobs: dict[tuple[str, str], str]) -> dict[str, dict[str, str]]:
    ids = ",".join(jobs.values())
    output = subprocess.run(
        ["sacct", "-j", ids, "--format=JobIDRaw,State,ExitCode,Elapsed", "-n", "-P"],
        check=False, capture_output=True, text=True,
    ).stdout
    states: dict[str, dict[str, str]] = {}
    for line in output.splitlines():
        job, state, code, elapsed, *_ = (line.split("|") + [""] * 4)[:4]
        if "." not in job and job in jobs.values():
            states[job] = {"state": state.split()[0], "exit_code": code, "elapsed": elapsed}
    return states


def build_snapshot() -> dict:
    jobs = current_jobs()
    scheduler = scheduler_states(jobs)
    cells = []
    counts: dict[str, int] = {}
    action_required = []
    for model in MODELS:
        safe_model = model.replace("/", "_")
        for task in TASKS:
            runs = sorted(SWEEP.glob(f"{task}_{safe_model}_*"))
            run = runs[-1] if runs else None
            status, score = classify(run)
            counts[status] = counts.get(status, 0) + 1
            job = jobs[(model, task)]
            job_state = scheduler.get(job, {}).get("state", "UNKNOWN")
            cell = {
                "task": task, "model": model, "job_id": job, "job_state": job_state,
                "artifact_status": status, "score": score,
                "run_dir": str(run) if run else None,
            }
            cells.append(cell)
            if job_state in TERMINAL_FAILURES and status != "complete":
                action_required.append(cell)
    return {
        "checked_at": datetime.now(timezone.utc).isoformat(),
        "results_root": str(ROOT),
        "counts": counts,
        "complete": counts.get("complete", 0) == len(TASKS) * len(MODELS),
        "action_required": action_required,
        "cells": cells,
    }


def write_snapshot(snapshot: dict) -> None:
    ROOT.mkdir(parents=True, exist_ok=True)
    temporary = ROOT / "WATCH_STATUS.json.tmp"
    destination = ROOT / "WATCH_STATUS.json"
    temporary.write_text(json.dumps(snapshot, indent=2) + "\n")
    temporary.replace(destination)
    with (ROOT / "WATCH.log").open("a") as log:
        log.write(f"{snapshot['checked_at']} counts={snapshot['counts']} "
                  f"action_required={len(snapshot['action_required'])}\n")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--interval", type=int, default=300)
    parser.add_argument("--once", action="store_true")
    args = parser.parse_args()
    while True:
        snapshot = build_snapshot()
        write_snapshot(snapshot)
        print(json.dumps({key: snapshot[key] for key in
                          ("checked_at", "counts", "complete", "action_required")}), flush=True)
        if args.once or snapshot["complete"]:
            return
        time.sleep(args.interval)


if __name__ == "__main__":
    main()