"""Large-scale single-event-upset campaign over trained 3DGS models.

For every (scene, precision, field, bit) cell we draw S random fault sites
(a Gaussian and a component), flip the bit in the stored representation,
re-render K held-out views, and record perceptual degradation + a catastrophe
flag.  Results are written as compressed per-(scene,precision) shards plus a
running log so the run survives disconnects.
"""
import argparse
import glob
import json
import os
import time

import numpy as np
import torch
import lpips as lpips_mod

import faultlib as F
from common import ssim
import gsmodel

FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]
FIELD_ID = {f: i for i, f in enumerate(FIELDS)}
BITCLASS_ID = {"sign": 0, "exp": 1, "mantissa": 2}


def pick_views(tvm, tKs, K):
    n = tvm.shape[0]
    idx = np.linspace(0, n - 1, K).round().astype(int)
    return tvm[idx].cuda(), tKs[idx].cuda()


def run_model(model_path, out_dir, precisions, K, S, lpips_fn, seed, guard, log):
    ckpt = torch.load(model_path, map_location="cuda", weights_only=False)
    params = {k: v.cuda().float() for k, v in ckpt["params"].items()}
    sh_degree = ckpt["sh_degree"]
    W, H = ckpt["W"], ckpt["H"]
    scene = ckpt["scene"]
    N = params["means"].shape[0]
    tvm, tKs = pick_views(ckpt["test_viewmats"], ckpt["test_Ks"], K)
    bounds = F.compute_bounds(params)

    def log_print(*a):
        msg = " ".join(str(x) for x in a)
        print(msg, flush=True)
        with open(log, "a") as fh:
            fh.write(msg + "\n")

    log_print(f"[{scene}] N={N} WxH={W}x{H} K={K} S={S} guard={guard} views={tvm.shape[0]}")

    for prec in precisions:
        stored, work = F.quantize_params(params, prec)
        nbits = F.PREC[prec][2]
        # clean reference at this precision
        clean_img, clean_cat = F.render_views(work, tvm, tKs, W, H, sh_degree)
        assert not clean_cat, f"clean render catastrophe for {scene}/{prec}"

        # per-field flattened component counts
        comps = {f: work[f].reshape(N, -1).shape[1] for f in FIELDS}
        rows = []
        t0 = time.time()
        n_inj = 0
        rng = np.random.default_rng(seed + hash((scene, prec)) % (2 ** 31))
        for field in FIELDS:
            Cf = comps[field]
            wfield = work[field]
            sfield = stored[field]
            for bit in range(nbits):
                bc = BITCLASS_ID[F.bit_class(prec, bit)]
                for _ in range(S):
                    g = int(rng.integers(0, N))
                    c = int(rng.integers(0, Cf))
                    flat_idx = g * Cf + c
                    clean_val, corr_val = F.flip_one(sfield, wfield, flat_idx, bit, prec)
                    if guard:
                        gwork = F.apply_guard(work, bounds)
                        img, cat = F.render_views(gwork, tvm, tKs, W, H, sh_degree)
                    else:
                        img, cat = F.render_views(work, tvm, tKs, W, H, sh_degree)
                    m = F.metrics(img, clean_img, lpips_fn, ssim)
                    F.restore_one(wfield, flat_idx, clean_val)
                    rows.append((FIELD_ID[field], bit, bc, g, c,
                                 float(clean_val), float(corr_val),
                                 m["mse"], m["psnr"], m["ssim"], m["lpips"],
                                 m["maxerr"], m["fracchg"], int(cat)))
                    n_inj += 1
            dt = time.time() - t0
            log_print(f"  [{scene}/{prec}] field={field} done  "
                      f"n_inj={n_inj} elapsed={dt:.1f}s  rate={n_inj/dt:.1f}/s")

        arr = np.array(rows, dtype=np.float64)
        cols = ["field_id", "bit", "bitclass", "g", "c", "clean_val", "corr_val",
                "mse", "psnr", "ssim", "lpips", "maxerr", "fracchg", "cat"]
        tag = f"{scene}_{prec}" + ("_guard" if guard else "")
        np.savez_compressed(os.path.join(out_dir, f"shard_{tag}.npz"),
                            data=arr, cols=np.array(cols),
                            meta=np.array([scene, prec, str(N), str(K), str(S),
                                           str(sh_degree), str(W), str(H)]))
        log_print(f"  SAVED shard_{tag}.npz rows={len(rows)} "
                  f"total_time={time.time()-t0:.1f}s")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--results_dir", default="/root/seu/results")
    ap.add_argument("--scenes", default="chair,lego,ficus,hotdog")
    ap.add_argument("--out", default="/root/seu/results/campaign")
    ap.add_argument("--precisions", default="fp32,fp16,bf16")
    ap.add_argument("--K", type=int, default=4)
    ap.add_argument("--S", type=int, default=1500)
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--guard", type=int, default=0)
    args = ap.parse_args()
    os.makedirs(args.out, exist_ok=True)
    log = os.path.join(args.out, "campaign.log")
    lpips_fn = lpips_mod.LPIPS(net="alex").cuda().eval()
    for p in lpips_fn.parameters():
        p.requires_grad_(False)

    precisions = args.precisions.split(",")
    scenes = args.scenes.split(",")
    t_all = time.time()
    for sc in scenes:
        mp = os.path.join(args.results_dir, sc, "model.pt")
        if not os.path.exists(mp):
            print("missing", mp, flush=True)
            continue
        run_model(mp, args.out, precisions, args.K, args.S, lpips_fn, args.seed,
                  args.guard, log)
    with open(log, "a") as fh:
        fh.write(f"CAMPAIGN_DONE total={time.time()-t_all:.1f}s\n")
    print(f"CAMPAIGN_DONE total={time.time()-t_all:.1f}s", flush=True)


if __name__ == "__main__":
    main()