"""Llama-shaped decoder with a DeepSeek-V3-style Multi-Token Prediction head.

The main model produces `logits0` for the next token as usual. An MTP module then takes the main
model's final hidden state together with the embedding of the *following* token, normalises both,
concatenates them, projects `2d -> d`, runs one more full decoder block against its own KV cache, and
produces `logits1` -- a prediction two tokens ahead. Both logit sets are returned and both are graded.

For a megakernel this is the interesting case where the step is not a straight line: `logits0` and the
MTP block both depend on the same hidden state, they share the tied LM head, and the MTP block has its
own attention over its own cache. A fused implementation can compute `logits0` and start the MTP
projection from the same registers; an unfused one writes the hidden state to HBM and reads it twice.

`next_token_ids` is an input rather than a sample of `logits0`. In generation it would be the sampled
token; here it is supplied so the step is deterministic -- sampling from near-uniform random-weight
logits is exactly the argmax coin-flip this family refuses to grade on.
"""
from model import HELPERS_CORE, QUANT_FP8

BODY = r'''
def make_weights(cfg, seed=0, device="cuda"):
    """Deterministic 1/sqrt(fan_in)-scaled weights. `mtp` holds the extra module."""
    g = torch.Generator(device=device).manual_seed(seed)
    d, ffn, n_q, n_kv, hd = cfg["d"], cfg["ffn"], cfg["n_q"], cfg["n_kv"], cfg["hd"]
    dt = cfg["wdtype"]

    def rnd(*shape, fan_in):
        w = torch.randn(*shape, device=device, dtype=torch.float32, generator=g) / (fan_in ** 0.5)
        return _quantise(w, dt)

    ones = lambda: torch.ones(d, device=device, dtype=torch.bfloat16)

    def block():
        return dict(in_norm=ones(), post_norm=ones(),
                    q=rnd(n_q * hd, d, fan_in=d), k=rnd(n_kv * hd, d, fan_in=d),
                    v=rnd(n_kv * hd, d, fan_in=d), o=rnd(d, n_q * hd, fan_in=n_q * hd),
                    gate=rnd(ffn, d, fan_in=d), up=rnd(ffn, d, fan_in=d),
                    down=rnd(d, ffn, fan_in=ffn))

    W = {"embed": rnd(cfg["vocab"], d, fan_in=d), "final_norm": ones(), "layers": []}
    for _ in range(cfg["layers"]):
        W["layers"].append(block())
    W["mtp"] = dict(enorm=ones(), hnorm=ones(), proj=rnd(d, 2 * d, fan_in=2 * d), block=block())
    return W


def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"):
    """`layers + 1` caches: one per main layer, plus one for the MTP block."""
    g = torch.Generator(device=device).manual_seed(seed + 777)
    kv = []
    for _ in range(cfg["layers"] + 1):
        k = torch.zeros(batch, cfg["n_kv"], max_seq, cfg["hd"], device=device, dtype=torch.bfloat16)
        v = torch.zeros_like(k)
        k[:, :, :prefill_len] = torch.randn(batch, cfg["n_kv"], prefill_len, cfg["hd"], device=device,
                                            dtype=torch.float32, generator=g).to(torch.bfloat16) * 0.5
        v[:, :, :prefill_len] = torch.randn(batch, cfg["n_kv"], prefill_len, cfg["hd"], device=device,
                                            dtype=torch.float32, generator=g).to(torch.bfloat16) * 0.5
        kv.append((k, v))
    return kv


def make_step_args(cfg, batch, base_pos, seed, n):
    """(token_ids, next_token_ids, pos) per step."""
    g = torch.Generator(device="cuda").manual_seed(seed)
    out = []
    for i in range(n):
        t0 = torch.randint(0, cfg["vocab"], (batch,), device="cuda", generator=g)
        t1 = torch.randint(0, cfg["vocab"], (batch,), device="cuda", generator=g)
        out.append((t0, t1, base_pos + i))
    return out


def build_model(weights, kv_cache, cfg, max_seq_len):
    """UNTIMED setup. Returns whatever handle you like; the grader only passes it back to decode_step."""
    cos, sin = _rope_cache(cfg, max_seq_len, weights["final_norm"].device)
    dq = lambda L: {k: (v if k.endswith("norm") else _deq(v)) for k, v in L.items()}
    W = {"embed": _deq(weights["embed"]), "final_norm": weights["final_norm"],
         "layers": [dq(L) for L in weights["layers"]],
         "mtp": dict(enorm=weights["mtp"]["enorm"], hnorm=weights["mtp"]["hnorm"],
                     proj=_deq(weights["mtp"]["proj"]), block=dq(weights["mtp"]["block"]))}
    return {"W": W, "kv": kv_cache, "cfg": cfg, "cos": cos, "sin": sin}


def _block(L, x, kv_pair, cos, sin, pos, cfg):
    """One decoder block: attention over its own cache, then the MLP. Returns the new residual."""
    B = x.shape[0]
    n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"]
    rep = n_q // n_kv
    h = _rms_norm(x, L["in_norm"], cfg["eps"])
    q = (h @ L["q"].T).view(B, n_q, 1, hd)
    k = (h @ L["k"].T).view(B, n_kv, 1, hd)
    v = (h @ L["v"].T).view(B, n_kv, 1, hd)
    q = _apply_rope(q, cos, sin, pos)
    k = _apply_rope(k, cos, sin, pos)
    kc, vc = kv_pair
    kc[:, :, pos:pos + 1] = k
    vc[:, :, pos:pos + 1] = v
    kk = kc[:, :, :pos + 1].repeat_interleave(rep, dim=1)
    vv = vc[:, :, :pos + 1].repeat_interleave(rep, dim=1)
    att = F.scaled_dot_product_attention(q, kk, vv)
    x = x + (att.reshape(B, n_q * hd) @ L["o"].T)
    h = _rms_norm(x, L["post_norm"], cfg["eps"])
    return x + ((F.silu(h @ L["gate"].T) * (h @ L["up"].T)) @ L["down"].T)


@torch.no_grad()
def decode_step(handle, token_ids, next_token_ids, pos):
    """One decode step plus one MTP step. Appends `pos` into all `layers + 1` caches.

    token_ids:      (B,) int64  the current token
    next_token_ids: (B,) int64  the token that follows it (the MTP module's second input)
    pos:            int, the absolute position being written
    returns:        (logits0, logits1), each (B, vocab)
    """
    W, kv, cfg = handle["W"], handle["kv"], handle["cfg"]
    cos, sin = handle["cos"], handle["sin"]

    x = W["embed"][token_ids]
    for li, L in enumerate(W["layers"]):
        x = _block(L, x, kv[li], cos, sin, pos, cfg)
    logits0 = _rms_norm(x, W["final_norm"], cfg["eps"]) @ W["embed"].T      # tied lm_head

    M = W["mtp"]
    he = _rms_norm(W["embed"][next_token_ids], M["enorm"], cfg["eps"])
    hh = _rms_norm(x, M["hnorm"], cfg["eps"])                               # x = pre-final-norm hidden
    xm = torch.cat([hh, he], dim=-1) @ M["proj"].T                          # (B, 2d) -> (B, d)
    xm = _block(M["block"], xm, kv[cfg["layers"]], cos, sin, pos, cfg)
    logits1 = _rms_norm(xm, W["final_norm"], cfg["eps"]) @ W["embed"].T     # SAME tied head
    return logits0, logits1
'''

MODEL_SRC = HELPERS_CORE + QUANT_FP8 + BODY