"""Forward latency and input preparation time on a real sensor capture."""

from __future__ import annotations

import argparse
import hashlib
import importlib.metadata
import json
from pathlib import Path
import statistics
import time

import torch

from pallet.data import apply_normalization, canonical_records, load_frame, scan_dataset
from pallet.data.loader import NormalizationStats
from pallet.devices import device_metadata, resolve_device
from pallet.experiments.dataset import letterbox_float
from pallet.models import PalletDetector, RFDETRDetector


def _sync(device):
    if device.type == "cuda":
        torch.cuda.synchronize(device)


def _summary(samples):
    values = sorted(samples)
    return {"median_ms": statistics.median(values) * 1000,
            "p95_ms": values[min(len(values) - 1, int(0.95 * len(values)))] * 1000}


def _sha256(path):
    digest = hashlib.sha256()
    with Path(path).open("rb") as source:
        for chunk in iter(lambda: source.read(4 * 1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def benchmark_model(model, record, *, device="cuda:0", size=640, warmup=5, repeats=20):
    """Time prepared batch-one forward passes separately from CPU PCD preparation."""
    device = resolve_device(device)
    if size != 640 or repeats < 1:
        raise ValueError("Benchmark requires size=640 and repeats>=1")
    normalization = NormalizationStats(depth_scale=5000, intensity_scale=10)
    start = time.perf_counter()
    raw = load_frame(record)
    image, _, _ = letterbox_float(apply_normalization(raw, normalization), size)
    tensor = image.unsqueeze(0).to(device)
    _sync(device)
    preparation = [time.perf_counter() - start]
    model.eval().to(device)
    if device.type == "cuda":
        torch.cuda.reset_peak_memory_stats(device)
    with torch.inference_mode():
        for _ in range(warmup):
            model(tensor)
        _sync(device)
        forward = []
        for _ in range(repeats):
            _sync(device)
            start = time.perf_counter()
            model(tensor)
            _sync(device)
            forward.append(time.perf_counter() - start)
    for _ in range(repeats):
        start = time.perf_counter()
        raw = load_frame(record)
        prepared, _, _ = letterbox_float(apply_normalization(raw, normalization), size)
        prepared.unsqueeze(0).to(device)
        _sync(device)
        preparation.append(time.perf_counter() - start)
    return {"batch": 1, "precision": "fp32", "image_size": size,
            "forward_only": _summary(forward),
            "pcd_load_preprocess_and_upload": _summary(preparation),
            "parameters": sum(param.numel() for param in model.parameters()),
            "peak_gpu_mib": torch.cuda.max_memory_allocated(device) / 2**20
            if device.type == "cuda" else 0,
            "transfer_coverage": getattr(model, "transfer_report", None)}


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--root", default="/root/private/data/pallet")
    parser.add_argument("--frame-id", default="2024_11_29/29-11-2024_07-00-28#all")
    parser.add_argument("--size", type=int, default=640, choices=[640])
    parser.add_argument("--device", default="cuda:0", help="PyTorch CUDA index or GPU UUID")
    parser.add_argument("--repeats", type=int, default=20)
    parser.add_argument("--output", default="outputs/benchmark_v3/architecture_benchmark.json")
    args = parser.parse_args()
    record = next(row for row in canonical_records(scan_dataset(args.root))
                  if row.frame_id == args.frame_id)
    variants = {
        "yolov8s": lambda: PalletDetector(1, p2=False, family="yolov8", pretrained="yolov8s.pt"),
        "yolov8s_cspnext_approximation": lambda: PalletDetector(
            1, p2=False, family="yolov8-cspnext", pretrained="yolov8s.pt"),
        "yolo26s": lambda: PalletDetector(1, p2=False, pretrained="yolo26s.pt"),
        "pallet_yolo26": lambda: PalletDetector(1, p2=True, pretrained="yolo26s.pt"),
        "rfdetr_small": lambda: RFDETRDetector(resolution=args.size, pretrained=True),
    }
    metadata = device_metadata(args.device)
    result = {"status": "pretrained architecture timing; no fine-tuned accuracy implied",
              "measurement": "forward only, batch 1, FP32, 640 pixels",
              "frame_id": args.frame_id, "device": metadata,
              "torch": torch.__version__, "ultralytics": importlib.metadata.version("ultralytics"),
              "rfdetr": importlib.metadata.version("rfdetr"),
              "weights_sha256": {
                  "yolo26s.pt": _sha256("yolo26s.pt"),
                  "yolov8s.pt": _sha256("yolov8s.pt"),
                  "rf-detr-small.pth": _sha256("/root/.roboflow/models/rf-detr-small.pth"),
              }, "results": {}}
    for name, create in variants.items():
        model = create()
        result["results"][name] = benchmark_model(model, record, device=metadata["device"],
                                                    size=args.size, repeats=args.repeats)
        print(name, {key: result["results"][name][key] for key in
                     ("forward_only", "pcd_load_preprocess_and_upload", "peak_gpu_mib")}, flush=True)
        del model
        if metadata["device"].startswith("cuda"):
            torch.cuda.empty_cache()
    output = Path(args.output)
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(json.dumps(result, indent=2), encoding="utf-8")


if __name__ == "__main__":
    main()
