"""DeepL translation backend."""
  
  from __future__ import annotations
  
  import logging

  import re

  from typing import List, Optional, Sequence, Tuple, Union

  
  import requests
  

  from translation.languages import DEEPL_LANGUAGE_CODES
  from translation.scenes import SCENE_DEEPL_CONTEXTS, normalize_scene_name

  
  logger = logging.getLogger(__name__)
  

  
  class DeepLTranslationBackend:

      def __init__(
          self,
          api_key: Optional[str],
          *,

          api_url: str,
          timeout: float,

          glossary_id: Optional[str] = None,
      ) -> None:

          self.api_key = api_key

          self.api_url = api_url
          self.timeout = float(timeout)
          self.glossary_id = glossary_id

          self.model = "deepl"

          if not self.api_key:
              logger.warning("DEEPL_AUTH_KEY not set; DeepL translation is unavailable")
  
      @property
      def supports_batch(self) -> bool:
          return False
  
      def _resolve_request_context(
          self,
          target_lang: str,

          scene: Optional[str],

      ) -> Optional[str]:

          if scene is None:
              raise ValueError("deepl translation scene is required")
          normalized_scene = normalize_scene_name(scene)
          scene_map = SCENE_DEEPL_CONTEXTS[normalized_scene]
          tgt = str(target_lang or "").strip().lower()

          return scene_map.get(tgt) or scene_map.get("en")
  
      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 self.api_key:
              return None
  

          target_code = DEEPL_LANGUAGE_CODES.get((target_lang or "").lower(), (target_lang or "").upper())

          headers = {
              "Authorization": f"DeepL-Auth-Key {self.api_key}",
              "Content-Type": "application/json",
          }
  

          api_context = self._resolve_request_context(target_lang, scene)

          text_to_translate, needs_extraction = self._add_ecommerce_context(text, source_lang, api_context)
  
          payload = {
              "text": [text_to_translate],
              "target_lang": target_code,
          }
          if source_lang:

              payload["source_lang"] = DEEPL_LANGUAGE_CODES.get(source_lang.lower(), source_lang.upper())

          if api_context:
              payload["context"] = api_context
          if self.glossary_id:
              payload["glossary_id"] = self.glossary_id
  
          try:

              response = requests.post(self.api_url, headers=headers, json=payload, timeout=self.timeout)

              if response.status_code != 200:
                  logger.warning(
                      "[deepl] Failed | status=%s tgt=%s body=%s",
                      response.status_code,
                      target_code,
                      (response.text or "")[:200],
                  )
                  return None
  
              data = response.json()
              translations = data.get("translations") or []
              if not translations:
                  return None
              translated = translations[0].get("text")
              if not translated:
                  return None
              if needs_extraction:
                  translated = self._extract_term_from_translation(translated, text, target_code)
              return translated
          except requests.Timeout:
              logger.warning("[deepl] Timeout | tgt=%s timeout=%.1fs", target_code, self.timeout)
              return None
          except Exception as exc:
              logger.warning("[deepl] Exception | tgt=%s error=%s", target_code, exc, exc_info=True)
              return None
  
      def _add_ecommerce_context(
          self,
          text: str,
          source_lang: Optional[str],

          scene: Optional[str],

      ) -> Tuple[str, bool]:

          if not scene or "e-commerce" not in scene.lower():

              return text, False
          if (source_lang or "").lower() != "zh":
              return text, False
  
          term = (text or "").strip()
          if len(term.split()) == 1 and len(term) <= 2:
              return f"购买 {term}", True
          return text, False
  
      def _extract_term_from_translation(
          self,
          translated_text: str,
          original_text: str,
          target_lang_code: str,
      ) -> str:
          del original_text
          if target_lang_code != "EN":
              return translated_text
  
          words = translated_text.strip().split()
          if len(words) <= 1:
              return translated_text
          context_words = {"buy", "purchase", "product", "item", "commodity", "goods"}
          for word in reversed(words):
              normalized = re.sub(r"[.,!?;:]+$", "", word.lower())
              if normalized not in context_words:
                  return normalized
          return re.sub(r"[.,!?;:]+$", "", words[-1].lower())