"""E10: resilience versus primitive count.

A trained model is subsampled to a range of primitive counts N (and real scenes,
which carry millions of primitives, extend the high end).  For each N we run an
accumulated-dose sweep and record the dose k at which the mean PSNR drops below
30 dB, the redundancy budget, plus the mean footprint of a scale-sign upset.  If
redundancy is the source of resilience, the budget should grow with N while the
per-upset footprint stays roughly constant.
"""
import argparse
import json
import os

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


def subsample(params, n_keep, rng):
    N = params["means"].shape[0]
    if n_keep >= N:
        return {k: v.clone() for k, v in params.items()}, N
    idx = torch.from_numpy(rng.choice(N, size=n_keep, replace=False)).long().cuda()
    return {k: v[idx].contiguous() for k, v in params.items()}, n_keep


def dose_curve(work, stored, comps, N, nbits, tvm, tKs, W, H, sh, lpips_fn, ks, repeats, rng):
    clean, _ = F.render_views(work, tvm, tKs, W, H, sh)
    weights = np.array([comps[f] * N * nbits for f in FIELDS], float); weights /= weights.sum()
    out = {}
    for k in ks:
        ps = []
        for _ in range(repeats):
            sites = []
            for _ in range(k):
                fi = rng.choice(6, p=weights); field = FIELDS[fi]
                flat = int(rng.integers(0, N * comps[field])); bit = int(rng.integers(0, nbits))
                cv, _ = F.flip_one(stored[field], work[field], flat, bit, "fp32"); sites.append((field, flat, cv))
            img, _ = F.render_views(work, tvm, tKs, W, H, sh)
            mse = torch.mean((img - clean) ** 2).item()
            ps.append(-10.0 * np.log10(max(mse, 1e-12)))
            for field, flat, cv in sites:
                F.restore_one(work[field], flat, cv)
        out[k] = float(np.mean(ps))
    return out


def k_at_30(curve):
    ks = sorted(curve)
    for k in ks:
        if curve[k] < 30.0:
            return k
    return ks[-1]


def run(model_path, out, fracs, ks, repeats, lpips_fn, seed, log):
    ck = torch.load(model_path, map_location="cuda", weights_only=False)
    base = {k: v.cuda().float() for k, v in ck["params"].items()}
    sh, W, H = ck["sh_degree"], ck["W"], ck["H"]
    scene = ck["scene"]
    Nbase = base["means"].shape[0]
    tvm = ck["test_viewmats"][:6].cuda(); tKs = ck["test_Ks"][:6].cuda()
    rng = np.random.default_rng(seed)

    def lg(*a):
        m = " ".join(str(x) for x in a); print(m, flush=True); open(log, "a").write(m + "\n")

    rows = []
    for fr in fracs:
        n_keep = max(2000, int(Nbase * fr))
        sub, N = subsample(base, n_keep, rng)
        stored, work = F.quantize_params(sub, "fp32")
        comps = {f: work[f].reshape(N, -1).shape[1] for f in FIELDS}
        curve = dose_curve(work, stored, comps, N, 32, tvm, tKs, W, H, sh, lpips_fn, ks, repeats, rng)
        # scale-sign footprint at this N (mean over a sample)
        clean, _ = F.render_views(work, tvm, tKs, W, H, sh)
        foots = []
        for _ in range(80):
            g = int(rng.integers(0, N)); flat = g * 3
            cv, _ = F.flip_one(stored["scales"], work["scales"], flat, 31, "fp32")
            img, _ = F.render_views(work, tvm, tKs, W, H, sh)
            F.restore_one(work["scales"], flat, cv)
            foots.append(((img - clean).abs().amax(-1) > 1 / 255).float().mean().item())
        k30 = k_at_30(curve)
        rows.append({"N": N, "k30": k30, "scalesign_footprint": float(np.mean(foots) * 100),
                     "curve": curve})
        lg(f"[{scene}] N={N:8d} k30={k30:6d} scalesign_foot={np.mean(foots)*100:.2f}%")
    json.dump({"scene": scene, "Nbase": Nbase, "rows": rows},
              open(os.path.join(out, f"scaling_{scene}.json"), "w"), indent=2)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--results_dir", default="/root/seu/results")
    ap.add_argument("--scenes", default="chair,lego")
    ap.add_argument("--out", default="/root/seu/results/scaling")
    ap.add_argument("--fracs", default="0.05,0.1,0.25,0.5,1.0")
    ap.add_argument("--ks", default="10,50,200,1000,5000,20000,50000")
    ap.add_argument("--repeats", type=int, default=30)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()
    os.makedirs(args.out, exist_ok=True)
    log = os.path.join(args.out, "scaling.log")
    fracs = [float(x) for x in args.fracs.split(",")]
    ks = [int(x) for x in args.ks.split(",")]
    lpips_fn = None
    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, fracs, ks, args.repeats, lpips_fn, args.seed, log)
    print("SCALING_DONE", flush=True)


if __name__ == "__main__":
    main()