"""quantized-optimizer-state verifier — correctness gate + achieved-GB/s SPEED LEADERBOARD (uncapped).

    reward = 0                                     if the submission is incorrect
    reward = geomean over graded shapes of GB/s otherwise

GENERATED by _factory/build.py — do not edit here; edit the spec and regenerate.

There is no gold solution and no oracle: the score is an absolute hardware metric, so it is hardware-portable
by construction and nothing has to be vendored, sealed, or re-benchmarked.

CORRECTNESS is a hard gate, checked against an INDEPENDENT (embedded) copy of the reference at every graded
shape including the timed ones, so editing /app/reference.py cannot affect grading and a fast wrong kernel
scores 0.

ANTI-CHEAT on the timing path: every timed rep runs on FRESHLY generated inputs, and the output of the last
timed rep is itself validated against the reference for those exact inputs. A submission that memoizes a
result and replays it fails the gate instead of posting an inflated number. Warm-up runs on a separate
throwaway input set, so ordinary shape-keyed JIT/autotune caching is not penalised.

WORK is attributed by a CANONICAL formula that depends only on the shape, never on the implementation, so all
submissions are credited identically and the ranking is a pure speed ranking.
"""
import importlib.util
import json
import math
import os
import sys
import traceback

import torch

REWARD_DIR = "/logs/verifier"
MODULE_PATH = "/app/qadam.py"
TOL = 4e-05
NAMES = ('params_out', 'm_out', 'v_out', 'm_absmax_out', 'v_absmax_out')

GRADER_SHAPES = [(146484,), (97656,), (122070,), (136718,), (107421,)]
CORRECT_SHAPES = [(7,), (13,), (129,), (61,)]

sys.path.insert(0, "/app")

def canonical_work(NB):
    """BYTES attributed to one 8-bit AdamW step, from the SHAPE ALONE.

    N = NB*2048 parameters. Per parameter: read params (2), grads (2), both moment codes (1 + 1) = 6, and
    write params (2) plus both dequantised moments (4 + 4) = 10. The (N/2048,) absmax vectors are 1/2048 of
    the traffic and are not counted. 16 bytes per parameter; this is a memory-bound kernel, so the score is
    achieved bandwidth against that fixed byte count.
    """
    return 16 * NB * 2048

BLOCK = 2048            # quantisation block: one fp32 absmax per 2048 consecutive parameters


def _requantise(x, qmap):
    """x -> (dequantised round trip, per-block absmax). Nearest entry of the ascending 256-point map."""
    nb = x.numel() // BLOCK
    xb = x.view(nb, BLOCK)
    absmax = xb.abs().amax(-1)                                  # the NEW scale of this block
    c = xb / absmax.clamp(min=1e-30).unsqueeze(-1)              # normalised into the map's range
    mid = (qmap[:-1] + qmap[1:]) * 0.5                          # 255 midpoints, ascending
    code = torch.bucketize(c, mid)                              # index of the nearest map entry
    return (qmap[code] * absmax.unsqueeze(-1)).reshape(-1), absmax


def _ref(params, grads, m_code, m_absmax, v_code, v_absmax, qmap1, qmap2, step,
                         lr=1e-3, beta1=0.9, beta2=0.999, eps=1e-8, wd=0.01):
    """8-bit blockwise AdamW, in fp32.

    Correct and simple — it is the numerical SPECIFICATION, not a performance target. Every line
    materialises another full-size fp32 temporary in HBM.
    """
    m = qmap1[m_code.long()] * m_absmax.repeat_interleave(BLOCK)     # dequantise the first moment
    v = qmap2[v_code.long()] * v_absmax.repeat_interleave(BLOCK)     # dequantise the second moment
    g = grads.float()

    m_new = beta1 * m + (1.0 - beta1) * g
    v_new = beta2 * v + (1.0 - beta2) * g * g

    bc1 = 1.0 - beta1 ** step
    bc2 = 1.0 - beta2 ** step
    denom = (v_new / bc2).sqrt() + eps
    upd = (lr / bc1) * m_new / denom
    p_out = params.float() * (1.0 - lr * wd) - upd                   # DECOUPLED weight decay

    m_out, m_absmax_out = _requantise(m_new, qmap1)                  # the state that gets stored back
    v_out, v_absmax_out = _requantise(v_new, qmap2)
    return p_out.to(torch.bfloat16), m_out, v_out, m_absmax_out, v_absmax_out

