"""Translator service HTTP app."""

  import argparse

  import logging
  from contextlib import asynccontextmanager
  from functools import lru_cache
  from typing import List, Optional, Union
  

  import uvicorn

  from fastapi import FastAPI, HTTPException

  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.service import TranslationService

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

  
  # Configure logging
  logging.basicConfig(
      level=logging.INFO,
      format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
  )
  logger = logging.getLogger(__name__)
  

  @lru_cache(maxsize=1)

  def get_translation_service() -> TranslationService:

      return TranslationService(get_translation_config())

  
  
  # 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 _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)
      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,
              )
              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: %s", exc, exc_info=True)
              out = None
          results.append(out)
      return results
  
  
  @asynccontextmanager
  async def lifespan(_: FastAPI):
      """Warm the default backend on process startup."""
      logger.info("Starting Translation Service API")
      service = get_translation_service()
      default_backend = service.get_backend(service.config["default_model"])
      logger.info(
          "Translation service ready | default_model=%s available_models=%s loaded_models=%s",
          service.config["default_model"],
          service.available_models,
          service.loaded_models,
      )
      logger.info(
          "Default translation backend warmed up | model=%s",
          getattr(default_backend, "model", service.config["default_model"]),
      )
      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()

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

              "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,

          }
      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):

      _ensure_valid_text(request.text)
  

      if not request.target_lang:

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

      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
  

          if isinstance(raw_text, list):

              results = _translate_batch(
                  service,
                  raw_text,
                  target_lang=request.target_lang,
                  source_lang=request.source_lang,
                  model=model,
                  scene=scene,
              )

              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 = 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")

          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:
          raise

      except ValueError as e:
          raise HTTPException(status_code=400, detail=str(e)) from e

      except Exception as e:
          logger.error(f"Translation error: {e}", exc_info=True)

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

  
  
  @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
      )