"""Reasoning-step segmentation and exact character -> token alignment.

A response is partitioned into contiguous segments that cover every character:
  segment 0..T-1 : reasoning steps (any preamble before "Step 1:" is merged into the first step)
  segment T      : the terminal segment (the "Final answer:" line and anything after it)
Steps are delimited by "Step k:" markers (as in skill_dynamics.scoring.segment). When a
response has no markers, paragraphs separated by blank lines are used instead and
`marker_found` is False, so the fallback rate can be monitored.
"""

import re
from dataclasses import dataclass, field

# Line openers seen in real samples: "Step 1:", "Step 1.", "**Step 1:**", "**Step 1**:", "### Step 1:",
# "- Step 1:", "*Step 1:*". The final answer may also carry a step marker ("Step 6: Final answer: ...").
_OPEN = r"^[ \t]*(?:[-+>][ \t]*)?(?:#{1,6}[ \t]*)?(?:\*{1,2}|_{1,2})?[ \t]*"
_EMPH = r"[ \t]*(?:\*{1,2}|_{1,2})?[ \t]*"
STEP_RE = re.compile(r"(?im)" + _OPEN + r"Step[ \t]+(\d+)" + _EMPH + r"[:.](?:[ \t]*(?:\*{1,2}|_{1,2}))?")
FINAL_PREFIX = _OPEN + r"(?:Step[ \t]+\d+" + _EMPH + r"[:.]" + _EMPH + r")?Final answer" + _EMPH + r":"
FINAL_RE = re.compile(r"(?im)" + FINAL_PREFIX)


@dataclass
class Segmentation:
    text: str
    steps: list = field(default_factory=list)   # [(char_start, char_end)] covering [0, final_start)
    final_start: int = 0                        # start of the terminal segment
    marker_found: bool = True
    content_start: int = 0                      # first step marker (preamble excluded), as in skill_dynamics
    content_token: int = 0                      # token index of content_start (set by response_segments)

    @property
    def num_steps(self):
        return len(self.steps)

    def step_texts(self):
        return [self.text[a:b] for a, b in self.steps]

    def bounds(self):
        """Segment boundaries: steps then the terminal segment, covering the whole text."""
        return [*self.steps, (self.final_start, len(self.text))]


def segment(text):
    final = None
    for match in FINAL_RE.finditer(text):
        final = match
    stop = final.start() if final else len(text)
    body = text[:stop]
    marks = [m for m in STEP_RE.finditer(body)]
    starts = []
    for m in marks:
        if not starts or m.start() > starts[-1]:
            starts.append(m.start())
    marker_found = bool(starts)
    if not marker_found:
        # paragraphs start at their line start (with any indentation), where tokenizers put a token edge
        starts = [len(body[:m.start()].rstrip(" \t")) for m in re.finditer(r"(?s)\S.*?(?=\n[ \t]*\n|\Z)", body)]
    # Drop empty steps, merge any preamble into the first step.
    bounds = []
    for i, start in enumerate(starts):
        end = starts[i + 1] if i + 1 < len(starts) else stop
        if body[start:end].strip():
            bounds.append([start, end])
    content_start = bounds[0][0] if bounds else 0
    if bounds:
        bounds[0][0] = 0
        bounds[-1][1] = stop
    return Segmentation(text=text, steps=[tuple(b) for b in bounds], final_start=stop if bounds else 0,
                        marker_found=marker_found, content_start=content_start)


def _byte_decoder():
    # GPT-2 / tiktoken-style byte-level BPE alphabet (used by Qwen2.5 and Llama-3 tokenizers).
    bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1))
    cs = bs[:]
    n = 0
    for b in range(256):
        if b not in bs:
            bs.append(b)
            cs.append(256 + n)
            n += 1
    return {chr(c): b for b, c in zip(bs, cs)}


_BYTE_DECODER = _byte_decoder()


def token_char_offsets(tokenizer, ids):
    """Character offset of each token boundary in decode(ids, skip_special_tokens=True,
    clean_up_tokenization_spaces=False). Returns (text, offsets) with len(offsets) == len(ids)+1."""
    text = tokenizer.decode(ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
    special = set(getattr(tokenizer, "all_special_ids", []) or [])
    pieces = tokenizer.convert_ids_to_tokens(list(ids))
    try:
        byte_lens = []
        for tid, piece in zip(ids, pieces):
            if tid in special or piece is None:
                byte_lens.append(0)
            else:
                byte_lens.append(len(bytes(_BYTE_DECODER[ch] for ch in piece)))
        data = text.encode("utf-8")
        if sum(byte_lens) != len(data):
            raise ValueError("byte-level reconstruction mismatch")
        # Map every byte boundary to a character boundary (bytes inside a multi-byte char map
        # to the start of that char's next boundary, so spans never split a character).
        char_at_byte = [0] * (len(data) + 1)
        pos = 0
        for ci, ch in enumerate(text):
            width = len(ch.encode("utf-8"))
            for k in range(width):
                char_at_byte[pos + k] = ci if k == 0 else ci + 1
            pos += width
        char_at_byte[len(data)] = len(text)
        offsets, acc = [0], 0
        for length in byte_lens:
            acc += length
            offsets.append(char_at_byte[acc])
        return text, offsets
    except (KeyError, ValueError):
        offsets = [len(tokenizer.decode(ids[:i], skip_special_tokens=True, clean_up_tokenization_spaces=False))
                   for i in range(len(ids) + 1)]
        return text, offsets


def char_spans_to_token_spans(offsets, char_spans):
    """Map contiguous character spans to contiguous token spans [t0, t1). A token belongs to the
    span containing its first character; spans that receive no token are returned empty."""
    import bisect
    n_tokens = len(offsets) - 1
    starts = [offsets[i] for i in range(n_tokens)]
    out = []
    for a, b in char_spans:
        t0 = bisect.bisect_left(starts, a)
        t1 = bisect.bisect_left(starts, b)
        out.append((t0, t1))
    return out


def response_segments(tokenizer, ids):
    """Segmentation of a generated response plus token spans for every segment (steps + terminal).
    Tokens are assigned in order, so spans tile [0, len(ids)) exactly. Also returns the token index
    where reasoning content starts (first step marker), used by the spectral features."""
    text, offsets = token_char_offsets(tokenizer, ids)
    seg = segment(text)
    spans = char_spans_to_token_spans(offsets, seg.bounds())
    if spans:
        spans[-1] = (spans[-1][0], len(ids))
        spans = [(spans[i][0], spans[i + 1][0]) for i in range(len(spans) - 1)] + [spans[-1]]
        if spans[0][0] != 0:
            spans[0] = (0, spans[0][1])
    content_tok = char_spans_to_token_spans(offsets, [(seg.content_start, seg.content_start)])[0][0]
    if seg.num_steps:
        content_tok = min(content_tok, max(spans[0][1] - 1, 0))
    seg.content_token = content_tok
    return seg, spans