#!/usr/bin/env python3
"""Shard eval_mlebench.py (or any repo command) across a GKE Indexed Job.

    # 20 comps x 3 arms x 10 repeats, one pod per (comp, 2-repeat chunk):
    gke/.venv/bin/python gke/submit_eval.py submit --run r1 \
        --competitions-from-split both --arms all --repeats 10 --repeat-chunk 2 \
        --parallelism 50

    # generic parallel command (rubric_gen experiments etc.); the shard sees
    # SHARD_INDEX / SHARD_COUNT / MLEBENCH_DATA_DIR / WORK_DIR in its env:
    gke/.venv/bin/python gke/submit_eval.py submit --run cf1 --mode cmd \
        --shards 40 --competitions-from-split both \
        --command 'cd rubric_gen && python counterfactual.py ... ' \
        --artifacts 'rubric_gen/results/*.json'

    gke/.venv/bin/python gke/submit_eval.py status  --run r1
    gke/.venv/bin/python gke/submit_eval.py logs    --run r1 --index 3
    gke/.venv/bin/python gke/submit_eval.py collect --run r1
    gke/.venv/bin/python gke/submit_eval.py cancel  --run r1

The working tree ships as the code snapshot (git-tracked + untracked-unignored
files), so uncommitted changes run as-is. Each shard resumes from its own
previous rows on retry. Results merge locally into data/gke_runs/<run>.jsonl.
"""
from __future__ import annotations

import argparse
import json
import sys
import time
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
import k8s as K
import settings as S

REPO = Path(__file__).resolve().parents[1]
upload_code = K.upload_code


def job_name(run: str) -> str:
    return f"eval-{run.lower().replace('_', '-')[:40].strip('-')}"


def build_shards(args) -> list[dict]:
    comps: list[str] = []
    if args.competitions:
        comps += [c.strip() for c in args.competitions.split(",") if c.strip()]
    if args.competitions_from_split != "none":
        sys.path.insert(0, str(REPO / "gke"))
        from prep_datasets import split_sides

        sides = split_sides()
        comps += [c for c, s in sides.items()
                  if args.competitions_from_split in (s, "both")]

    if args.mode == "cmd":
        if not args.command:
            raise SystemExit("--mode cmd needs --command")
        n = args.shards or 1
        return [{"command": args.command, "shard_count": n,
                 "competitions": comps,
                 "artifacts": args.artifacts.split(",") if args.artifacts else []}
                for _ in range(n)]

    if not comps:
        raise SystemExit("no competitions selected")
    shards = []
    if args.repeats:
        # eval_mlebench.py repeats are 1-based INCLUSIVE:
        # for repeat in range(repeat_start, repeat_end + 1)
        chunk = args.repeat_chunk or args.repeats
        ranges = [(a + 1, min(a + chunk, args.repeats))
                  for a in range(0, args.repeats, chunk)]
    else:
        ranges = [(None, None)]
    for i in range(0, len(comps), args.group_size):
        group = comps[i:i + args.group_size]
        for start, end in ranges:
            shard: dict = {"competitions": group}
            if start is not None:
                shard.update(repeats=args.repeats, repeat_start=start,
                             repeat_end=end)
            shards.append(shard)
    return shards


def cmd_submit(args) -> None:
    shards = build_shards(args)
    common = {"arms": args.arms, "run_cap": args.run_cap}
    if args.db:
        common["db"] = args.db
    if args.eval_arg:
        common["extra_args"] = args.eval_arg
    manifest = {"run": args.run, "mode": args.mode, "common": common,
                "shards": shards, "submitted_unix": int(time.time())}
    S.bucket().blob(f"runs/{args.run}/manifest.json").upload_from_string(
        json.dumps(manifest, indent=1))
    upload_code(args.run)

    n = len(shards)
    job = K.make_indexed_job(
        name=job_name(args.run), run_id=args.run, mode=args.mode,
        completions=n, parallelism=min(args.parallelism, n),
        cpu=args.cpu, memory=args.memory, scratch_gi=args.scratch,
        gpu=args.gpu or None, spot=args.spot,
    )
    K.submit_job(job)
    print(f"[ok] job {job.metadata.name}: {n} shards, parallelism "
          f"{min(args.parallelism, n)}, cpu={args.cpu} mem={args.memory} "
          f"scratch={args.scratch}Gi gpu={args.gpu or 'none'} spot={args.spot}")
    print(f"     shards preview: {json.dumps(shards[0])[:200]}")
    print(f"     status: gke/.venv/bin/python gke/submit_eval.py status --run {args.run}")


