"""Llama-shaped decoder whose KV cache is PAGED.

Instead of one contiguous `(B, n_kv, max_seq, hd)` tensor per layer, each layer owns a pool of fixed
size pages and a per-sequence page table maps logical position -> physical page. The pool is twice the
size the batch needs and the pages a sequence owns are deliberately SCATTERED through it, so a kernel
cannot quietly treat the table as the identity and read contiguously; every attention step is a gather
through one level of indirection.

This is how every production serving stack stores KV (vLLM PagedAttention and everything after it),
and it is the single change that makes the attention half of a megakernel hard: the weight stream is
still a static schedule you can prefetch, but the KV addresses only exist after a table lookup.
"""
from model import HELPERS_CORE, QUANT_FP8

BODY = r'''
def make_weights(cfg, seed=0, device="cuda"):
    """Deterministic 1/sqrt(fan_in)-scaled weights. No checkpoint is shipped or downloaded."""
    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)
    W = {"embed": rnd(cfg["vocab"], d, fan_in=d), "final_norm": ones(), "layers": []}
    for _ in range(cfg["layers"]):
        W["layers"].append(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)))
    return W


def make_kv(cfg, batch, prefill_len, max_seq, seed=0, device="cuda"):
    """Paged KV pool + page table.

    Returns {"k": [per-layer pool], "v": [...], "page_table": (B, pages_per_seq) int32,
             "page_size": int}. Pools are (n_pages, n_kv, page_size, hd) bf16.

    The pool is OVERSUBSCRIBED: it holds twice as many pages as this batch needs, and the page table
    is a random SELECTION of half of them, so logically adjacent positions are physically scattered
    and the pages in between belong to somebody else. `page_table[b, j]` is the physical page holding
    logical positions [j*page_size, (j+1)*page_size) of sequence b.

    Every page in the pool holds live-looking KV, including the ones this batch does not own. That is
    what a real pool looks like (other sequences' pages, and freed pages still holding stale data),
    and it is also what makes the indirection GRADEABLE. When the table was a permutation of a pool
    that the sequence owned entirely, a kernel that ignored the table and read the pool contiguously
    gathered a PERMUTED COPY OF THE SAME KEYS -- and attention is permutation-invariant over the key
    axis, so the measured error of that shortcut was 0.087, barely above the 0.028 numerical floor.
    With the pool oversubscribed the same shortcut measures 0.76 (see the spec's Precision section)."""
    g = torch.Generator(device=device).manual_seed(seed + 777)
    ps = cfg["page_size"]
    per_seq = (max_seq + ps - 1) // ps
    n_pages = 2 * batch * per_seq
    sel = torch.randperm(n_pages, device=device, generator=g)[:batch * per_seq].to(torch.int32)
    table = sel.view(batch, per_seq).contiguous()
    ks, vs = [], []
    for _ in range(cfg["layers"]):
        k = (torch.randn(n_pages, cfg["n_kv"], ps, cfg["hd"], device=device, dtype=torch.float32,
                         generator=g) * 0.5).to(torch.bfloat16)
        v = (torch.randn(n_pages, cfg["n_kv"], ps, cfg["hd"], device=device, dtype=torch.float32,
                         generator=g) * 0.5).to(torch.bfloat16)
        ks.append(k)
        vs.append(v)
    return {"k": ks, "v": vs, "page_table": table, "page_size": ps}


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)
    W = {"embed": _deq(weights["embed"]), "final_norm": weights["final_norm"],
         "layers": [{k: (v if k.endswith("norm") else _deq(v)) for k, v in L.items()}
                    for L in weights["layers"]]}
    return {"W": W, "kv": kv_cache, "cfg": cfg, "cos": cos, "sin": sin}


def _gather_pages(pool, table, b, n_pos, ps):
    """Logical (n_kv, n_pos, hd) view of sequence b, gathered through the page table."""
    npg = (n_pos + ps - 1) // ps
    phys = table[b, :npg].long()
    g = pool[phys]                                   # (npg, n_kv, ps, hd)
    g = g.permute(1, 0, 2, 3).reshape(g.shape[1], npg * ps, g.shape[3])
    return g[:, :n_pos]


@torch.no_grad()
def decode_step(handle, token_ids, pos):
    """One decode step for every sequence in the batch. Appends this position's K/V into its page.

    token_ids: (B,) int64      pos: int, the absolute position being written
    returns:   (B, vocab) logits
    """
    W, kv, cfg = handle["W"], handle["kv"], handle["cfg"]
    cos, sin = handle["cos"], handle["sin"]
    B = token_ids.shape[0]
    n_q, n_kv, hd = cfg["n_q"], cfg["n_kv"], cfg["hd"]
    rep, ps = n_q // n_kv, kv["page_size"]
    table = kv["page_table"]
    pg, slot = pos // ps, pos % ps

    x = W["embed"][token_ids]
    for li, L in enumerate(W["layers"]):
        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)
        kp, vp = kv["k"][li], kv["v"][li]
        outs = []
        for b in range(B):
            p = int(table[b, pg])
            kp[p, :, slot] = k[b, :, 0]              # append THIS position into its page
            vp[p, :, slot] = v[b, :, 0]
            kk = _gather_pages(kp, table, b, pos + 1, ps).unsqueeze(0)
            vv = _gather_pages(vp, table, b, pos + 1, ps).unsqueeze(0)
            kk = kk.repeat_interleave(rep, dim=1)
            vv = vv.repeat_interleave(rep, dim=1)
            outs.append(F.scaled_dot_product_attention(q[b:b + 1], kk, vv))
        att = torch.cat(outs, dim=0)
        x = x + (att.reshape(B, n_q * hd) @ L["o"].T)
        h = _rms_norm(x, L["post_norm"], cfg["eps"])
        x = x + ((F.silu(h @ L["gate"].T) * (h @ L["up"].T)) @ L["down"].T)
    x = _rms_norm(x, W["final_norm"], cfg["eps"])
    return x @ W["embed"].T                      # tied lm_head
'''

MODEL_SRC = HELPERS_CORE + QUANT_FP8 + BODY