def _mk(NB, seed):
    """A parameter buffer of NB blocks of 2048, with its 8-bit moment state already in the quantised form
    the reference must dequantise. The maps are the fixed nonlinear (cubic) maps the optimiser ships with:
    fine resolution near zero, coarse near the block maximum."""
    gen = torch.Generator(device="cuda").manual_seed(seed)
    N = NB * 2048

    t = (torch.arange(256, device="cuda", dtype=torch.float32) - 127.5) / 127.5
    qmap1 = t.sign() * t.abs() ** 3                                  # signed, ascending, [-1, 1]
    qmap2 = (torch.arange(256, device="cuda", dtype=torch.float32) / 255.0) ** 3   # unsigned, [0, 1]

    params = (torch.randn(N, device="cuda", generator=gen) * 0.02).to(torch.bfloat16)
    grads = (torch.randn(N, device="cuda", generator=gen) * 1e-3).to(torch.bfloat16)
    m_code = torch.randint(0, 256, (N,), device="cuda", dtype=torch.uint8, generator=gen)
    # v_code starts at 1, not 0: qmap2[0] is exactly 0, so a zero code with a ~0 gradient makes
    # v_new underflow and the AdamW denominator collapse to eps=1e-8, giving that element an
    # update ~1e4x typical. Eight such elements then carried 86% of the output tensor's energy,
    # so the relative-Frobenius gate was effectively reading eight numbers. A trained model's
    # second moment is never exactly zero. With this change the top-8 share drops to 3.1%.
    v_code = torch.randint(1, 256, (N,), device="cuda", dtype=torch.uint8, generator=gen)
    m_absmax = (1e-3 * (0.5 + torch.rand(NB, device="cuda", generator=gen))).float()
    v_absmax = (1e-6 * (0.5 + torch.rand(NB, device="cuda", generator=gen))).float()
    step = 137
    return (params, grads, m_code, m_absmax, v_code, v_absmax, qmap1, qmap2, step)


def _check(out, ref):
    """-> (ok, value, msg). value = MAX relative error across the returned tuple."""
    if out is None or len(out) != len(NAMES):
        return False, 1.0, f"expected a {len(NAMES)}-tuple {NAMES}"
    per = []
    for n, a, b in zip(NAMES, out, ref):
        if a is None or tuple(a.shape) != tuple(b.shape):
            return False, 1.0, f"{n} bad shape"
        if b.dtype in (torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.bool):
            # exact: .float() is lossy above 2**24 and would let distinct large ids compare equal
            bad = int((a != b).sum())
            if bad:
                return False, 1.0, f"{n}: {bad} elements differ"
            continue
        per.append((n, float((a.float() - b.float()).norm() / (b.float().norm() + 1e-12))))
    if not per:
        return True, 0.0, "all integer outputs exact"
    wn, wv = max(per, key=lambda x: x[1])
    return wv <= TOL, wv, f"worst {wn} {wv:.2e}"


def _bench_fresh(fn, mkargs, reps=5, warm=3):
    """Time `fn` on FRESH inputs every rep -> (min_seconds, timed_ok). See the module docstring."""
    wargs = mkargs(0)
    for _ in range(warm):
        fn(*wargs)
    torch.cuda.synchronize()
    del wargs
    torch.cuda.empty_cache()

    best, timed_ok = float("inf"), True
    for i in range(reps):
        args = mkargs(10_000 + i)
        s, e = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
        s.record()
        out = fn(*args)
        e.record()
        torch.cuda.synchronize()
        best = min(best, s.elapsed_time(e))
        if i == reps - 1:
            timed_ok = _check(out, _ref(*args))[0]
        del args, out
        torch.cuda.empty_cache()
    return best / 1e3, timed_ok


def _geomean(xs):
    return math.exp(sum(math.log(max(v, 1e-9)) for v in xs) / len(xs)) if xs else 0.0


def main():
    details, correct_gate, geo = {}, False, 0.0
    try:
        spec = importlib.util.spec_from_file_location("submission", MODULE_PATH)
        m = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(m)
        fn = m.quantized_adamw_step

        corr_ok, msg = True, ""
        for i, shp in enumerate(CORRECT_SHAPES):
            args = _mk(*shp, seed=10 + i)
            ok, val, m_ = _check(fn(*args), _ref(*args))
            if not ok:
                corr_ok, msg = False, f"cfg{i} {shp} {m_}"
                break
            del args
            torch.cuda.empty_cache()
        details["correct_msg"] = msg or "all correctness shapes pass"

        vals, per_shape, perf_ok = [], [], corr_ok
        for i, shp in enumerate(GRADER_SHAPES):
            args = _mk(*shp, seed=100 + i)
            ok, val, m_ = _check(fn(*args), _ref(*args))
            if not ok:
                perf_ok = False
            del args
            torch.cuda.empty_cache()
            t, timed_ok = _bench_fresh(fn, lambda s, _p=shp: _mk(*_p, seed=s))
            if not timed_ok:
                perf_ok = False
            v = canonical_work(*shp) / t / 2**30 if t > 0 else 0.0
            vals.append(v)
            per_shape.append({"shape": list(shp), "gbps": round(v, 3), "ms": round(t * 1e3, 3),
                              "check": m_, "timed_ok": timed_ok})
        geo = _geomean(vals)
        details.update(per_shape=per_shape, geomean=round(geo, 4), perf_size_ok=perf_ok)
        correct_gate = corr_ok and perf_ok
    except Exception as e:
        details["error"] = f"{e.__class__.__name__}: {e}"[:220]
        details["trace"] = traceback.format_exc()[-800:]

    reward = round(geo, 4) if correct_gate else 0.0
    os.makedirs(REWARD_DIR, exist_ok=True)
    json.dump({"reward": reward, "correct": 1.0 if correct_gate else 0.0,
               "geomean": round(geo, 4), "metric": "GB/s (geomean over graded shapes)"},
              open(f"{REWARD_DIR}/reward.json", "w"), indent=2)
    open(f"{REWARD_DIR}/reward.txt", "w").write(str(reward))
    json.dump(details, open(f"{REWARD_DIR}/details.json", "w"), indent=2, default=str)
    print("reward:", reward, "GB/s | correct:", 1.0 if correct_gate else 0.0)


main()