def cmd_status(args) -> None:
    print(K.job_status(job_name(args.run)))
    blobs = list(S.storage_client().list_blobs(
        S.BUCKET, prefix=f"runs/{args.run}/shards/"))
    done = sum(1 for b in blobs if b.name.endswith(".done"))
    rows = 0
    for b in blobs:
        if b.name.endswith(".jsonl") and not b.name.endswith(".gymlog.jsonl"):
            rows += b.download_as_text().count("\n")
    print(f"shards done: {done} | result rows so far: {rows}")


def cmd_logs(args) -> None:
    print(K.pod_logs(job_name(args.run), index=args.index, tail=args.tail))


def cmd_collect(args) -> None:
    out_dir = REPO / "data" / "gke_runs"
    out_dir.mkdir(parents=True, exist_ok=True)
    out = out_dir / f"{args.run}.jsonl"
    rows, shards = [], 0
    for b in S.storage_client().list_blobs(S.BUCKET, prefix=f"runs/{args.run}/shards/"):
        if b.name.endswith(".jsonl") and not b.name.endswith(".gymlog.jsonl"):
            rows += [l for l in b.download_as_text().splitlines() if l.strip()]
            shards += 1
    out.write_text("\n".join(rows) + ("\n" if rows else ""))
    print(f"[ok] {len(rows)} rows from {shards} shards -> {out}")


def cmd_cancel(args) -> None:
    _, batch = S.kube_api()
    batch.delete_namespaced_job(
        name=job_name(args.run), namespace=S.NAMESPACE,
        propagation_policy="Background")
    print(f"[ok] deleted job {job_name(args.run)} (results in GCS are kept)")


def main() -> None:
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="cmd", required=True)
    p = sub.add_parser("submit")
    p.add_argument("--run", required=True)
    p.add_argument("--mode", choices=("eval", "cmd"), default="eval")
    p.add_argument("--competitions", default="")
    p.add_argument("--competitions-from-split",
                   choices=("train", "eval", "both", "none"), default="none")
    p.add_argument("--arms", default="all")
    p.add_argument("--repeats", type=int, default=0)
    p.add_argument("--repeat-chunk", type=int, default=0)
    p.add_argument("--group-size", type=int, default=1,
                   help="Competitions per shard.")
    p.add_argument("--run-cap", type=int, default=1800)
    p.add_argument("--db", default="")
    p.add_argument("--eval-arg", action="append", default=[],
                   help="Extra arg passed through to eval_mlebench.py (repeatable).")
    p.add_argument("--command", default="")
    p.add_argument("--shards", type=int, default=0, help="Shard count for --mode cmd.")
    p.add_argument("--artifacts", default="",
                   help="Comma-separated globs uploaded after a cmd shard.")
    p.add_argument("--parallelism", type=int, default=20)
    p.add_argument("--cpu", default="4")
    p.add_argument("--memory", default="16Gi")
    p.add_argument("--scratch", type=int, default=100)
    p.add_argument("--gpu", default="", help="e.g. nvidia-l4 or nvidia-tesla-t4")
    p.add_argument("--spot", action="store_true")
    for name in ("status", "logs", "collect", "cancel"):
        q = sub.add_parser(name)
        q.add_argument("--run", required=True)
        q.add_argument("--index", type=int, default=None)
        q.add_argument("--tail", type=int, default=100)
    args = ap.parse_args()
    {"submit": cmd_submit, "status": cmd_status, "logs": cmd_logs,
     "collect": cmd_collect, "cancel": cmd_cancel}[args.cmd](args)


if __name__ == "__main__":
    main()