#!/usr/bin/env python3
  """
  Shoplazza data ingestion script.
  
  Loads SPU and SKU data from MySQL and indexes into Elasticsearch using SPU transformer.
  """
  
  import sys
  import os
  import argparse
  from pathlib import Path
  
  # Add parent directory to path
  sys.path.insert(0, str(Path(__file__).parent.parent))
  
  from utils.db_connector import create_db_connection
  from utils.es_client import ESClient
  from indexer.spu_transformer import SPUTransformer

  from indexer.mapping_generator import load_mapping, DEFAULT_INDEX_NAME

  from indexer.bulk_indexer import BulkIndexer

  
  
  def main():
      parser = argparse.ArgumentParser(description='Ingest Shoplazza SPU/SKU data into Elasticsearch')
      
      # Database connection
      parser.add_argument('--db-host', required=True, help='MySQL host')
      parser.add_argument('--db-port', type=int, default=3306, help='MySQL port (default: 3306)')
      parser.add_argument('--db-database', required=True, help='MySQL database name')
      parser.add_argument('--db-username', required=True, help='MySQL username')
      parser.add_argument('--db-password', required=True, help='MySQL password')
      
      # Tenant and index
      parser.add_argument('--tenant-id', required=True, help='Tenant ID (required)')

      parser.add_argument('--es-host', default='http://localhost:9200', help='Elasticsearch host')
      
      # Options
      parser.add_argument('--recreate', action='store_true', help='Recreate index if exists')
      parser.add_argument('--batch-size', type=int, default=500, help='Batch size for indexing (default: 500)')
      
      args = parser.parse_args()
  
      print(f"Starting Shoplazza data ingestion for tenant: {args.tenant_id}")
  

      # Load mapping from JSON file

      try:

          mapping = load_mapping()
          print(f"Loaded mapping configuration")

      except Exception as e:

          print(f"ERROR: Failed to load mapping: {e}")

          return 1
  

      index_name = DEFAULT_INDEX_NAME

  
      # Connect to MySQL
      print(f"Connecting to MySQL: {args.db_host}:{args.db_port}/{args.db_database}")
      try:
          db_engine = create_db_connection(
              host=args.db_host,
              port=args.db_port,
              database=args.db_database,
              username=args.db_username,
              password=args.db_password
          )
      except Exception as e:
          print(f"ERROR: Failed to connect to MySQL: {e}")
          return 1
  

      # Connect to Elasticsearch
      es_host = args.es_host
      es_username = os.environ.get('ES_USERNAME')
      es_password = os.environ.get('ES_PASSWORD')

      
      print(f"Connecting to Elasticsearch: {es_host}")
      if es_username and es_password:
          print(f"Using authentication: {es_username}")
          es_client = ESClient(hosts=[es_host], username=es_username, password=es_password)
      else:
          es_client = ESClient(hosts=[es_host])
      

      if not es_client.ping():

          print(f"ERROR: Cannot connect to Elasticsearch at {es_host}")

          return 1
  

      # Create index if needed

      if args.recreate:
          if es_client.index_exists(index_name):
              print(f"Deleting existing index: {index_name}")

              if not es_client.delete_index(index_name):
                  print(f"ERROR: Failed to delete index '{index_name}'")
                  return 1

  
      if not es_client.index_exists(index_name):
          print(f"Creating index: {index_name}")

          if not es_client.create_index(index_name, mapping):
              print(f"ERROR: Failed to create index '{index_name}'")
              print("Please check the mapping configuration and try again.")
              return 1

      else:
          print(f"Using existing index: {index_name}")
  
      # Initialize SPU transformer
      print(f"Initializing SPU transformer for tenant: {args.tenant_id}")
      transformer = SPUTransformer(db_engine, args.tenant_id)
  
      # Transform data
      print("Transforming SPU and SKU data...")
      try:
          documents = transformer.transform_batch()
          print(f"Transformed {len(documents)} SPU documents")
      except Exception as e:
          print(f"ERROR: Failed to transform data: {e}")
          import traceback
          traceback.print_exc()
          return 1
  
      if not documents:
          print("WARNING: No documents to index")
          return 0
  
      # Bulk index
      print(f"Indexing {len(documents)} documents (batch size: {args.batch_size})...")
      indexer = BulkIndexer(es_client, index_name, batch_size=args.batch_size)
      
      try:

          results = indexer.index_documents(documents, id_field="spu_id", show_progress=True)

          print(f"\nIngestion complete:")
          print(f"  Success: {results['success']}")
          print(f"  Failed: {results['failed']}")
          print(f"  Time: {results.get('elapsed_time', 0):.2f}s")
          
          if results['failed'] > 0:
              print(f"\nWARNING: {results['failed']} documents failed to index")
              return 1
          
          return 0
      except Exception as e:
          print(f"ERROR: Failed to index documents: {e}")
          import traceback
          traceback.print_exc()
          return 1
  
  
  if __name__ == '__main__':
      sys.exit(main())