"""Qwen-MT translation backend."""

from __future__ import annotations

import logging
import re
import time
from typing import List, Optional, Sequence, Union

from openai import OpenAI

from translation.languages import QWEN_LANGUAGE_CODES

logger = logging.getLogger(__name__)


class QwenMTTranslationBackend:
    def __init__(
        self,
        capability_name: str,
        model: str,
        base_url: str,
        api_key: Optional[str] = None,
        timeout: int = 10,
        glossary_id: Optional[str] = None,
    ):
        self.capability_name = capability_name
        self.model = self._normalize_capability_name(capability_name)
        self.qwen_model_name = self._normalize_model_name(model)
        self.base_url = base_url
        self.timeout = int(timeout)
        self.glossary_id = glossary_id

        self._api_key = api_key or self._default_api_key(self.model)
        self._qwen_client: Optional[OpenAI] = None
        if self._api_key:
            try:
                self._qwen_client = OpenAI(api_key=self._api_key, base_url=self.base_url)
            except Exception as exc:
                logger.warning("Failed to initialize qwen-mt client: %s", exc, exc_info=True)
        else:
            logger.warning("DASHSCOPE_API_KEY not set; qwen-mt translation unavailable")

    @property
    def supports_batch(self) -> bool:
        return True

    @staticmethod
    def _normalize_capability_name(name: str) -> str:
        normalized = str(name or "").strip().lower()
        if normalized != "qwen-mt":
            raise ValueError(f"Qwen-MT backend capability must be 'qwen-mt', got '{name}'")
        return normalized

    @staticmethod
    def _normalize_model_name(model: str) -> str:
        normalized = str(model or "").strip()
        if not normalized:
            raise ValueError("qwen-mt backend model is required")
        return normalized

    @staticmethod
    def _default_api_key(model: str) -> Optional[str]:
        del model
        return None

    def translate(
        self,
        text: Union[str, Sequence[str]],
        target_lang: str,
        source_lang: Optional[str] = None,
        scene: Optional[str] = None,
    ) -> Union[Optional[str], List[Optional[str]]]:
        if isinstance(text, (list, tuple)):
            results: List[Optional[str]] = []
            for item in text:
                if item is None or not str(item).strip():
                    results.append(item)  # type: ignore[arg-type]
                    continue
                out = self.translate(
                    text=str(item),
                    target_lang=target_lang,
                    source_lang=source_lang,
                    scene=scene,
                )
                results.append(out)
            return results

        if not text or not str(text).strip():
            return text  # type: ignore[return-value]

        tgt = (target_lang or "").strip().lower()
        src = (source_lang or "").strip().lower() or None
        if tgt == "en" and self._is_english_text(text):
            return text
        if tgt == "zh" and (self._contains_chinese(text) or self._is_pure_number(text)):
            return text

        result = self._translate_qwen(text, tgt, src)
        return result

    def _translate_qwen(
        self,
        text: str,
        target_lang: str,
        source_lang: Optional[str],
    ) -> Optional[str]:
        if not self._qwen_client:
            return None
        tgt_norm = (target_lang or "").strip().lower()
        src_norm = (source_lang or "").strip().lower()
        tgt_qwen = QWEN_LANGUAGE_CODES.get(tgt_norm, tgt_norm.capitalize())
        src_qwen = "auto" if not src_norm or src_norm == "auto" else QWEN_LANGUAGE_CODES.get(src_norm, src_norm.capitalize())
        start = time.time()
        try:
            completion = self._qwen_client.chat.completions.create(
                model=self.qwen_model_name,
                messages=[{"role": "user", "content": text}],
                extra_body={
                    "translation_options": {
                        "source_lang": src_qwen,
                        "target_lang": tgt_qwen,
                    }
                },
                timeout=self.timeout,
            )
            content = (completion.choices[0].message.content or "").strip()
            if not content:
                return None
            logger.info("[qwen-mt] Success | src=%s tgt=%s latency=%.1fms", src_qwen, tgt_qwen, (time.time() - start) * 1000)
            return content
        except Exception as exc:
            logger.warning(
                "[qwen-mt] Failed | src=%s tgt=%s latency=%.1fms error=%s",
                src_qwen,
                tgt_qwen,
                (time.time() - start) * 1000,
                exc,
                exc_info=True,
            )
            return None

    @staticmethod
    def _contains_chinese(text: str) -> bool:
        return bool(re.search(r"[\u4e00-\u9fff]", text or ""))

    @staticmethod
    def _is_english_text(text: str) -> bool:
        stripped = (text or "").strip()
        return bool(stripped) and bool(re.fullmatch(r"[A-Za-z0-9\s\W]+", stripped)) and not QwenMTTranslationBackend._contains_chinese(stripped)

    @staticmethod
    def _is_pure_number(text: str) -> bool:
        return bool(re.fullmatch(r"[\d.\-+%/,: ]+", (text or "").strip()))