"""Translator service HTTP app."""

  import argparse

  import asyncio

  import logging

  import os
  import pathlib
  import time

  import uuid

  from contextlib import asynccontextmanager

  from functools import lru_cache, partial

  from logging.handlers import TimedRotatingFileHandler

  from typing import List, Optional, Union
  

  import anyio

  import uvicorn

  from fastapi import FastAPI, HTTPException, Request

  from fastapi.middleware.cors import CORSMiddleware

  from fastapi.responses import JSONResponse
  from pydantic import BaseModel, ConfigDict, Field

  from config.services_config import get_translation_config

  from translation.logging_utils import (
      TranslationRequestFilter,
      bind_translation_request_id,
      reset_translation_request_id,
  )

  from translation.service import TranslationService

  from translation.settings import (
      get_enabled_translation_models,
      normalize_translation_model,
      normalize_translation_scene,
  )

  
  def configure_translator_logging() -> None:
      log_dir = pathlib.Path("logs")
      verbose_dir = log_dir / "verbose"
      log_dir.mkdir(exist_ok=True)
      verbose_dir.mkdir(parents=True, exist_ok=True)
  
      log_level = os.getenv("LOG_LEVEL", "INFO").upper()
      numeric_level = getattr(logging, log_level, logging.INFO)

      formatter = logging.Formatter("%(asctime)s | reqid:%(reqid)s | %(name)s | %(levelname)s | %(message)s")
      request_filter = TranslationRequestFilter()

  
      root_logger = logging.getLogger()
      root_logger.setLevel(numeric_level)
      root_logger.handlers.clear()
  
      console_handler = logging.StreamHandler()
      console_handler.setLevel(numeric_level)
      console_handler.setFormatter(formatter)

      console_handler.addFilter(request_filter)

      root_logger.addHandler(console_handler)
  
      file_handler = TimedRotatingFileHandler(
          filename=log_dir / "translator_api.log",
          when="midnight",
          interval=1,
          backupCount=30,
          encoding="utf-8",
      )
      file_handler.setLevel(numeric_level)
      file_handler.setFormatter(formatter)

      file_handler.addFilter(request_filter)

      root_logger.addHandler(file_handler)
  
      verbose_logger = logging.getLogger("translator.verbose")
      verbose_logger.setLevel(numeric_level)
      verbose_logger.handlers.clear()
      verbose_logger.propagate = False
  
      verbose_handler = TimedRotatingFileHandler(
          filename=verbose_dir / "translator_verbose.log",
          when="midnight",
          interval=1,
          backupCount=30,
          encoding="utf-8",
      )
      verbose_handler.setLevel(numeric_level)
      verbose_handler.setFormatter(formatter)

      verbose_handler.addFilter(request_filter)

      verbose_logger.addHandler(verbose_handler)
  
  
  configure_translator_logging()

  logger = logging.getLogger(__name__)

  verbose_logger = logging.getLogger("translator.verbose")

  @lru_cache(maxsize=1)

  def get_translation_service() -> TranslationService:

      return TranslationService(get_translation_config())

  _TRANSLATION_MAX_INFLIGHT = int(os.getenv("TRANSLATION_MAX_INFLIGHT", "4"))
  _translation_inflight_semaphore = asyncio.Semaphore(max(1, _TRANSLATION_MAX_INFLIGHT))
  
  
  async def _run_translation_blocking(fn, /, *args, **kwargs):
      """Run blocking translation work in a thread with bounded concurrency."""
      bound = partial(fn, *args, **kwargs)
      async with _translation_inflight_semaphore:
          return await anyio.to_thread.run_sync(bound)
  
  

  # Request/Response models
  class TranslationRequest(BaseModel):
      """Translation request model."""

      model_config = ConfigDict(
          json_schema_extra={

              "example": {
                  "text": "商品名称",
                  "target_lang": "en",

                  "source_lang": "zh",

                  "model": "llm",

                  "scene": "sku_name",

              }
          }

      )
  
      text: Union[str, List[str]] = Field(..., description="Text to translate (string or list of strings)")
      target_lang: str = Field(..., description="Target language code (zh, en, ru, etc.)")
      source_lang: Optional[str] = Field(None, description="Source language code (optional, auto-detect if not provided)")
      model: Optional[str] = Field(None, description="Enabled translation capability name")
      scene: Optional[str] = Field(None, description="Translation scene, paired with model routing")

  
  
  class TranslationResponse(BaseModel):
      """Translation response model."""

      text: Union[str, List[str]] = Field(..., description="Original text (string or list)")

      target_lang: str = Field(..., description="Target language code")
      source_lang: Optional[str] = Field(None, description="Source language code (detected or provided)")

      translated_text: Union[str, List[Optional[str]]] = Field(
          ...,
          description="Translated text (string or list; list elements may be null on failure)",
      )

      status: str = Field(..., description="Translation status")

      model: str = Field(..., description="Translation model used")

      scene: str = Field(..., description="Translation scene used")

  def _normalize_scene(service: TranslationService, scene: Optional[str]) -> str:
      return normalize_translation_scene(service.config, scene)
  
  
  def _normalize_model(service: TranslationService, model: Optional[str]) -> str:
      return normalize_translation_model(service.config, model or service.config["default_model"])
  
  
  def _ensure_valid_text(text: Union[str, List[str]]) -> None:
      if isinstance(text, list):
          if not text:
              raise HTTPException(status_code=400, detail="Text list cannot be empty")
          return
      if not text or not text.strip():
          raise HTTPException(status_code=400, detail="Text cannot be empty")
  
  
  def _normalize_batch_result(
      original: List[str],
      translated: Union[str, List[Optional[str]], None],
  ) -> List[Optional[str]]:
      if translated is None:
          return [None for _ in original]
      if not isinstance(translated, list):
          raise HTTPException(status_code=500, detail="Batch translation provider returned non-list result")
      return [translated[idx] if idx < len(translated) else None for idx, _ in enumerate(original)]
  
  

  def _text_preview(text: Optional[str], limit: int = 20) -> str:
      normalized = str(text or "").replace("\n", "\\n")
      return normalized[:limit]
  
  
  def _request_metrics(text: Union[str, List[str]]) -> dict:
      if isinstance(text, list):
          lengths = [len(str(item or "")) for item in text]
          return {
              "request_count": len(text),
              "lengths": lengths,
              "first_preview": _text_preview(text[0] if text else ""),
          }
      return {
          "request_count": 1,
          "lengths": [len(str(text or ""))],
          "first_preview": _text_preview(str(text or "")),
      }
  
  
  def _result_preview(translated: Union[str, List[Optional[str]], None]) -> str:
      if isinstance(translated, list):
          if not translated:
              return ""
          first = translated[0]
          return _text_preview("" if first is None else str(first))
      if translated is None:
          return ""
      return _text_preview(str(translated))
  
  

  def _resolve_request_id(http_request: Request) -> str:
      header_value = http_request.headers.get("X-Request-ID")
      if header_value and header_value.strip():
          return header_value.strip()[:32]
      return str(uuid.uuid4())[:8]
  
  

  def _translate_batch(
      service: TranslationService,
      raw_text: List[str],
      *,
      target_lang: str,
      source_lang: Optional[str],
      model: str,
      scene: str,
  ) -> List[Optional[str]]:
      backend = service.get_backend(model)

      logger.info(

          "Translation batch dispatch | execution=%s count=%s lengths=%s first_preview=%s",
          "backend-batch" if getattr(backend, "supports_batch", False) else "per-item",

          len(raw_text),
          [len(str(item or "")) for item in raw_text],
          _text_preview(raw_text[0] if raw_text else ""),

      )

      if getattr(backend, "supports_batch", False):
          try:
              translated = service.translate(
                  text=raw_text,
                  target_lang=target_lang,
                  source_lang=source_lang,
                  model=model,
                  scene=scene,
              )

              verbose_logger.info(
                  "Translation batch result | model=%s scene=%s count=%s first_result=%s",
                  model,
                  scene,
                  len(raw_text),
                  _result_preview(translated),
              )

              return _normalize_batch_result(raw_text, translated)
          except ValueError:
              raise
          except Exception as exc:
              logger.error("Batch translation failed: %s", exc, exc_info=True)
  
      results: List[Optional[str]] = []
      for item in raw_text:
          if item is None or not str(item).strip():
              results.append(item)  # type: ignore[arg-type]
              continue
          try:
              out = service.translate(
                  text=str(item),
                  target_lang=target_lang,
                  source_lang=source_lang,
                  model=model,
                  scene=scene,
              )
          except ValueError:
              raise
          except Exception as exc:

              logger.warning(
                  "Per-item translation failed | model=%s scene=%s target_lang=%s source_lang=%s item_len=%s item_preview=%s error=%s",
                  model,
                  scene,
                  target_lang,
                  source_lang or "auto",
                  len(str(item or "")),
                  _text_preview(str(item or "")),
                  exc,
                  exc_info=True,
              )

              out = None
          results.append(out)
      return results
  
  
  @asynccontextmanager
  async def lifespan(_: FastAPI):

      """Initialize all enabled translation backends on process startup."""

      logger.info("Starting Translation Service API")
      service = get_translation_service()

      failed_models = list(getattr(service, "failed_models", []))
      backend_errors = dict(getattr(service, "backend_errors", {}))

      logger.info(

          "Translation service ready | default_model=%s default_scene=%s available_models=%s loaded_models=%s failed_models=%s",

          service.config["default_model"],

          service.config["default_scene"],

          service.available_models,
          service.loaded_models,

          failed_models,

      )
      logger.info(

          "Translation backends initialized on startup | loaded=%s failed=%s",

          service.loaded_models,

          backend_errors,

      )
      verbose_logger.info(
          "Translation startup detail | capabilities=%s cache_ttl_seconds=%s cache_sliding_expiration=%s",
          service.available_models,
          service.config["cache"]["ttl_seconds"],
          service.config["cache"]["sliding_expiration"],

      )
      yield
  
  

  # Create FastAPI app
  app = FastAPI(
      title="Translation Service API",

      description="Translation service with pluggable capabilities and scene routing",

      version="1.0.0",
      docs_url="/docs",

      redoc_url="/redoc",
      lifespan=lifespan,

  )
  
  # Add CORS middleware
  app.add_middleware(
      CORSMiddleware,
      allow_origins=["*"],
      allow_credentials=True,
      allow_methods=["*"],
      allow_headers=["*"],
  )
  
  

  @app.get("/health")
  async def health_check():
      """Health check endpoint."""
      try:

          service = get_translation_service()

          failed_models = list(getattr(service, "failed_models", []))
          backend_errors = dict(getattr(service, "backend_errors", {}))

          logger.info(

              "Health check | default_model=%s default_scene=%s loaded_models=%s failed_models=%s",

              service.config["default_model"],
              service.config["default_scene"],
              service.loaded_models,

              failed_models,

          )

          return {
              "status": "healthy",
              "service": "translation",

              "max_inflight": _TRANSLATION_MAX_INFLIGHT,

              "default_model": service.config["default_model"],
              "default_scene": service.config["default_scene"],

              "available_models": service.available_models,

              "enabled_capabilities": get_enabled_translation_models(service.config),
              "loaded_models": service.loaded_models,

              "failed_models": failed_models,
              "backend_errors": backend_errors,

          }
      except Exception as e:
          logger.error(f"Health check failed: {e}")
          return JSONResponse(
              status_code=503,
              content={
                  "status": "unhealthy",
                  "error": str(e)
              }
          )
  
  
  @app.post("/translate", response_model=TranslationResponse)

  async def translate(request: TranslationRequest, http_request: Request):

      _ensure_valid_text(request.text)
  

      if not request.target_lang:

          raise HTTPException(status_code=400, detail="target_lang is required")
  

      _, request_token = bind_translation_request_id(_resolve_request_id(http_request))

      request_started = time.perf_counter()

      try:

          service = get_translation_service()

          scene = _normalize_scene(service, request.scene)
          model = _normalize_model(service, request.model)

          translator = service.get_backend(model)

          raw_text = request.text

          metrics = _request_metrics(raw_text)
          logger.info(
              "Translation request | model=%s scene=%s target_lang=%s source_lang=%s count=%s lengths=%s first_preview=%s backend=%s",
              model,
              scene,
              request.target_lang,
              request.source_lang or "auto",
              metrics["request_count"],
              metrics["lengths"],
              metrics["first_preview"],
              getattr(translator, "model", model),
          )
          verbose_logger.info(
              "Translation request detail | model=%s scene=%s target_lang=%s source_lang=%s payload=%s",
              model,
              scene,
              request.target_lang,
              request.source_lang or "auto",
              raw_text,
          )

          if isinstance(raw_text, list):

              results = await _run_translation_blocking(
                  _translate_batch,

                  service,
                  raw_text,
                  target_lang=request.target_lang,
                  source_lang=request.source_lang,
                  model=model,
                  scene=scene,
              )

              latency_ms = (time.perf_counter() - request_started) * 1000
              logger.info(
                  "Translation response | model=%s scene=%s count=%s first_result=%s latency_ms=%.2f",
                  model,
                  scene,
                  len(raw_text),
                  _result_preview(results),
                  latency_ms,
              )
              verbose_logger.info(
                  "Translation response detail | model=%s scene=%s translated=%s latency_ms=%.2f",
                  model,
                  scene,
                  results,
                  latency_ms,
              )

              return TranslationResponse(
                  text=raw_text,
                  target_lang=request.target_lang,
                  source_lang=request.source_lang,
                  translated_text=results,
                  status="success",
                  model=str(getattr(translator, "model", model)),

                  scene=scene,

              )
  

          translated_text = await _run_translation_blocking(
              service.translate,

              text=raw_text,

              target_lang=request.target_lang,
              source_lang=request.source_lang,

              model=model,
              scene=scene,

          )

          if translated_text is None:

              raise HTTPException(status_code=500, detail="Translation failed")

          latency_ms = (time.perf_counter() - request_started) * 1000
          logger.info(
              "Translation response | model=%s scene=%s count=1 first_result=%s latency_ms=%.2f",
              model,
              scene,
              _result_preview(translated_text),
              latency_ms,
          )
          verbose_logger.info(
              "Translation response detail | model=%s scene=%s translated=%s latency_ms=%.2f",
              model,
              scene,
              translated_text,
              latency_ms,
          )
  

          return TranslationResponse(

              text=raw_text,

              target_lang=request.target_lang,
              source_lang=request.source_lang,
              translated_text=translated_text,

              status="success",

              model=str(getattr(translator, "model", model)),
              scene=scene,

          )
      

      except HTTPException as exc:
          latency_ms = (time.perf_counter() - request_started) * 1000
          logger.warning(
              "Translation request failed | status_code=%s detail=%s latency_ms=%.2f",
              exc.status_code,
              exc.detail,
              latency_ms,
          )

          raise

      except ValueError as e:

          latency_ms = (time.perf_counter() - request_started) * 1000

          logger.warning("Translation validation error | error=%s latency_ms=%.2f", e, latency_ms)

          raise HTTPException(status_code=400, detail=str(e)) from e

      except RuntimeError as e:
          latency_ms = (time.perf_counter() - request_started) * 1000
          logger.warning("Translation backend unavailable | error=%s latency_ms=%.2f", e, latency_ms)
          raise HTTPException(status_code=503, detail=str(e)) from e

      except Exception as e:

          latency_ms = (time.perf_counter() - request_started) * 1000
          logger.error("Translation error | error=%s latency_ms=%.2f", e, latency_ms, exc_info=True)

          raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")

      finally:
          reset_translation_request_id(request_token)

  
  
  @app.get("/")
  async def root():
      """Root endpoint with API information."""
      return {
          "service": "Translation Service API",
          "version": "1.0.0",
          "status": "running",
          "endpoints": {
              "translate": "POST /translate",
              "health": "GET /health",
              "docs": "GET /docs"
          }
      }
  
  
  if __name__ == "__main__":
      parser = argparse.ArgumentParser(description='Start translation API service')
      parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
      parser.add_argument('--port', type=int, default=6006, help='Port to bind to')
      parser.add_argument('--reload', action='store_true', help='Enable auto-reload')
      args = parser.parse_args()
  
      # Run server
      uvicorn.run(
          "api.translator_app:app",
          host=args.host,
          port=args.port,
          reload=args.reload
      )