"""Qwen3Guard-Gen をバッチ推論するバックエンド（第3パス用）。

vLLM（GPU、既定）と transformers（左パディングの一括生成）を選べる。出力は
``Safety: Safe|Unsafe|Controversial`` と ``Categories: ...`` を含む短い文字列で、
``parse`` が安全性ラベルとカテゴリ名の一覧に分解する。

テスト用に ``FakeBackend`` を用意する（``marker`` を含む本文を Unsafe と判定する）。
"""

from __future__ import annotations

import re
from typing import Any

DEFAULT_MODEL = "Qwen/Qwen3Guard-Gen-0.6B"
SAFETY_RE = re.compile(r"Safety:\s*(Safe|Unsafe|Controversial)", re.I)
CATEGORY_NAMES = (
    "Violent", "Non-violent Illegal Acts", "Sexual Content or Sexual Acts", "PII", "Suicide & Self-Harm",
    "Unethical Acts", "Politically Sensitive Topics", "Copyright Violation", "Jailbreak",
)
CATEGORY_RE = re.compile("|".join(re.escape(name) for name in CATEGORY_NAMES), re.I)
CANONICAL = {name.lower(): name for name in CATEGORY_NAMES}


def parse(raw: str) -> tuple[str | None, list[str]]:
    """モデル出力から (安全性ラベル, カテゴリ一覧) を取り出す。取れなければ (None, [])。"""

    match = SAFETY_RE.search(raw or "")
    categories = sorted({CANONICAL[m.lower()] for m in CATEGORY_RE.findall(raw or "")})
    return (match.group(1).title() if match else None), categories


class VllmBackend:
    def __init__(self, model: str = DEFAULT_MODEL, max_chars: int = 2000, gpu_memory_utilization: float = 0.85, max_model_len: int = 4096) -> None:
        from transformers import AutoTokenizer
        from vllm import LLM, SamplingParams

        self.tokenizer = AutoTokenizer.from_pretrained(model)
        self.llm = LLM(model=model, gpu_memory_utilization=gpu_memory_utilization, max_model_len=max_model_len, enable_prefix_caching=True)
        self.params = SamplingParams(max_tokens=48, temperature=0.0)
        self.model = model
        self.max_chars = max_chars

    def classify(self, texts: list[str]) -> list[str]:
        prompts = [self.tokenizer.apply_chat_template([{"role": "user", "content": t[: self.max_chars]}], tokenize=False) for t in texts]
        outputs = self.llm.generate(prompts, self.params, use_tqdm=False)
        return [o.outputs[0].text for o in outputs]


class TransformersBackend:
    def __init__(self, model: str = DEFAULT_MODEL, max_chars: int = 2000, device: str = "auto", batch_size: int = 8) -> None:
        import torch
        from transformers import AutoModelForCausalLM, AutoTokenizer

        self.torch = torch
        self.tokenizer = AutoTokenizer.from_pretrained(model)
        self.tokenizer.padding_side = "left"
        if self.tokenizer.pad_token is None:
            self.tokenizer.pad_token = self.tokenizer.eos_token
        kwargs: dict[str, Any] = {"device_map": "auto"} if device == "auto" else {}
        try:
            self.model = AutoModelForCausalLM.from_pretrained(model, dtype="auto", **kwargs)
        except TypeError:
            self.model = AutoModelForCausalLM.from_pretrained(model, torch_dtype="auto", **kwargs)
        if device != "auto":
            self.model = self.model.to(device)
        self.model.eval()
        self.max_chars = max_chars
        self.batch_size = batch_size

    def classify(self, texts: list[str]) -> list[str]:
        results: list[str] = []
        for start in range(0, len(texts), self.batch_size):
            chunk = texts[start : start + self.batch_size]
            prompts = [self.tokenizer.apply_chat_template([{"role": "user", "content": t[: self.max_chars]}], tokenize=False) for t in chunk]
            inputs = self.tokenizer(prompts, return_tensors="pt", padding=True).to(self.model.device)
            with self.torch.no_grad():
                generated = self.model.generate(**inputs, max_new_tokens=48, do_sample=False, pad_token_id=self.tokenizer.pad_token_id)
            new_tokens = generated[:, inputs["input_ids"].shape[1]:]
            results.extend(self.tokenizer.batch_decode(new_tokens, skip_special_tokens=True))
        return results


class FakeBackend:
    """テスト用。``marker`` を含む本文を Unsafe（``category``）、``controversial_marker`` を含む本文を Controversial とする。"""

    def __init__(self, marker: str = "UNSAFE_MARKER", category: str = "Sexual Content or Sexual Acts", controversial_marker: str = "CONTRO_MARKER") -> None:
        self.marker = marker
        self.category = category
        self.controversial_marker = controversial_marker
        self.calls = 0

    def classify(self, texts: list[str]) -> list[str]:
        self.calls += 1
        out = []
        for text in texts:
            if self.marker in text:
                out.append(f"Safety: Unsafe\nCategories: {self.category}")
            elif self.controversial_marker in text:
                out.append("Safety: Controversial\nCategories: Politically Sensitive Topics")
            else:
                out.append("Safety: Safe\nCategories: None")
        return out


def make_backend(name: str, model: str = DEFAULT_MODEL, max_chars: int = 2000, device: str = "auto") -> Any:
    if name == "vllm":
        return VllmBackend(model, max_chars)
    if name == "transformers":
        return TransformersBackend(model, max_chars, device)
    if name == "fake":
        return FakeBackend()
    raise ValueError(f"unknown backend: {name}")