"""Translation service orchestration."""
  
  from __future__ import annotations
  
  import logging

  from typing import Dict, List, Optional, Tuple

  from config.loader import get_app_config
  from config.schema import AppConfig

  from translation.cache import TranslationCache

  from translation.protocols import TranslateInput, TranslateOutput, TranslationBackendProtocol

  from translation.settings import (
      TranslationConfig,
      get_enabled_translation_models,
      get_translation_capability,
      normalize_translation_model,
      normalize_translation_scene,

      translation_cache_probe_models,

  )

  
  logger = logging.getLogger(__name__)
  
  
  class TranslationService:
      """Owns translation backends and routes calls by model and scene."""
  

      def __init__(self, config: Optional[TranslationConfig] = None, app_config: Optional[AppConfig] = None) -> None:
          self._app_config = app_config or get_app_config()
          self.config = config or self._app_config.services.translation.as_dict()

          self._enabled_capabilities = self._collect_enabled_capabilities()

          if not self._enabled_capabilities:
              raise ValueError("No enabled translation backends found in services.translation.capabilities")

          self._translation_cache = TranslationCache(self.config["cache"])

          self._backends: Dict[str, TranslationBackendProtocol] = {}
          self._backend_errors: Dict[str, str] = {}
          self._initialize_backends()
          if not self._backends:
              details = ", ".join(f"{name}: {err}" for name, err in sorted(self._backend_errors.items())) or "unknown error"
              raise RuntimeError(f"No translation backends could be initialized: {details}")

      def _collect_enabled_capabilities(self) -> Dict[str, Dict[str, object]]:
          enabled: Dict[str, Dict[str, object]] = {}
          for name in get_enabled_translation_models(self.config):
              capability = get_translation_capability(self.config, name, require_enabled=True)
              backend_type = capability.get("backend")
              if not backend_type:
                  raise ValueError(f"Translation capability '{name}' must define a backend")
              enabled[name] = capability
          return enabled
  
      def _create_backend(
          self,
          *,
          name: str,
          backend_type: str,
          cfg: Dict[str, object],
      ) -> TranslationBackendProtocol:

          registry = {

              "qwen_mt": self._create_qwen_mt_backend,

              "deepl": self._create_deepl_backend,
              "llm": self._create_llm_backend,

              "local_nllb": self._create_local_nllb_backend,
              "local_marian": self._create_local_marian_backend,

          }

          factory = registry.get(backend_type)
          if factory is None:
              raise ValueError(f"Unsupported translation backend '{backend_type}' for capability '{name}'")
          return factory(name=name, cfg=cfg)

      def _load_backend(self, name: str) -> Optional[TranslationBackendProtocol]:
          capability_cfg = self._enabled_capabilities.get(name)
          if capability_cfg is None:
              return None
          if name in self._backends:
              return self._backends[name]
  
          backend_type = str(capability_cfg["backend"])
          logger.info("Initializing translation backend | model=%s backend=%s", name, backend_type)
          try:
              backend = self._create_backend(

                  name=name,
                  backend_type=backend_type,
                  cfg=capability_cfg,
              )

          except Exception as exc:
              error_text = str(exc).strip() or exc.__class__.__name__
              self._backend_errors[name] = error_text
              logger.error(
                  "Translation backend initialization failed | model=%s backend=%s error=%s",

                  name,
                  backend_type,

                  error_text,
                  exc_info=True,

              )

              return None
  
          self._backends[name] = backend
          self._backend_errors.pop(name, None)
          logger.info(
              "Translation backend initialized | model=%s backend=%s use_cache=%s backend_model=%s",
              name,
              backend_type,
              bool(capability_cfg.get("use_cache")),
              getattr(backend, "model", name),
          )
          return backend
  
      def _initialize_backends(self) -> None:
          for name, capability_cfg in self._enabled_capabilities.items():
              self._load_backend(name)

      def _create_qwen_mt_backend(self, *, name: str, cfg: Dict[str, object]) -> TranslationBackendProtocol:

          from translation.backends.qwen_mt import QwenMTTranslationBackend
  

          return QwenMTTranslationBackend(

              capability_name=name,
              model=str(cfg["model"]).strip(),
              base_url=str(cfg["base_url"]).strip(),

              api_key=self._app_config.infrastructure.secrets.dashscope_api_key,

              timeout=int(cfg["timeout_sec"]),

              glossary_id=cfg.get("glossary_id"),

          )
  

      def _create_deepl_backend(self, *, name: str, cfg: Dict[str, object]) -> TranslationBackendProtocol:

          from translation.backends.deepl import DeepLTranslationBackend
  

          return DeepLTranslationBackend(

              api_key=self._app_config.infrastructure.secrets.deepl_auth_key,

              api_url=str(cfg["api_url"]).strip(),
              timeout=float(cfg["timeout_sec"]),

              glossary_id=cfg.get("glossary_id"),
          )
  

      def _create_llm_backend(self, *, name: str, cfg: Dict[str, object]) -> TranslationBackendProtocol:

          from translation.backends.llm import LLMTranslationBackend
  

          return LLMTranslationBackend(

              capability_name=name,
              model=str(cfg["model"]).strip(),
              timeout_sec=float(cfg["timeout_sec"]),
              base_url=str(cfg["base_url"]).strip(),

              api_key=self._app_config.infrastructure.secrets.dashscope_api_key,

          )
  
      def _create_local_nllb_backend(self, *, name: str, cfg: Dict[str, object]) -> TranslationBackendProtocol:

          from translation.backends.local_ctranslate2 import NLLBCTranslate2TranslationBackend

          return NLLBCTranslate2TranslationBackend(

              name=name,
              model_id=str(cfg["model_id"]).strip(),
              model_dir=str(cfg["model_dir"]).strip(),
              device=str(cfg["device"]).strip(),
              torch_dtype=str(cfg["torch_dtype"]).strip(),
              batch_size=int(cfg["batch_size"]),
              max_input_length=int(cfg["max_input_length"]),
              max_new_tokens=int(cfg["max_new_tokens"]),
              num_beams=int(cfg["num_beams"]),

              ct2_model_dir=cfg.get("ct2_model_dir"),
              ct2_compute_type=cfg.get("ct2_compute_type"),
              ct2_auto_convert=bool(cfg.get("ct2_auto_convert", True)),
              ct2_conversion_quantization=cfg.get("ct2_conversion_quantization"),
              ct2_inter_threads=int(cfg.get("ct2_inter_threads", 1)),
              ct2_intra_threads=int(cfg.get("ct2_intra_threads", 0)),
              ct2_max_queued_batches=int(cfg.get("ct2_max_queued_batches", 0)),
              ct2_batch_type=str(cfg.get("ct2_batch_type", "examples")),

              ct2_decoding_length_mode=str(cfg.get("ct2_decoding_length_mode", "fixed")),
              ct2_decoding_length_extra=int(cfg.get("ct2_decoding_length_extra", 0)),
              ct2_decoding_length_min=int(cfg.get("ct2_decoding_length_min", 1)),

          )
  
      def _create_local_marian_backend(self, *, name: str, cfg: Dict[str, object]) -> TranslationBackendProtocol:

          from translation.backends.local_ctranslate2 import MarianCTranslate2TranslationBackend, get_marian_language_direction

  
          source_lang, target_lang = get_marian_language_direction(name)
  

          return MarianCTranslate2TranslationBackend(

              name=name,
              model_id=str(cfg["model_id"]).strip(),
              model_dir=str(cfg["model_dir"]).strip(),
              device=str(cfg["device"]).strip(),
              torch_dtype=str(cfg["torch_dtype"]).strip(),
              batch_size=int(cfg["batch_size"]),
              max_input_length=int(cfg["max_input_length"]),
              max_new_tokens=int(cfg["max_new_tokens"]),
              num_beams=int(cfg["num_beams"]),
              source_langs=[source_lang],
              target_langs=[target_lang],

              ct2_model_dir=cfg.get("ct2_model_dir"),
              ct2_compute_type=cfg.get("ct2_compute_type"),
              ct2_auto_convert=bool(cfg.get("ct2_auto_convert", True)),
              ct2_conversion_quantization=cfg.get("ct2_conversion_quantization"),
              ct2_inter_threads=int(cfg.get("ct2_inter_threads", 1)),
              ct2_intra_threads=int(cfg.get("ct2_intra_threads", 0)),
              ct2_max_queued_batches=int(cfg.get("ct2_max_queued_batches", 0)),
              ct2_batch_type=str(cfg.get("ct2_batch_type", "examples")),

              ct2_decoding_length_mode=str(cfg.get("ct2_decoding_length_mode", "fixed")),
              ct2_decoding_length_extra=int(cfg.get("ct2_decoding_length_extra", 0)),
              ct2_decoding_length_min=int(cfg.get("ct2_decoding_length_min", 1)),

          )
  
      @property
      def available_models(self) -> List[str]:

          return list(self._enabled_capabilities.keys())
  
      @property
      def loaded_models(self) -> List[str]:

          return list(self._backends.keys())
  

      @property
      def failed_models(self) -> List[str]:
          return list(self._backend_errors.keys())
  
      @property
      def backend_errors(self) -> Dict[str, str]:
          return dict(self._backend_errors)
  

      def get_backend(self, model: Optional[str] = None) -> TranslationBackendProtocol:

          normalized = normalize_translation_model(self.config, model)

          backend = self._backends.get(normalized) or self._load_backend(normalized)

          if backend is None:

              if normalized not in self._enabled_capabilities:
                  raise ValueError(
                      f"Translation model '{normalized}' is not enabled. "
                      f"Available models: {', '.join(self.available_models) or 'none'}"
                  )
              error_text = self._backend_errors.get(normalized) or "unknown initialization error"
              raise RuntimeError(
                  f"Translation model '{normalized}' failed to initialize: {error_text}. "
                  f"Loaded models: {', '.join(self.loaded_models) or 'none'}"

              )

          return backend
  
      def translate(
          self,
          text: TranslateInput,
          target_lang: str,
          source_lang: Optional[str] = None,
          *,
          model: Optional[str] = None,
          scene: Optional[str] = None,

      ) -> TranslateOutput:

          normalized_model = normalize_translation_model(self.config, model)
          backend = self.get_backend(normalized_model)

          active_scene = normalize_translation_scene(self.config, scene)

          capability_cfg = self._enabled_capabilities[normalized_model]
          use_cache = bool(capability_cfg.get("use_cache"))

          logger.info(

              "Translation route | backend=%s request_type=%s use_cache=%s cache_available=%s",

              getattr(backend, "model", normalized_model),

              "single" if isinstance(text, str) else "batch",

              use_cache,
              self._translation_cache.available,
          )
          if not use_cache or not self._translation_cache.available:
              return backend.translate(
                  text=text,
                  target_lang=target_lang,
                  source_lang=source_lang,
                  scene=active_scene,
              )
  
          if isinstance(text, str):
              return self._translate_with_cache(
                  backend,
                  text=text,
                  target_lang=target_lang,
                  source_lang=source_lang,
                  scene=active_scene,
                  model=normalized_model,
              )
  
          return self._translate_batch_with_cache(

              text=text,
              target_lang=target_lang,
              source_lang=source_lang,

              backend=backend,

              scene=active_scene,

              model=normalized_model,
          )
  
      def _translate_with_cache(
          self,
          backend: TranslationBackendProtocol,
          *,
          text: str,
          target_lang: str,
          source_lang: Optional[str],
          scene: str,
          model: str,
      ) -> Optional[str]:
          if not text.strip():
              return text

          cached, _served = self._tiered_cache_get(
              request_model=model,
              target_lang=target_lang,
              source_text=text,
          )

          if cached is not None:
              logger.info(

                  "Translation cache served | request_type=single text_len=%s",

                  len(text),
              )
              return cached
          translated = backend.translate(
              text=text,
              target_lang=target_lang,
              source_lang=source_lang,
              scene=scene,

          )

          if translated is not None:
              self._translation_cache.set(
                  model=model,
                  target_lang=target_lang,
                  source_text=text,
                  translated_text=translated,
              )
              logger.info(

                  "Translation backend result cached | request_type=single text_len=%s result_len=%s",

                  len(text),
                  len(str(translated)),
              )
          else:
              logger.warning(

                  "Translation backend returned empty result | request_type=single text_len=%s",

                  len(text),
              )
          return translated
  

      def _tiered_cache_get(
          self,
          *,
          request_model: str,
          target_lang: str,
          source_text: str,
      ) -> Tuple[Optional[str], Optional[str]]:
          """Redis lookup: cache from higher-tier or **same-tier** models may satisfy A.
  
          Lower-tier entries are never read. Returns ``(translated, served_model)``.
          """
          probe_models = translation_cache_probe_models(self.config, request_model)
  
          for probe_model in probe_models:
              hit = self._translation_cache.get(
                  model=probe_model,
                  target_lang=target_lang,
                  source_text=source_text,
              )
              if hit is not None:
                  return hit, probe_model
  
          return None, None
  

      def _translate_batch_with_cache(
          self,
          *,
          text: TranslateInput,
          target_lang: str,
          source_lang: Optional[str],
          backend: TranslationBackendProtocol,
          scene: str,
          model: str,
      ) -> List[Optional[str]]:
          texts = list(text)
          results: List[Optional[str]] = [None] * len(texts)
          misses: List[str] = []
          miss_indices: List[int] = []
          cache_hits = 0
  
          for idx, item in enumerate(texts):
              normalized_text = "" if item is None else str(item)
              if not normalized_text.strip():
                  results[idx] = normalized_text
                  continue

              cached, _served = self._tiered_cache_get(
                  request_model=model,

                  target_lang=target_lang,
                  source_text=normalized_text,
              )
              if cached is not None:
                  results[idx] = cached
                  cache_hits += 1
                  continue
              misses.append(normalized_text)
              miss_indices.append(idx)
  
          logger.info(

              "Translation batch cache summary | total=%s cache_hits=%s cache_misses=%s",

              len(texts),
              cache_hits,
              len(misses),
          )
  
          if misses:
              translated = backend.translate(
                  text=misses,
                  target_lang=target_lang,
                  source_lang=source_lang,
                  scene=scene,
              )
              translated_list = translated if isinstance(translated, list) else [translated]
              for idx, original_text, translated_text in zip(miss_indices, misses, translated_list):
                  results[idx] = translated_text
                  if translated_text is not None:
                      self._translation_cache.set(
                          model=model,
                          target_lang=target_lang,
                          source_text=original_text,
                          translated_text=translated_text,
                      )
                  else:
                      logger.warning(

                          "Translation batch item returned empty result | item_index=%s text_len=%s",

                          idx,
                          len(original_text),
                      )
  
          return results