"""
  
  # 方式1：直接运行
  python api/translator_app.py
  
  # 方式2：使用 uvicorn
  uvicorn api.translator_app:app --host 0.0.0.0 --port 6006 --reload
  
  
  使用说明：
  Translation HTTP Service
  
  This service provides a RESTful API for text translation using DeepL API.
  The service runs on port 6006 and provides a simple translation endpoint.
  
  API Endpoint:
      POST /translate
  
  Request Body (JSON):
      {
          "text": "要翻译的文本",
          "target_lang": "en",  # Required: target language code (zh, en, ru, etc.)
          "source_lang": "zh"   # Optional: source language code (auto-detect if not provided)
      }
  
  Response (JSON):
      {
          "text": "要翻译的文本",
          "target_lang": "en",
          "source_lang": "zh",
          "translated_text": "Text to translate",
          "status": "success"
      }
  
  Usage Examples:
  
  1. Translate Chinese to English:
     curl -X POST http://localhost:6006/translate \
       -H "Content-Type: application/json" \
       -d '{
         "text": "商品名称",
         "target_lang": "en",
         "source_lang": "zh"
       }'
  
  2. Translate with auto-detection:
     curl -X POST http://localhost:6006/translate \
       -H "Content-Type: application/json" \
       -d '{
         "text": "Product name",
         "target_lang": "zh"
       }'
  
  3. Translate Russian to English:
     curl -X POST http://localhost:6006/translate \
       -H "Content-Type: application/json" \
       -d '{
         "text": "Название товара",
         "target_lang": "en",
         "source_lang": "ru"
       }'
  
  Health Check:
      GET /health
  
      curl http://localhost:6006/health
  
  Start the service:
      python api/translator_app.py
      # or
      uvicorn api.translator_app:app --host 0.0.0.0 --port 6006 --reload
  """
  
  import os
  import sys
  import logging
  import argparse
  import uvicorn
  from typing import Optional
  from fastapi import FastAPI, HTTPException
  from fastapi.responses import JSONResponse
  from fastapi.middleware.cors import CORSMiddleware
  from pydantic import BaseModel, Field
  
  # Add parent directory to path
  sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
  
  from query.translator import Translator
  from config.env_config import DEEPL_AUTH_KEY, REDIS_CONFIG
  
  # Configure logging
  logging.basicConfig(
      level=logging.INFO,
      format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
  )
  logger = logging.getLogger(__name__)
  
  # Fixed translation prompt
  TRANSLATION_PROMPT = "Translate the original text into an English product SKU name. Requirements: Ensure accurate and complete transmission of the original information, with concise, clear, authentic, and professional language."
  
  # Global translator instance
  _translator: Optional[Translator] = None
  
  
  def init_translator():
      """Initialize translator instance."""
      global _translator
      if _translator is None:
          logger.info("Initializing translator...")
          _translator = Translator(
              api_key=DEEPL_AUTH_KEY,
              use_cache=True,
              timeout=10
          )
          logger.info("Translator initialized")
      return _translator
  
  
  # Request/Response models
  class TranslationRequest(BaseModel):
      """Translation request model."""
      text: str = Field(..., description="Text to translate")
      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)")
  
      class Config:
          json_schema_extra = {
              "example": {
                  "text": "商品名称",
                  "target_lang": "en",
                  "source_lang": "zh"
              }
          }
  
  
  class TranslationResponse(BaseModel):
      """Translation response model."""
      text: str = Field(..., description="Original text")
      target_lang: str = Field(..., description="Target language code")
      source_lang: Optional[str] = Field(None, description="Source language code (detected or provided)")
      translated_text: str = Field(..., description="Translated text")
      status: str = Field(..., description="Translation status")
  
  
  # Create FastAPI app
  app = FastAPI(
      title="Translation Service API",
      description="RESTful API for text translation using DeepL",
      version="1.0.0",
      docs_url="/docs",
      redoc_url="/redoc"
  )
  
  # Add CORS middleware
  app.add_middleware(
      CORSMiddleware,
      allow_origins=["*"],
      allow_credentials=True,
      allow_methods=["*"],
      allow_headers=["*"],
  )
  
  
  @app.on_event("startup")
  async def startup_event():
      """Initialize translator on startup."""
      logger.info("Starting Translation Service API on port 6006")
      try:
          init_translator()
          logger.info("Translation service ready")
      except Exception as e:
          logger.error(f"Failed to initialize translator: {e}", exc_info=True)
          logger.warning("Service will start but translation may not work correctly")
  
  
  @app.get("/health")
  async def health_check():
      """Health check endpoint."""
      try:
          translator = init_translator()
          return {
              "status": "healthy",
              "service": "translation",
              "translator_initialized": translator is not None,
              "cache_enabled": translator.use_cache if translator else False
          }
      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):
      """
      Translate text to target language.
      
      Uses a fixed prompt optimized for product SKU name translation.
      The translation is cached in Redis for performance.
      """
      if not request.text or not request.text.strip():
          raise HTTPException(
              status_code=400,
              detail="Text cannot be empty"
          )
      
      if not request.target_lang:
          raise HTTPException(
              status_code=400,
              detail="target_lang is required"
          )
      
      try:
          translator = init_translator()
          
          # Translate using the fixed prompt
          translated_text = translator.translate(
              text=request.text,
              target_lang=request.target_lang,
              source_lang=request.source_lang,
              prompt=TRANSLATION_PROMPT
          )
          
          if translated_text is None:
              raise HTTPException(
                  status_code=500,
                  detail="Translation failed"
              )
          
          return TranslationResponse(
              text=request.text,
              target_lang=request.target_lang,
              source_lang=request.source_lang,
              translated_text=translated_text,
              status="success"
          )
      
      except HTTPException:
          raise
      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
      )