"""Pack a System One-style request into a single token sequence.

Layout per request:
    [STATE] state_tokens [Q] qctx_tokens ([O] opt_tokens)* [ANS]   (repeated per question)

Attention mask semantics (token a attends to token b):
    state -> state                       (bidirectional; blind to questions -> cacheable)
    qctx(q) -> state + qctx(q)
    opt(q,i) -> state + qctx(q) + opt(q,i)
    ans(q) -> state + qctx(q) + all opts(q) + itself

All questions reuse the same position range (they are mutually invisible),
and all option spans share one position base -> option order carries no
positional signal, giving permutation invariance by construction.
"""
from dataclasses import dataclass, field

SEG_PAD = 0
SEG_STATE = 1
SEG_QCTX = 2
SEG_OPT = 3
SEG_ANS = 4

# Unused Qwen3 special tokens repurposed as segment markers.
TOK_STATE = "<|object_ref_start|>"
TOK_QUESTION = "<|object_ref_end|>"
TOK_OPTION = "<|box_start|>"
TOK_ANS = "<|quad_start|>"

OPT_POS_GAP = 4          # position gap between qctx and the option block
OPT_SPAN_CAP = 64        # reserved position span for options before ANS


@dataclass
class QuestionSpec:
    qid: str
    qtype: str                      # 'choice' | 'noul' | 'score'
    instructions: str
    options: list                   # option/level description strings ([] for noul)
    option_keys: list = None        # caller-facing keys; defaults to indices


@dataclass
class Packed:
    input_ids: list
    position_ids: list
    seg_types: list                 # per-token SEG_*
    q_of: list                      # per-token question index, -1 for state
    opt_of: list                    # per-token option index within question, -1 else
    questions: list
    option_spans: list              # [q] -> [(start, end)] inclusive, per option
    qctx_spans: list                # [q] -> (start, end)
    ans_pos: list                   # [q] -> index of ANS token
    state_span: tuple


def _tok(tokenizer, text):
    return tokenizer.encode(text, add_special_tokens=False)


def pack_request(tokenizer, state_text, questions, max_len=4096, max_state=2048,
                 max_opt_tokens=48):
    """Tokenize and lay out one request. Raises ValueError if over max_len."""
    m_state = _tok(tokenizer, TOK_STATE)
    m_q = _tok(tokenizer, TOK_QUESTION)
    m_o = _tok(tokenizer, TOK_OPTION)
    m_ans = _tok(tokenizer, TOK_ANS)
    assert all(len(m) == 1 for m in (m_state, m_q, m_o, m_ans)), "markers must be single tokens"

    ids, pos, seg, qof, oof = [], [], [], [], []

    state_ids = [m_state[0]] + _tok(tokenizer, state_text)[: max_state - 1]
    s0 = len(ids)
    ids += state_ids
    pos += list(range(len(state_ids)))
    seg += [SEG_STATE] * len(state_ids)
    qof += [-1] * len(state_ids)
    oof += [-1] * len(state_ids)
    state_span = (s0, len(ids) - 1)
    S = len(state_ids)

    option_spans, qctx_spans, ans_pos = [], [], []

    for qi, q in enumerate(questions):
        qc_ids = [m_q[0]] + _tok(tokenizer, q.instructions)
        q_start = S                      # position base for this question's context
        c0 = len(ids)
        ids += qc_ids
        pos += [q_start + i for i in range(len(qc_ids))]
        seg += [SEG_QCTX] * len(qc_ids)
        qof += [qi] * len(qc_ids)
        oof += [-1] * len(qc_ids)
        qctx_spans.append((c0, len(ids) - 1))

        opt_base = S + len(qc_ids) + OPT_POS_GAP
        spans = []
        for oi, opt_text in enumerate(q.options):
            o_ids = [m_o[0]] + _tok(tokenizer, opt_text)[: max_opt_tokens - 1]
            o0 = len(ids)
            ids += o_ids
            pos += [opt_base + i for i in range(len(o_ids))]   # same base for every option
            seg += [SEG_OPT] * len(o_ids)
            qof += [qi] * len(o_ids)
            oof += [oi] * len(o_ids)
            spans.append((o0, len(ids) - 1))
        option_spans.append(spans)

        ids.append(m_ans[0])
        pos.append(opt_base + OPT_SPAN_CAP)
        seg.append(SEG_ANS)
        qof.append(qi)
        oof.append(-1)
        ans_pos.append(len(ids) - 1)

    if len(ids) > max_len:
        raise ValueError(f"packed length {len(ids)} > max_len {max_len}")

    return Packed(ids, pos, seg, qof, oof, list(questions), option_spans,
                  qctx_spans, ans_pos, state_span)


def build_additive_mask(packed, neg=-1e9):
    """Return [L, L] float mask: 0.0 = allowed, neg = blocked."""
    import torch

    L = len(packed.input_ids)
    seg = torch.tensor(packed.seg_types)
    qof = torch.tensor(packed.q_of)
    oof = torch.tensor(packed.opt_of)

    a_state = seg[:, None] == SEG_STATE
    a_qctx = seg[:, None] == SEG_QCTX
    a_opt = seg[:, None] == SEG_OPT
    a_ans = seg[:, None] == SEG_ANS

    b_state = seg[None, :] == SEG_STATE
    b_qctx = seg[None, :] == SEG_QCTX
    b_opt = seg[None, :] == SEG_OPT
    b_ans = seg[None, :] == SEG_ANS

    same_q = (qof[:, None] == qof[None, :]) & (qof[:, None] >= 0)
    same_opt = same_q & (oof[:, None] == oof[None, :]) & (oof[:, None] >= 0)

    allowed = (
        (a_state & b_state)
        | (a_qctx & (b_state | (b_qctx & same_q)))
        | (a_opt & (b_state | (b_qctx & same_q) | (b_opt & same_opt)))
        | (a_ans & (b_state | ((b_qctx | b_opt | b_ans) & same_q)))
    )
    mask = torch.full((L, L), neg, dtype=torch.float32)
    mask[allowed] = 0.0
    return mask