"""
  Test script for cloud text embedding using Aliyun DashScope API.
  
  Reads queries from queries.txt and tests embedding generation,
  logging send time, receive time, and duration for each request.
  """
  
  import os
  import sys
  import time
  from datetime import datetime
  from pathlib import Path
  
  # Add parent directory to path
  sys.path.insert(0, str(Path(__file__).parent.parent))
  
  from embeddings.cloud_text_encoder import CloudTextEncoder
  
  
  def format_timestamp(ts: float) -> str:
      """Format timestamp to readable string."""
      return datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
  
  
  def read_queries(file_path: str, limit: int = 100) -> list:
      """
      Read queries from text file.
      
      Args:
          file_path: Path to queries file
          limit: Maximum number of queries to read
          
      Returns:
          List of query strings
      """
      queries = []
      with open(file_path, 'r', encoding='utf-8') as f:
          for i, line in enumerate(f):
              if i >= limit:
                  break
              query = line.strip()
              if query:  # Skip empty lines
                  queries.append(query)
      return queries
  
  
  def test_cloud_embedding(queries_file: str, num_queries: int = 100):
      """
      Test cloud embedding with queries from file.
      
      Args:
          queries_file: Path to queries file
          num_queries: Number of queries to test
      """
      print("=" * 80)
      print("Cloud Text Embedding Test - Aliyun DashScope API")
      print("=" * 80)
      print()
      
      # Check if API key is set
      api_key = os.getenv("DASHSCOPE_API_KEY")
      if not api_key:
          print("ERROR: DASHSCOPE_API_KEY environment variable is not set!")
          print("Please set it using: export DASHSCOPE_API_KEY='your-api-key'")
          return
      
      print(f"API Key: {api_key[:10]}...{api_key[-4:]}")
      print()
      
      # Read queries
      print(f"Reading queries from: {queries_file}")
      try:
          queries = read_queries(queries_file, limit=num_queries)
          print(f"Successfully read {len(queries)} queries")
          print()
      except Exception as e:
          print(f"ERROR: Failed to read queries file: {e}")
          return
      
      # Initialize encoder
      print("Initializing CloudTextEncoder...")
      try:
          encoder = CloudTextEncoder()
          print("CloudTextEncoder initialized successfully")
          print()
      except Exception as e:
          print(f"ERROR: Failed to initialize encoder: {e}")
          return
      
      # Test embeddings
      print("=" * 80)
      print(f"Testing {len(queries)} queries (one by one)")
      print("=" * 80)
      print()
      
      total_start = time.time()
      success_count = 0
      failure_count = 0
      total_duration = 0.0
      
      for i, query in enumerate(queries, 1):
          try:
              # Record send time
              send_time = time.time()
              send_time_str = format_timestamp(send_time)
              
              # Generate embedding
              embedding = encoder.encode(query)
              
              # Record receive time
              receive_time = time.time()
              receive_time_str = format_timestamp(receive_time)
              
              # Calculate duration
              duration = receive_time - send_time
              total_duration += duration
              
              # Verify embedding
              if embedding.shape[0] > 0:
                  success_count += 1
                  status = "✓ SUCCESS"
              else:
                  failure_count += 1
                  status = "✗ FAILED"
              
              # Print result
              query_display = query[:50] + "..." if len(query) > 50 else query
              print(f"[{i:3d}/{len(queries)}] {status}")
              print(f"  Query: {query_display}")
              print(f"  Send Time:    {send_time_str}")
              print(f"  Receive Time: {receive_time_str}")
              print(f"  Duration:     {duration:.3f}s")
              print(f"  Embedding Shape: {embedding.shape}")
              print()
              
          except Exception as e:
              failure_count += 1
              receive_time = time.time()
              duration = receive_time - send_time
              
              print(f"[{i:3d}/{len(queries)}] ✗ ERROR")
              print(f"  Query: {query[:50]}...")
              print(f"  Send Time:    {send_time_str}")
              print(f"  Receive Time: {format_timestamp(receive_time)}")
              print(f"  Duration:     {duration:.3f}s")
              print(f"  Error: {str(e)}")
              print()
      
      # Print summary
      total_elapsed = time.time() - total_start
      avg_duration = total_duration / len(queries) if queries else 0
      
      print("=" * 80)
      print("Test Summary")
      print("=" * 80)
      print(f"Total Queries:     {len(queries)}")
      print(f"Successful:        {success_count}")
      print(f"Failed:            {failure_count}")
      print(f"Success Rate:      {success_count / len(queries) * 100:.1f}%")
      print(f"Total Time:        {total_elapsed:.3f}s")
      print(f"Total API Time:    {total_duration:.3f}s")
      print(f"Average Duration:  {avg_duration:.3f}s per query")
      print(f"Throughput:        {len(queries) / total_elapsed:.2f} queries/second")
      print("=" * 80)
  
  
  def main():
      """Main entry point."""
      # Default queries file path
      queries_file = Path(__file__).parent.parent / "data_crawling" / "queries.txt"
      
      # Check if file exists
      if not queries_file.exists():
          print(f"ERROR: Queries file not found: {queries_file}")
          return
      
      # Run test with 100 queries
      test_cloud_embedding(str(queries_file), num_queries=100)
  
  
  if __name__ == "__main__":
      main()