"""One guarded optimization step on independently reviewed training frames."""

from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path
import time

import torch
from torch.utils.data import DataLoader

from pallet.annotation import load_jsonl
from pallet.data import canonical_records, fit_normalization, scan_dataset, unify_duplicate_groups
from pallet.experiments.dataset import PalletDataset, collate_pallet
from pallet.models import PalletDetector


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--root", default="/root/private/data/pallet")
    parser.add_argument("--annotations", default="outputs/annotations_pilot.jsonl")
    parser.add_argument("--index", default="outputs/content_hashes.json")
    parser.add_argument("--pretrained", default="yolo26s.pt")
    parser.add_argument("--output", default="outputs/pilot_gpu_smoke.json")
    parser.add_argument("--device", default="cuda:0")
    args = parser.parse_args()
    records = canonical_records(scan_dataset(args.root))
    if Path(args.index).exists():
        records = unify_duplicate_groups(records, json.loads(Path(args.index).read_text()))
    labels = load_jsonl(args.annotations)
    rows = [row for row in records if row.frame_id in labels.frames
            and labels.frames[row.frame_id].split == "train"
            and labels.frames[row.frame_id].status == "pos"
            and len(labels.frames[row.frame_id].reviews) >= 2]
    if len(rows) < 2:
        raise ValueError("at least two independently reviewed training examples are required")
    chosen = rows[:2]
    normalization = fit_normalization(chosen)
    loader = DataLoader(PalletDataset(chosen, labels, normalization, size=320), batch_size=2,
                        collate_fn=collate_pallet)
    batch = next(iter(loader))
    model = PalletDetector(1, pretrained=args.pretrained).train().to(args.device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=0.001)
    torch.cuda.reset_peak_memory_stats(torch.device(args.device))
    start = time.perf_counter()
    loss, _ = model.loss({key: value.to(args.device) for key, value in batch.items() if key != "meta"})
    loss.sum().backward()
    optimizer.step()
    torch.cuda.synchronize(torch.device(args.device))
    elapsed = time.perf_counter() - start
    payload = {"status": "one-step smoke, not a trained/evaluated detector",
               "frames": [row.frame_id for row in chosen], "loss_components": loss.detach().cpu().tolist(),
               "seconds": elapsed,
               "peak_gpu_mib": torch.cuda.max_memory_allocated(torch.device(args.device)) / 2**20,
               "normalization": normalization.__dict__,
               "weights_sha256": hashlib.sha256(Path(args.pretrained).read_bytes()).hexdigest()}
    Path(args.output).write_text(json.dumps(payload, indent=2), encoding="utf-8")
    print(json.dumps(payload, ensure_ascii=False))


if __name__ == "__main__":
    main()
