"""

  Services configuration - single source for translation, embedding, rerank.

  Translation is modeled as:
  - one translator service endpoint used by business callers
  - multiple translation capabilities loaded inside the translator service

  """
  
  from __future__ import annotations
  
  import os
  from dataclasses import dataclass, field
  from functools import lru_cache
  from pathlib import Path

  from typing import Any, Dict, List, Optional

  
  import yaml
  
  
  @dataclass
  class ServiceConfig:

      """Config for one capability (embedding/rerank)."""
  

      provider: str
      providers: Dict[str, Any] = field(default_factory=dict)
  
      def get_provider_cfg(self) -> Dict[str, Any]:

          p = (self.provider or "").strip().lower()
          return self.providers.get(p, {}) if isinstance(self.providers, dict) else {}
  
  

  @dataclass
  class TranslationServiceConfig:
      """Dedicated config model for the translation service."""
  
      service_url: str
      timeout_sec: float
      default_model: str
      default_scene: str
      capabilities: Dict[str, Dict[str, Any]] = field(default_factory=dict)
      cache: Dict[str, Any] = field(default_factory=dict)
  
      def normalize_model_name(self, model: Optional[str]) -> str:
          normalized = str(model or self.default_model).strip().lower()
          aliases = {
              "qwen": "qwen-mt",
              "qwen-mt-flash": "qwen-mt",
              "qwen-mt-flush": "qwen-mt",
              "service": self.default_model,
              "default": self.default_model,
          }
          return aliases.get(normalized, normalized)
  
      @property
      def enabled_models(self) -> List[str]:
          items: List[str] = []
          for name, cfg in self.capabilities.items():
              if isinstance(cfg, dict) and bool(cfg.get("enabled", False)):
                  items.append(str(name).strip().lower())
          return items
  
      def get_capability_cfg(self, model: Optional[str]) -> Dict[str, Any]:
          normalized = self.normalize_model_name(model)
          value = self.capabilities.get(normalized)
          return dict(value) if isinstance(value, dict) else {}
  
  

  def _load_services_raw(config_path: Optional[Path] = None) -> Dict[str, Any]:

      if config_path is None:
          config_path = Path(__file__).parent / "config.yaml"
      path = Path(config_path)
      if not path.exists():

          raise FileNotFoundError(f"services config file not found: {path}")

      try:
          with open(path, "r", encoding="utf-8") as f:
              data = yaml.safe_load(f)

      except Exception as exc:
          raise RuntimeError(f"failed to parse services config from {path}: {exc}") from exc
      if not isinstance(data, dict):
          raise RuntimeError(f"invalid config format in {path}: expected mapping root")
      services = data.get("services")
      if not isinstance(services, dict):
          raise RuntimeError("config.yaml must contain a valid 'services' mapping")
      return services
  
  

  def _resolve_provider_name(env_name: str, config_provider: Any, capability: str) -> str:

      provider = os.getenv(env_name) or config_provider
      if not provider:
          raise ValueError(
              f"services.{capability}.provider is required "
              f"(or set env override {env_name})"
          )
      return str(provider).strip().lower()

  def _resolve_translation() -> TranslationServiceConfig:

      raw = _load_services_raw()
      cfg = raw.get("translation", {}) if isinstance(raw.get("translation"), dict) else {}

      service_url = (
          os.getenv("TRANSLATION_SERVICE_URL")
          or cfg.get("service_url")
          or cfg.get("base_url")
          or "http://127.0.0.1:6006"

      )

      timeout_sec = float(os.getenv("TRANSLATION_TIMEOUT_SEC") or cfg.get("timeout_sec") or 10.0)
  
      raw_capabilities = cfg.get("capabilities")
      if not isinstance(raw_capabilities, dict):
          raw_capabilities = cfg.get("providers")
      capabilities = raw_capabilities if isinstance(raw_capabilities, dict) else {}
  
      default_model = str(
          os.getenv("TRANSLATION_MODEL")
          or cfg.get("default_model")
          or cfg.get("provider")
          or "qwen-mt"
      ).strip().lower()
      default_scene = str(
          os.getenv("TRANSLATION_SCENE")
          or cfg.get("default_scene")
          or "general"
      ).strip() or "general"
  
      resolved_capabilities: Dict[str, Dict[str, Any]] = {}
      for name, value in capabilities.items():
          if not isinstance(value, dict):
              continue
          normalized = str(name or "").strip().lower()
          if not normalized:
              continue
          copied = dict(value)
          copied.setdefault("enabled", normalized == default_model)
          resolved_capabilities[normalized] = copied
  
      aliases = {
          "qwen": "qwen-mt",
          "qwen-mt-flash": "qwen-mt",
          "qwen-mt-flush": "qwen-mt",
      }
      default_model = aliases.get(default_model, default_model)

      if default_model not in resolved_capabilities:
          raise ValueError(
              f"services.translation.default_model '{default_model}' is not defined in capabilities"
          )
      if not bool(resolved_capabilities[default_model].get("enabled", False)):
          resolved_capabilities[default_model]["enabled"] = True

      cache_cfg = cfg.get("cache", {}) if isinstance(cfg.get("cache"), dict) else {}
  
      return TranslationServiceConfig(
          service_url=str(service_url).rstrip("/"),
          timeout_sec=timeout_sec,
          default_model=default_model,
          default_scene=default_scene,
          capabilities=resolved_capabilities,
          cache=cache_cfg,
      )

  
  
  def _resolve_embedding() -> ServiceConfig:
      raw = _load_services_raw()
      cfg = raw.get("embedding", {}) if isinstance(raw.get("embedding"), dict) else {}
      providers = cfg.get("providers", {}) if isinstance(cfg.get("providers"), dict) else {}
  

      provider = _resolve_provider_name(
          env_name="EMBEDDING_PROVIDER",
          config_provider=cfg.get("provider"),
          capability="embedding",

      )

      if provider != "http":
          raise ValueError(f"Unsupported embedding provider: {provider}")

  
      env_url = os.getenv("EMBEDDING_SERVICE_URL")
      if env_url and provider == "http":
          providers = dict(providers)
          providers["http"] = dict(providers.get("http", {}))
          providers["http"]["base_url"] = env_url.rstrip("/")
  
      return ServiceConfig(provider=provider, providers=providers)
  
  
  def _resolve_rerank() -> ServiceConfig:
      raw = _load_services_raw()
      cfg = raw.get("rerank", {}) if isinstance(raw.get("rerank"), dict) else {}
      providers = cfg.get("providers", {}) if isinstance(cfg.get("providers"), dict) else {}
  

      provider = _resolve_provider_name(
          env_name="RERANK_PROVIDER",
          config_provider=cfg.get("provider"),
          capability="rerank",

      )

      if provider != "http":
          raise ValueError(f"Unsupported rerank provider: {provider}")

  
      env_url = os.getenv("RERANKER_SERVICE_URL")
      if env_url:
          url = env_url.rstrip("/")
          if not url.endswith("/rerank"):
              url = f"{url}/rerank" if "/rerank" not in url else url
          providers = dict(providers)
          providers["http"] = dict(providers.get("http", {}))
          providers["http"]["base_url"] = url.replace("/rerank", "")
          providers["http"]["service_url"] = url
  
      return ServiceConfig(provider=provider, providers=providers)
  
  

  def get_rerank_backend_config() -> tuple[str, dict]:

      raw = _load_services_raw()
      cfg = raw.get("rerank", {}) if isinstance(raw.get("rerank"), dict) else {}
      backends = cfg.get("backends", {}) if isinstance(cfg.get("backends"), dict) else {}

      name = os.getenv("RERANK_BACKEND") or cfg.get("backend")

      if not name:
          raise ValueError("services.rerank.backend is required (or env RERANK_BACKEND)")

      name = str(name).strip().lower()
      backend_cfg = backends.get(name, {}) if isinstance(backends.get(name), dict) else {}

      if not backend_cfg:
          raise ValueError(f"services.rerank.backends.{name} is required")

      return name, backend_cfg
  
  
  def get_embedding_backend_config() -> tuple[str, dict]:

      raw = _load_services_raw()
      cfg = raw.get("embedding", {}) if isinstance(raw.get("embedding"), dict) else {}
      backends = cfg.get("backends", {}) if isinstance(cfg.get("backends"), dict) else {}

      name = os.getenv("EMBEDDING_BACKEND") or cfg.get("backend")

      if not name:
          raise ValueError("services.embedding.backend is required (or env EMBEDDING_BACKEND)")

      name = str(name).strip().lower()
      backend_cfg = backends.get(name, {}) if isinstance(backends.get(name), dict) else {}

      if not backend_cfg:
          raise ValueError(f"services.embedding.backends.{name} is required")

      return name, backend_cfg
  
  

  @lru_cache(maxsize=1)

  def get_translation_config() -> TranslationServiceConfig:

      return _resolve_translation()
  
  
  @lru_cache(maxsize=1)
  def get_embedding_config() -> ServiceConfig:

      return _resolve_embedding()
  
  
  @lru_cache(maxsize=1)
  def get_rerank_config() -> ServiceConfig:

      return _resolve_rerank()
  
  
  def get_translation_base_url() -> str:

      return get_translation_config().service_url

  def get_translation_cache_config() -> Dict[str, Any]:

      cache_cfg = get_translation_config().cache

      return {
          "enabled": bool(cache_cfg.get("enabled", True)),
          "key_prefix": str(cache_cfg.get("key_prefix", "trans:v2")),
          "ttl_seconds": int(cache_cfg.get("ttl_seconds", 360 * 24 * 3600)),
          "sliding_expiration": bool(cache_cfg.get("sliding_expiration", True)),
          "key_include_context": bool(cache_cfg.get("key_include_context", True)),
          "key_include_prompt": bool(cache_cfg.get("key_include_prompt", True)),
          "key_include_source_lang": bool(cache_cfg.get("key_include_source_lang", True)),
      }
  
  

  def get_embedding_base_url() -> str:

      base = os.getenv("EMBEDDING_SERVICE_URL") or get_embedding_config().providers.get("http", {}).get("base_url")

      if not base:
          raise ValueError("Embedding HTTP base_url is not configured")

      return str(base).rstrip("/")
  
  

  def get_rerank_base_url() -> str:

      base = (
          os.getenv("RERANKER_SERVICE_URL")
          or get_rerank_config().providers.get("http", {}).get("service_url")
          or get_rerank_config().providers.get("http", {}).get("base_url")

      )

      if not base:

          raise ValueError("Rerank HTTP base_url is not configured")
      return str(base).rstrip("/")

  def get_rerank_service_url() -> str:
      """Backward-compatible alias."""
      return get_rerank_base_url()