from __future__ import annotations

import re
from collections.abc import Iterable, Sequence
from typing import Any


CHATML_BLOCK_RE = re.compile(
    r"<\|im_start\|>\s*(system|user|assistant)\s*\n?(.*?)<\|im_end\|>",
    re.IGNORECASE | re.DOTALL,
)

ROLE_HEADERS = {
    "system": "### 지침:\n",
    "user": "### 사용자:\n",
    "assistant": "### 도우미:\n",
}

KOREAN_CHAT_TEMPLATE = """{{ bos_token }}{% for message in messages %}{% if message['role'] == 'system' %}### 지침:
{{ message['content'] }}

{% elif message['role'] == 'user' %}### 사용자:
{{ message['content'] }}

{% elif message['role'] == 'assistant' %}### 도우미:
{{ message['content'] }}{{ eos_token }}

{% endif %}{% endfor %}{% if add_generation_prompt %}### 도우미:
{% endif %}"""


def parse_chatml(text: str) -> list[tuple[str, str]]:
    if not isinstance(text, str):
        return []
    return [
        (role.casefold(), content.strip())
        for role, content in CHATML_BLOCK_RE.findall(text)
        if content.strip()
    ]


def format_generation_prompt(
    user_text: str,
    *,
    system_text: str | None = None,
) -> str:
    sections: list[str] = []
    if system_text:
        sections.append(ROLE_HEADERS["system"] + system_text.strip())
    sections.append(ROLE_HEADERS["user"] + user_text.strip())
    sections.append(ROLE_HEADERS["assistant"])
    return "\n\n".join(sections)


def _encode(tokenizer: Any, text: str) -> list[int]:
    return list(
        tokenizer(
            text,
            add_special_tokens=False,
            return_attention_mask=False,
            return_token_type_ids=False,
        )["input_ids"]
    )


def _encode_context_block(
    tokenizer: Any,
    role: str,
    content: str,
) -> list[int]:
    result = _encode(tokenizer, ROLE_HEADERS[role] + content.strip())
    if role == "assistant":
        result.append(int(tokenizer.eos_token_id))
    result.extend(_encode(tokenizer, "\n\n"))
    return result


def build_assistant_examples(
    blocks: Sequence[tuple[str, str]],
    tokenizer: Any,
    *,
    max_length: int,
    min_prompt_tokens: int = 32,
) -> Iterable[tuple[list[int], list[int]]]:
    """Yield one assistant-only-loss example for every assistant turn.

    Earlier assistant turns remain masked context. The current assistant response
    and its EOS token are supervised. Long prompts are cropped from the left so
    the most recent user request and assistant header are retained.
    """

    if max_length <= min_prompt_tokens + 2:
        raise ValueError("max_length is too small for an SFT example")
    if tokenizer.bos_token_id is None or tokenizer.eos_token_id is None:
        raise ValueError("Tokenizer must define BOS and EOS token IDs")

    context_ids = [int(tokenizer.bos_token_id)]
    for role, content in blocks:
        if role not in ROLE_HEADERS or not content.strip():
            continue
        if role != "assistant":
            context_ids.extend(_encode_context_block(tokenizer, role, content))
            continue

        assistant_header = _encode(tokenizer, ROLE_HEADERS["assistant"])
        prompt_ids = context_ids + assistant_header
        response_ids = _encode(tokenizer, content.strip())
        response_budget = max_length - min_prompt_tokens - 1
        if len(response_ids) > response_budget:
            response_ids = response_ids[:response_budget]
        target_ids = response_ids + [int(tokenizer.eos_token_id)]
        prompt_budget = max_length - len(target_ids)
        prompt_tail = prompt_ids[-prompt_budget:]
        input_ids = prompt_tail + target_ids
        loss_mask = [0] * len(prompt_tail) + [1] * len(target_ids)
        if response_ids and len(input_ids) <= max_length:
            yield input_ids, loss_mask

        context_ids.extend(_encode_context_block(tokenizer, role, content))