"""HTTP client for the translation service."""
  
  from __future__ import annotations
  
  import logging
  from typing import List, Optional, Sequence, Union
  
  import requests

  from requests.adapters import HTTPAdapter

  from config.loader import get_app_config

  from translation.settings import normalize_translation_model, normalize_translation_scene

  
  logger = logging.getLogger(__name__)
  
  
  class TranslationServiceClient:
      """Business-side translation client that talks to the translator service."""
  
      def __init__(
          self,
          *,
          base_url: Optional[str] = None,
          default_model: Optional[str] = None,
          default_scene: Optional[str] = None,
          timeout_sec: Optional[float] = None,
      ) -> None:

          cfg = get_app_config().services.translation.as_dict()

          self.base_url = str(base_url or cfg["service_url"]).rstrip("/")
          self.default_model = normalize_translation_model(cfg, default_model or cfg["default_model"])
          self.default_scene = normalize_translation_scene(cfg, default_scene or cfg["default_scene"])
          self.timeout_sec = float(cfg["timeout_sec"] if timeout_sec is None else timeout_sec)

          self._session = requests.Session()
          self._session.mount("http://", HTTPAdapter(pool_connections=32, pool_maxsize=32, max_retries=0))
          self._session.mount("https://", HTTPAdapter(pool_connections=32, pool_maxsize=32, max_retries=0))

  
      @property
      def model(self) -> str:
          return self.default_model
  
      @property
      def supports_batch(self) -> bool:
          return True
  
      def translate(
          self,
          text: Union[str, Sequence[str]],
          target_lang: str,
          source_lang: Optional[str] = None,

          scene: Optional[str] = None,

          model: Optional[str] = None,

      ) -> Union[Optional[str], List[Optional[str]]]:
          if isinstance(text, tuple):
              text = list(text)
          payload = {
              "text": text,
              "target_lang": target_lang,

              "source_lang": source_lang,

              "model": (model or self.default_model),

              "scene": self.default_scene if scene is None else scene,

          }

          try:

              response = self._session.post(

                  f"{self.base_url}/translate",
                  json=payload,

                  timeout=(2.0, self.timeout_sec),

              )
              if response.status_code != 200:
                  logger.warning(
                      "Translation service request failed: status=%s body=%s",
                      response.status_code,
                      (response.text or "")[:300],
                  )
                  return self._empty_result_for(text)
              data = response.json()
              return data.get("translated_text")
          except Exception as exc:
              logger.warning("Translation service request error: %s", exc, exc_info=True)
              return self._empty_result_for(text)
  
      @staticmethod
      def _empty_result_for(
          text: Union[str, Sequence[str]],
      ) -> Union[Optional[str], List[Optional[str]]]:
          if isinstance(text, (list, tuple)):
              return [None for _ in text]
          return None

  
  
  def create_translation_client() -> TranslationServiceClient:
      """Create the business-side translation client."""
      return TranslationServiceClient()