from __future__ import annotations

import hashlib
from pathlib import Path
from typing import Any, Protocol


class TokenizerProtocol(Protocol):
    def encode(self, text: str) -> list[int]: ...
    def decode(self, token_ids: list[int]) -> str: ...
    def render_chat(self, messages: list[dict[str, Any]]) -> str: ...
    def token_offset(self, rendered_text: str, substring: str) -> int: ...
    @property
    def fingerprint(self) -> str: ...


class TransformersTokenizer:
    def __init__(
        self,
        model_path: str | Path,
        *,
        enable_thinking: bool = True,
        reasoning_effort: str | None = "medium",
        preserve_thinking: bool = True,
    ):
        try:
            from transformers import AutoTokenizer
        except ImportError as exc:
            raise RuntimeError(
                "Install shiftedx-bench[tokenizers] to use a Transformers tokenizer"
            ) from exc
        self.model_path = Path(model_path).expanduser().resolve()
        self._tokenizer = AutoTokenizer.from_pretrained(
            self.model_path, local_files_only=True, trust_remote_code=True
        )
        self.enable_thinking = enable_thinking
        self.reasoning_effort = reasoning_effort
        self.preserve_thinking = preserve_thinking
        digest = hashlib.sha256()
        for name in ("tokenizer.json", "tokenizer_config.json", "special_tokens_map.json"):
            path = self.model_path / name
            if path.exists():
                digest.update(name.encode())
                digest.update(path.read_bytes())
        digest.update(
            repr((self.enable_thinking, self.reasoning_effort, self.preserve_thinking)).encode()
        )
        self._fingerprint = digest.hexdigest()

    def encode(self, text: str) -> list[int]:
        return list(self._tokenizer.encode(text, add_special_tokens=False))

    def decode(self, token_ids: list[int]) -> str:
        return self._tokenizer.decode(
            token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False
        )

    def render_chat(self, messages: list[dict[str, Any]]) -> str:
        kwargs: dict[str, Any] = {
            "tokenize": False,
            "add_generation_prompt": True,
            "enable_thinking": self.enable_thinking,
            "preserve_thinking": self.preserve_thinking,
        }
        if self.reasoning_effort:
            kwargs["reasoning_effort"] = self.reasoning_effort
        try:
            value = self._tokenizer.apply_chat_template(messages, **kwargs)
        except TypeError:
            value = self._tokenizer.apply_chat_template(
                messages, tokenize=False, add_generation_prompt=True
            )
        if not isinstance(value, str):
            raise TypeError("Tokenizer chat template did not return text")
        return value

    def token_offset(self, rendered_text: str, substring: str) -> int:
        char_offset = rendered_text.find(substring)
        if char_offset < 0:
            raise ValueError(f"Substring not present in rendered prompt: {substring!r}")
        encoded = self._tokenizer(
            rendered_text,
            add_special_tokens=False,
            return_offsets_mapping=True,
        )
        for index, (start, end) in enumerate(encoded["offset_mapping"]):
            if start <= char_offset < end or start == char_offset:
                return index
        raise ValueError("Could not map substring to a token offset")

    @property
    def fingerprint(self) -> str:
        return self._fingerprint