#!/usr/bin/env python3
  """
  索引功能测试脚本。
  
  测试内容：
  1. 全量索引（SPUTransformer）
  2. 增量索引（IncrementalIndexerService）
  3. 租户配置加载
  4. 翻译功能集成（根据租户配置）
  5. 文档转换器功能
  """
  
  import sys
  import os
  from pathlib import Path
  
  # Add parent directory to path
  sys.path.insert(0, str(Path(__file__).parent.parent))
  
  from config import ConfigLoader
  from config.tenant_config_loader import get_tenant_config_loader
  from utils.db_connector import create_db_connection
  from indexer.spu_transformer import SPUTransformer
  from indexer.incremental_service import IncrementalIndexerService
  import logging
  
  # Configure logging
  logging.basicConfig(
      level=logging.INFO,
      format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
  )
  logger = logging.getLogger(__name__)
  
  
  def test_tenant_config():
      """测试租户配置加载"""
      print("\n" + "="*60)
      print("测试1: 租户配置加载")
      print("="*60)
      
      try:
          tenant_config_loader = get_tenant_config_loader()
          
          # 测试默认配置
          default_config = tenant_config_loader.get_tenant_config("999")
          print(f"默认配置: {default_config}")
          
          # 测试租户162（翻译关闭）
          tenant_162_config = tenant_config_loader.get_tenant_config("162")
          print(f"租户162配置: {tenant_162_config}")
          assert tenant_162_config['translate_to_en'] == False, "租户162翻译应该关闭"
          assert tenant_162_config['translate_to_zh'] == False, "租户162翻译应该关闭"
          print("✓ 租户162配置正确（翻译关闭）")
          
          # 测试其他租户
          tenant_1_config = tenant_config_loader.get_tenant_config("1")
          print(f"租户1配置: {tenant_1_config}")
          assert tenant_1_config['translate_to_en'] == True, "租户1应该启用英文翻译"
          print("✓ 租户1配置正确（翻译开启）")
          
          return True
      except Exception as e:
          print(f"✗ 租户配置测试失败: {e}")
          import traceback
          traceback.print_exc()
          return False
  
  
  def test_full_indexing(tenant_id: str = "162"):
      """测试全量索引"""
      print("\n" + "="*60)
      print(f"测试2: 全量索引（租户{tenant_id}）")
      print("="*60)
      
      # 获取数据库配置
      db_host = os.environ.get('DB_HOST')
      db_port = int(os.environ.get('DB_PORT', 3306))
      db_database = os.environ.get('DB_DATABASE')
      db_username = os.environ.get('DB_USERNAME')
      db_password = os.environ.get('DB_PASSWORD')
      
      if not all([db_host, db_database, db_username, db_password]):
          print("✗ 跳过：数据库配置不完整")
          print("  需要环境变量: DB_HOST, DB_DATABASE, DB_USERNAME, DB_PASSWORD")
          return False
      
      try:
          # 连接数据库
          db_engine = create_db_connection(
              host=db_host,
              port=db_port,
              database=db_database,
              username=db_username,
              password=db_password
          )
          print(f"✓ 数据库连接成功: {db_host}:{db_port}/{db_database}")
          
          # 创建转换器
          transformer = SPUTransformer(db_engine, tenant_id)
          print(f"✓ SPUTransformer初始化成功")
          
          # 转换数据（只转换前3个SPU用于测试）
          print(f"\n开始转换数据（租户{tenant_id}）...")
          documents = transformer.transform_batch()
          
          if not documents:
              print(f"⚠ 没有数据需要转换")
              return True
          
          print(f"✓ 转换完成: {len(documents)} 个文档")
          
          # 检查前3个文档
          for i, doc in enumerate(documents[:3]):
              print(f"\n文档 {i+1}:")
              print(f"  SPU ID: {doc.get('spu_id')}")
              print(f"  Tenant ID: {doc.get('tenant_id')}")
              print(f"  标题 (中文): {doc.get('title_zh', 'N/A')}")
              print(f"  标题 (英文): {doc.get('title_en', 'N/A')}")
              
              # 检查租户162的翻译状态
              if tenant_id == "162":
                  # 租户162翻译应该关闭，title_en应该为None
                  if doc.get('title_en') is None:
                      print(f"  ✓ 翻译已关闭（title_en为None）")
                  else:
                      print(f"  ⚠ 警告：翻译应该关闭，但title_en有值: {doc.get('title_en')}")
          
          return True
          
      except Exception as e:
          print(f"✗ 全量索引测试失败: {e}")
          import traceback
          traceback.print_exc()
          return False
  
  
  def test_incremental_indexing(tenant_id: str = "162"):
      """测试增量索引"""
      print("\n" + "="*60)
      print(f"测试3: 增量索引（租户{tenant_id}）")
      print("="*60)
      
      # 获取数据库配置
      db_host = os.environ.get('DB_HOST')
      db_port = int(os.environ.get('DB_PORT', 3306))
      db_database = os.environ.get('DB_DATABASE')
      db_username = os.environ.get('DB_USERNAME')
      db_password = os.environ.get('DB_PASSWORD')
      
      if not all([db_host, db_database, db_username, db_password]):
          print("✗ 跳过：数据库配置不完整")
          return False
      
      try:
          # 连接数据库
          db_engine = create_db_connection(
              host=db_host,
              port=db_port,
              database=db_database,
              username=db_username,
              password=db_password
          )
          
          # 创建增量服务
          service = IncrementalIndexerService(db_engine)
          print(f"✓ IncrementalIndexerService初始化成功")
          
          # 先查询一个SPU ID
          from sqlalchemy import text
          with db_engine.connect() as conn:
              query = text("""
                  SELECT id FROM shoplazza_product_spu
                  WHERE tenant_id = :tenant_id AND deleted = 0
                  LIMIT 1
              """)
              result = conn.execute(query, {"tenant_id": tenant_id})
              row = result.fetchone()
              if not row:
                  print(f"⚠ 租户{tenant_id}没有数据，跳过增量测试")
                  return True
              spu_id = str(row[0])
          
          print(f"\n测试SPU ID: {spu_id}")
          
          # 获取SPU文档
          doc = service.get_spu_document(tenant_id=tenant_id, spu_id=spu_id)
          
          if doc is None:
              print(f"✗ SPU {spu_id} 文档获取失败")
              return False
          
          print(f"✓ SPU文档获取成功")
          print(f"  SPU ID: {doc.get('spu_id')}")
          print(f"  Tenant ID: {doc.get('tenant_id')}")
          print(f"  标题 (中文): {doc.get('title_zh', 'N/A')}")
          print(f"  标题 (英文): {doc.get('title_en', 'N/A')}")
          print(f"  SKU数量: {len(doc.get('skus', []))}")
          print(f"  规格数量: {len(doc.get('specifications', []))}")
          
          # 检查租户162的翻译状态
          if tenant_id == "162":
              if doc.get('title_en') is None:
                  print(f"  ✓ 翻译已关闭（title_en为None）")
              else:
                  print(f"  ⚠ 警告：翻译应该关闭，但title_en有值: {doc.get('title_en')}")
          
          return True
          
      except Exception as e:
          print(f"✗ 增量索引测试失败: {e}")
          import traceback
          traceback.print_exc()
          return False
  
  
  def test_document_transformer():
      """测试文档转换器"""
      print("\n" + "="*60)
      print("测试4: 文档转换器")
      print("="*60)
      
      try:
          import pandas as pd
          from indexer.document_transformer import SPUDocumentTransformer
          from config import ConfigLoader
          
          config = ConfigLoader().load_config()
          
          # 创建模拟数据
          spu_row = pd.Series({
              'id': 123,
              'tenant_id': '162',
              'title': '测试商品',
              'brief': '测试简介',
              'description': '测试描述',
              'vendor': '测试品牌',
              'category': '测试类目',
              'category_id': 100,
              'category_level': 1,
              'fake_sales': 1000,
              'image_src': 'https://example.com/image.jpg',
              'tags': '测试,标签',
              'create_time': pd.Timestamp.now(),
              'update_time': pd.Timestamp.now()
          })
          
          skus_df = pd.DataFrame([{
              'id': 456,
              'price': 99.99,
              'compare_at_price': 149.99,
              'sku': 'SKU001',
              'inventory_quantity': 100,
              'option1': '黑色',
              'option2': None,
              'option3': None
          }])
          
          options_df = pd.DataFrame([{
              'id': 1,
              'position': 1,
              'name': '颜色'
          }])
          
          # 获取租户配置
          tenant_config_loader = get_tenant_config_loader()
          tenant_config = tenant_config_loader.get_tenant_config('162')
          
          # 初始化翻译器（如果启用）
          translator = None
          if config.query_config.enable_translation:
              from query.translator import Translator
              translator = Translator(
                  api_key=config.query_config.translation_api_key,
                  use_cache=True
              )
          
          # 创建转换器
          transformer = SPUDocumentTransformer(
              category_id_to_name={},
              searchable_option_dimensions=['option1', 'option2', 'option3'],
              tenant_config=tenant_config,
              translator=translator,
              translation_prompts=config.query_config.translation_prompts
          )
          
          # 转换文档
          doc = transformer.transform_spu_to_doc(
              tenant_id='162',
              spu_row=spu_row,
              skus=skus_df,
              options=options_df
          )
          
          if doc:
              print(f"✓ 文档转换成功")
              print(f"  title_zh: {doc.get('title_zh')}")
              print(f"  title_en: {doc.get('title_en')}")
              print(f"  SKU数量: {len(doc.get('skus', []))}")
              
              # 验证租户162翻译关闭
              if doc.get('title_en') is None:
                  print(f"  ✓ 翻译已关闭（符合租户162配置）")
              else:
                  print(f"  ⚠ 警告：翻译应该关闭")
              
              return True
          else:
              print(f"✗ 文档转换失败")
              return False
          
      except Exception as e:
          print(f"✗ 文档转换器测试失败: {e}")
          import traceback
          traceback.print_exc()
          return False
  
  
  def main():
      """主测试函数"""
      print("="*60)
      print("索引功能完整测试")
      print("="*60)
      
      results = []
      
      # 测试1: 租户配置
      results.append(("租户配置加载", test_tenant_config()))
      
      # 测试2: 全量索引（租户162）
      results.append(("全量索引（租户162）", test_full_indexing("162")))
      
      # 测试3: 增量索引（租户162）
      results.append(("增量索引（租户162）", test_incremental_indexing("162")))
      
      # 测试4: 文档转换器
      results.append(("文档转换器", test_document_transformer()))
      
      # 总结
      print("\n" + "="*60)
      print("测试总结")
      print("="*60)
      
      passed = sum(1 for _, result in results if result)
      total = len(results)
      
      for name, result in results:
          status = "✓ 通过" if result else "✗ 失败"
          print(f"{status}: {name}")
      
      print(f"\n总计: {passed}/{total} 通过")
      
      if passed == total:
          print("✓ 所有测试通过")
          return 0
      else:
          print("✗ 部分测试失败")
          return 1
  
  
  if __name__ == '__main__':
      sys.exit(main())