"""
  全量索引服务。
  
  提供全量索引功能，将指定租户的所有SPU数据导入到ES。
  """
  
  import logging
  from typing import Dict, Any
  from sqlalchemy import Engine
  from utils.es_client import ESClient
  from indexer.spu_transformer import SPUTransformer
  from indexer.bulk_indexer import BulkIndexer
  from indexer.mapping_generator import load_mapping, delete_index_if_exists, DEFAULT_INDEX_NAME

  from indexer.indexer_logger import (
      get_indexer_logger, log_index_request, log_index_result, log_bulk_index_batch
  )

  
  logger = logging.getLogger(__name__)

  # Indexer专用日志器
  indexer_logger = get_indexer_logger()

  
  
  class BulkIndexingService:
      """全量索引服务，提供批量导入功能。"""
  
      def __init__(self, db_engine: Engine, es_client: ESClient):
          """
          初始化全量索引服务。
  
          Args:
              db_engine: SQLAlchemy database engine
              es_client: Elasticsearch client
          """
          self.db_engine = db_engine
          self.es_client = es_client
          self.index_name = DEFAULT_INDEX_NAME
  
      def bulk_index(self, tenant_id: str, recreate_index: bool = False, batch_size: int = 500) -> Dict[str, Any]:
          """执行全量索引"""
          import time
          start_time = time.time()
  

          # 记录请求开始
          log_index_request(
              indexer_logger,
              index_type='bulk',
              tenant_id=tenant_id,
              request_params={
                  'recreate_index': recreate_index,
                  'batch_size': batch_size,
                  'index_name': self.index_name
              }
          )
  

          try:
              # 1. 加载mapping
              logger.info(f"[BulkIndexing] Loading mapping for tenant_id={tenant_id}")

              indexer_logger.info(
                  f"Loading mapping for bulk index",
                  extra={
                      'index_type': 'bulk',
                      'tenant_id': tenant_id,
                      'operation': 'load_mapping',
                      'index_name': self.index_name
                  }
              )

              mapping = load_mapping()
  
              # 2. 处理索引（删除并重建或创建）
              if recreate_index:
                  logger.info(f"[BulkIndexing] Recreating index: {self.index_name}")

                  indexer_logger.info(
                      f"Recreating index: {self.index_name}",
                      extra={
                          'index_type': 'bulk',
                          'tenant_id': tenant_id,
                          'operation': 'recreate_index',
                          'index_name': self.index_name
                      }
                  )

                  if self.es_client.index_exists(self.index_name):
                      if delete_index_if_exists(self.es_client, self.index_name):
                          logger.info(f"[BulkIndexing] Deleted existing index: {self.index_name}")
                      else:
                          raise Exception(f"Failed to delete index: {self.index_name}")
  
              if not self.es_client.index_exists(self.index_name):
                  logger.info(f"[BulkIndexing] Creating index: {self.index_name}")

                  indexer_logger.info(
                      f"Creating index: {self.index_name}",
                      extra={
                          'index_type': 'bulk',
                          'tenant_id': tenant_id,
                          'operation': 'create_index',
                          'index_name': self.index_name
                      }
                  )

                  if not self.es_client.create_index(self.index_name, mapping):
                      raise Exception(f"Failed to create index: {self.index_name}")
                  logger.info(f"[BulkIndexing] Created index: {self.index_name}")
              else:
                  logger.info(f"[BulkIndexing] Index already exists: {self.index_name}")
  
              # 3. 转换数据
              logger.info(f"[BulkIndexing] Transforming data for tenant_id={tenant_id}")

              indexer_logger.info(
                  f"Transforming SPU data",
                  extra={
                      'index_type': 'bulk',
                      'tenant_id': tenant_id,
                      'operation': 'transform_data',
                      'index_name': self.index_name
                  }
              )

              transformer = SPUTransformer(self.db_engine, tenant_id)
              documents = transformer.transform_batch()
  
              if not documents:
                  logger.warning(f"[BulkIndexing] No documents to index for tenant_id={tenant_id}")

                  elapsed_time = time.time() - start_time
                  log_index_result(
                      indexer_logger,
                      index_type='bulk',
                      tenant_id=tenant_id,
                      total_count=0,
                      success_count=0,
                      failed_count=0,
                      elapsed_time=elapsed_time,
                      index_name=self.index_name
                  )

                  return {
                      "success": True,
                      "total": 0,
                      "indexed": 0,
                      "failed": 0,

                      "elapsed_time": elapsed_time,
                      "message": "No documents to index",
                      "index_name": self.index_name,
                      "tenant_id": tenant_id

                  }
  
              logger.info(f"[BulkIndexing] Transformed {len(documents)} documents")

              indexer_logger.info(
                  f"Transformed {len(documents)} documents",
                  extra={
                      'index_type': 'bulk',
                      'tenant_id': tenant_id,
                      'operation': 'transform_complete',
                      'total_count': len(documents),
                      'index_name': self.index_name
                  }
              )

  
              # 4. 批量导入
              logger.info(f"[BulkIndexing] Indexing {len(documents)} documents (batch_size={batch_size})")

              indexer = BulkIndexer(self.es_client, self.index_name, batch_size=batch_size, max_retries=3)

              results = indexer.index_documents(
                  documents,
                  id_field="spu_id",
                  show_progress=False  # API调用时不打印进度
              )
  
              elapsed_time = time.time() - start_time
  

              # 记录最终结果
              log_index_result(
                  indexer_logger,
                  index_type='bulk',
                  tenant_id=tenant_id,
                  total_count=len(documents),
                  success_count=results['success'],
                  failed_count=results['failed'],
                  elapsed_time=elapsed_time,
                  index_name=self.index_name,
                  errors=results.get('errors', [])
              )
  

              logger.info(
                  f"[BulkIndexing] Completed for tenant_id={tenant_id}: "
                  f"indexed={results['success']}, failed={results['failed']}, "
                  f"elapsed={elapsed_time:.2f}s"
              )
  
              return {
                  "success": results['failed'] == 0,
                  "total": len(documents),
                  "indexed": results['success'],
                  "failed": results['failed'],
                  "elapsed_time": elapsed_time,
                  "index_name": self.index_name,
                  "tenant_id": tenant_id
              }
  
          except Exception as e:

              elapsed_time = time.time() - start_time
              error_msg = str(e)

              logger.error(f"[BulkIndexing] Failed for tenant_id={tenant_id}: {e}", exc_info=True)

              indexer_logger.error(
                  f"Bulk index failed: {error_msg}",
                  extra={
                      'index_type': 'bulk',
                      'tenant_id': tenant_id,
                      'operation': 'request_failed',
                      'error': error_msg,
                      'elapsed_time': elapsed_time,
                      'index_name': self.index_name
                  },
                  exc_info=True
              )

              raise