"""Multi-upset accumulation: how many simultaneous single-bit upsets can a 3DGS
model absorb before global render quality collapses?  Models accumulated
radiation dose.  Upsets are drawn uniformly over the whole stored bit budget
(field sampled in proportion to its element x bit count), so each draw is a
realistic random VRAM bit.
"""
import argparse
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, psnr
import gsmodel

FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"]


def run(model_path, out_dir, precisions, K, ks, repeats, lpips_fn, seed, log, guard=False):
    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]
    bounds = F.compute_bounds(params)
    n = ckpt["test_viewmats"].shape[0]
    idx = np.linspace(0, n - 1, K).round().astype(int)
    tvm = ckpt["test_viewmats"][idx].cuda()
    tKs = ckpt["test_Ks"][idx].cuda()

    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")

    rows = []
    for prec in precisions:
        stored, work = F.quantize_params(params, prec)
        nbits = F.PREC[prec][2]
        comps = {f: work[f].reshape(N, -1).shape[1] for f in FIELDS}
        # field sampling weights proportional to (#elements * #bits)
        weights = np.array([comps[f] * N * nbits for f in FIELDS], dtype=np.float64)
        weights /= weights.sum()
        clean_img, _ = F.render_views(work, tvm, tKs, W, H, sh_degree)
        rng = np.random.default_rng(seed + hash((scene, prec)) % (2 ** 31))
        for k in ks:
            for r in range(repeats):
                sites = []  # (field, flat_idx, clean_val)
                for _ in range(k):
                    fi = rng.choice(6, p=weights)
                    field = FIELDS[fi]
                    Cf = comps[field]
                    flat_idx = int(rng.integers(0, N * Cf))
                    bit = int(rng.integers(0, nbits))
                    clean_val, _ = F.flip_one(stored[field], work[field], flat_idx, bit, prec)
                    sites.append((field, flat_idx, clean_val))
                render_in = F.apply_guard(work, bounds) if guard else work
                img, cat = F.render_views(render_in, tvm, tKs, W, H, sh_degree)
                mse = torch.mean((img - clean_img) ** 2).item()
                ps = -10.0 * np.log10(max(mse, 1e-12))
                ss = ssim(img.permute(0, 3, 1, 2), clean_img.permute(0, 3, 1, 2)).item()
                with torch.no_grad():
                    lp = lpips_fn(img.permute(0, 3, 1, 2) * 2 - 1,
                                  clean_img.permute(0, 3, 1, 2) * 2 - 1).mean().item()
                for field, flat_idx, clean_val in sites:
                    F.restore_one(work[field], flat_idx, clean_val)
                rows.append((k, r, ps, ss, lp, float(mse), int(cat)))
            sub = [x for x in rows if x[0] == k]
            pss = np.array([x[2] for x in sub])
            log_print(f"  [{scene}/{prec}] k={k:6d} meanPSNR={pss.mean():6.2f} "
                      f"minPSNR={pss.min():6.2f} catRate={np.mean([x[6] for x in sub]):.3f}")
        arr = np.array(rows, dtype=np.float64)
        tag = f"{scene}_{prec}" + ("_guard" if guard else "")
        np.savez_compressed(os.path.join(out_dir, f"multiupset_{tag}.npz"),
                            data=arr, cols=np.array(["k", "rep", "psnr", "ssim", "lpips", "mse", "cat"]),
                            meta=np.array([scene, prec, str(N)]))
        rows = []
    log_print(f"  MULTIUPSET done {scene} guard={guard}")


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/multiupset")
    ap.add_argument("--precisions", default="fp32,fp16,bf16")
    ap.add_argument("--K", type=int, default=8)
    ap.add_argument("--repeats", type=int, default=60)
    ap.add_argument("--ks", default="1,2,5,10,20,50,100,200,500,1000,2000,5000,10000,20000")
    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, "multiupset.log")
    ks = [int(x) for x in args.ks.split(",")]
    lpips_fn = lpips_mod.LPIPS(net="alex").cuda().eval()
    for p in lpips_fn.parameters():
        p.requires_grad_(False)
    for sc in args.scenes.split(","):
        mp = os.path.join(args.results_dir, sc, "model.pt")
        if os.path.exists(mp):
            run(mp, args.out, args.precisions.split(","), args.K, ks, args.repeats,
                lpips_fn, args.seed, log, guard=bool(args.guard))
    print("MULTIUPSET_DONE", flush=True)


if __name__ == "__main__":
    main()