"""
  FastAPI application dedicated to indexing (separate from search API).
  
  This service mounts ONLY ONE copy of indexer routes: api/routes/indexer.py
  and injects required services via api/service_registry.py.
  
  Usage:
      uvicorn api.indexer_app:app --host 0.0.0.0 --port 6004 --reload
  
  This service only exposes /indexer/* routes and can be run in a separate
  process so that heavy indexing work does not block online search traffic.
  """
  
  import os
  import sys
  import logging
  import time
  from typing import Optional
  
  from fastapi import FastAPI, Request
  from fastapi.responses import JSONResponse
  
  # Configure logging
  import pathlib
  
  log_dir = pathlib.Path("logs")
  log_dir.mkdir(exist_ok=True)
  logging.basicConfig(
      level=logging.INFO,
      format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
      handlers=[
          logging.StreamHandler(),
          logging.FileHandler(log_dir / "indexer_api.log", mode="a", encoding="utf-8"),
      ],
  )
  logger = logging.getLogger(__name__)
  
  # Add parent directory to path
  sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
  
  from config.env_config import ES_CONFIG  # noqa: E402
  from config import ConfigLoader  # noqa: E402
  from utils import ESClient  # noqa: E402
  from utils.db_connector import create_db_connection  # noqa: E402
  from indexer.incremental_service import IncrementalIndexerService  # noqa: E402
  from indexer.bulk_indexing_service import BulkIndexingService  # noqa: E402
  from .routes import indexer as indexer_routes  # noqa: E402
  from .service_registry import set_es_client, set_indexer_services  # noqa: E402
  
  
  _es_client: Optional[ESClient] = None
  _config = None
  _incremental_service: Optional[IncrementalIndexerService] = None
  _bulk_indexing_service: Optional[BulkIndexingService] = None
  
  
  def init_indexer_service(es_host: str = "http://localhost:9200"):
      """
      Initialize indexing services (ES client + DB + indexers).
  
      This mirrors the indexing-related initialization logic in api.app.init_service
      but without search-related components.
      """
      global _es_client, _config, _incremental_service, _bulk_indexing_service
  
      start_time = time.time()
      logger.info("Initializing Indexer service")
  
      # Load configuration (kept for parity/logging; indexer routes don't depend on it)
      logger.info("Loading configuration...")
      config_loader = ConfigLoader("config/config.yaml")
      _config = config_loader.load_config()
      logger.info("Configuration loaded")
  
      # Get ES credentials
      es_username = os.getenv("ES_USERNAME") or ES_CONFIG.get("username")
      es_password = os.getenv("ES_PASSWORD") or ES_CONFIG.get("password")
  
      # Connect to Elasticsearch
      logger.info(f"Connecting to Elasticsearch at {es_host} for indexer...")
      if es_username and es_password:
          _es_client = ESClient(hosts=[es_host], username=es_username, password=es_password)
      else:
          _es_client = ESClient(hosts=[es_host])
  
      if not _es_client.ping():
          raise ConnectionError(f"Failed to connect to Elasticsearch at {es_host}")
      logger.info("Elasticsearch connected for indexer")
      # publish ES client for routes
      set_es_client(_es_client)
  
      # Initialize indexing services (DB is required here)
      db_host = os.getenv("DB_HOST")
      db_port = int(os.getenv("DB_PORT", 3306))
      db_database = os.getenv("DB_DATABASE")
      db_username = os.getenv("DB_USERNAME")
      db_password = os.getenv("DB_PASSWORD")
  
      if all([db_host, db_database, db_username, db_password]):
          logger.info("Initializing database connection for indexing services...")
          db_engine = create_db_connection(
              host=db_host,
              port=db_port,
              database=db_database,
              username=db_username,
              password=db_password,
          )
  
          _incremental_service = IncrementalIndexerService(db_engine)
          _bulk_indexing_service = BulkIndexingService(db_engine, _es_client)
          set_indexer_services(
              incremental_service=_incremental_service,
              bulk_indexing_service=_bulk_indexing_service,
          )
          logger.info("Indexer services initialized (incremental + bulk)")
      else:
          missing = [
              name
              for name, value in [
                  ("DB_HOST", db_host),
                  ("DB_DATABASE", db_database),
                  ("DB_USERNAME", db_username),
                  ("DB_PASSWORD", db_password),
              ]
              if not value
          ]
          logger.warning(
              "Database config incomplete for indexer, services will not be available. "
              f"Missing: {', '.join(missing)}"
          )
          _incremental_service = None
          _bulk_indexing_service = None
  
      elapsed = time.time() - start_time
      logger.info(f"Indexer service ready! (took {elapsed:.2f}s)")
  
      # NOTE: we intentionally do NOT synchronize anything into api.app
      # to avoid code/route duplication and accidental availability on port 6002.
  
  
  app = FastAPI(
      title="E-Commerce Indexer API",
      description="Dedicated indexing service for SearchEngine",
      version="1.0.0",
      docs_url="/docs",
      redoc_url="/redoc",
      openapi_url="/openapi.json",
  )
  
  
  @app.on_event("startup")
  async def startup_event():

      # Configure thread pool size for uvicorn (default is 40, set to 48)
      try:
          import anyio.to_thread
          limiter = anyio.to_thread.current_default_thread_limiter()
          limiter.total_tokens = 48
          logger.info(f"Thread pool size set to {limiter.total_tokens}")
      except Exception as e:
          logger.warning(f"Failed to set thread pool size: {e}, using default")
      

      es_host = os.getenv("ES_HOST", "http://localhost:9200")
      logger.info("Starting Indexer API service")
      logger.info(f"Elasticsearch Host: {es_host}")
      try:
          init_indexer_service(es_host=es_host)
          logger.info("Indexer service initialized successfully")
      except Exception as e:
          logger.error(f"Failed to initialize indexer service: {e}", exc_info=True)
          logger.warning("Indexer service will start but may not function correctly")
  
  
  @app.on_event("shutdown")
  async def shutdown_event():
      logger.info("Shutting down Indexer API service")
  
  
  @app.exception_handler(Exception)
  async def global_exception_handler(request: Request, exc: Exception):
      """Global exception handler with basic logging."""
      client_ip = request.client.host if request.client else "unknown"
      logger.error(f"Unhandled exception from {client_ip}: {exc}", exc_info=True)
  
      return JSONResponse(
          status_code=500,
          content={
              "error": "Internal server error",
              "detail": "An unexpected error occurred in indexer service.",
              "timestamp": int(time.time()),
          },
      )
  
  
  @app.get("/health")
  async def health_check():
      """Simple health check for indexer service."""
      try:
          # ensure ES is reachable (best-effort)
          if _es_client is None:
              raise RuntimeError("ES client is not initialized")
          return {
              "status": "healthy",
              "services": {
                  "elasticsearch": "connected",
                  "incremental_indexer": "initialized" if _incremental_service else "unavailable",
                  "bulk_indexer": "initialized" if _bulk_indexing_service else "unavailable",
              },
              "timestamp": int(time.time()),
          }
      except Exception as e:
          logger.error(f"Indexer health check failed: {e}")
          return JSONResponse(
              status_code=503,
              content={
                  "status": "unhealthy",
                  "error": str(e),
                  "timestamp": int(time.time()),
              },
          )
  
  
  # Mount the single source of truth indexer routes
  app.include_router(indexer_routes.router)
  
  
  if __name__ == "__main__":
      import argparse
      import uvicorn
  
      parser = argparse.ArgumentParser(description="Start Indexer API service")
      parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
      parser.add_argument("--port", type=int, default=6004, help="Port to bind to")
      parser.add_argument("--es-host", default="http://localhost:9200", help="Elasticsearch host")
      parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
      args = parser.parse_args()
  
      os.environ["ES_HOST"] = args.es_host
  
      uvicorn.run(
          "api.indexer_app:app",
          host=args.host,
          port=args.port,
          reload=args.reload,
      )