"""Throughput / parallel-scaling micro-benchmark for the fault-injection engine.

Reports: (a) batched multi-camera render throughput vs camera count C (how the
single device's parallel rasterizer absorbs more work), (b) end-to-end injection
throughput vs views-per-injection K, (c) the per-frame cost of the parallel
range-guard relative to a render.  All numbers are measured on the real model.
"""
import argparse
import json
import os
import time

import numpy as np
import torch

import faultlib as F
import gsmodel


def timed(fn, iters, warmup=5):
    for _ in range(warmup):
        fn()
    torch.cuda.synchronize()
    t = time.time()
    for _ in range(iters):
        fn()
    torch.cuda.synchronize()
    return (time.time() - t) / iters


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", default="/root/seu/results/chair/model.pt")
    ap.add_argument("--out", default="/root/seu/results/bench.json")
    args = ap.parse_args()
    ckpt = torch.load(args.model, map_location="cuda", weights_only=False)
    params = {k: v.cuda().float() for k, v in ckpt["params"].items()}
    sh = ckpt["sh_degree"]
    W, H = ckpt["W"], ckpt["H"]
    N = params["means"].shape[0]
    tvm = ckpt["test_viewmats"].cuda()
    tKs = ckpt["test_Ks"].cuda()
    nv = tvm.shape[0]
    bounds = F.compute_bounds(params)
    res = {"N": int(N), "W": W, "H": H, "scene": ckpt["scene"]}

    # (a) batched render throughput vs number of cameras
    cam_scale = []
    for C in [1, 2, 4, 8, 16, 32, 64]:
        vm = tvm[torch.arange(C) % nv]
        ks = tKs[torch.arange(C) % nv]
        t = timed(lambda: gsmodel.render(params, vm, ks, W, H, sh), iters=30)
        mpix = C * W * H / 1e6 / t
        cam_scale.append({"C": C, "sec_per_call": t, "frames_per_s": C / t, "mpix_per_s": mpix})
        print(f"render C={C:3d}: {t*1000:7.2f} ms  {C/t:8.1f} frames/s  {mpix:8.1f} Mpix/s", flush=True)
    res["render_camera_scaling"] = cam_scale

    # (b) end-to-end injection throughput vs K (flip + render + restore, no metrics)
    stored, work = F.quantize_params(params, "fp32")
    inj_scale = []
    for K in [1, 2, 4, 8]:
        vm = tvm[torch.arange(K) % nv]
        ks = tKs[torch.arange(K) % nv]

        def one():
            cv, _ = F.flip_one(stored["scales"], work["scales"], 7, 22, "fp32")
            F.render_views(work, vm, ks, W, H, sh)
            F.restore_one(work["scales"], 7, cv)
        t = timed(one, iters=200)
        inj_scale.append({"K": K, "sec_per_inj": t, "inj_per_s": 1.0 / t})
        print(f"inject K={K}: {t*1000:6.2f} ms  {1.0/t:8.1f} inj/s", flush=True)
    res["inject_view_scaling"] = inj_scale

    # (c) range-guard cost vs render cost (single frame)
    t_guard = timed(lambda: F.apply_guard(work, bounds), iters=200)
    t_render1 = timed(lambda: gsmodel.render(params, tvm[:1], tKs[:1], W, H, sh), iters=100)
    res["guard_sec"] = t_guard
    res["render1_sec"] = t_render1
    res["guard_frac_of_render"] = t_guard / t_render1
    print(f"guard: {t_guard*1e6:.1f} us   render(1 view): {t_render1*1e3:.3f} ms   "
          f"guard/render = {t_guard/t_render1:.4f}", flush=True)

    with open(args.out, "w") as f:
        json.dump(res, f, indent=2)
    print("SAVED", args.out, flush=True)


if __name__ == "__main__":
    main()