#!/usr/bin/env python3
  """

  Main entry point for saas-search operations.

  
  Provides a unified CLI for common operations:

  - serve: Start API service (search + admin routes)
  - serve-indexer: Start dedicated Indexer API service

  - search: Test search from command line
  """
  
  import sys
  import os
  import argparse
  import json

  
  # Add parent directory to path
  sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
  

  from config import ConfigLoader

  from config.env_config import ES_CONFIG

  from utils import ESClient

  from search import Searcher

  from suggestion import SuggestionIndexBuilder
  from utils.db_connector import create_db_connection

  from context.request_context import create_request_context

  def cmd_serve(args):
      """Start API service."""

      import uvicorn

      os.environ['ES_HOST'] = args.es_host
  

      print("Starting API service (multi-tenant)...")

      print(f"  Host: {args.host}:{args.port} (search + admin routes)")

      print(f"  Elasticsearch: {args.es_host}")
  
      uvicorn.run(
          "api.app:app",
          host=args.host,
          port=args.port,
          reload=args.reload
      )
  
  

  def cmd_serve_indexer(args):
      """Start dedicated Indexer API service (no search endpoints)."""

      import uvicorn

      os.environ['ES_HOST'] = args.es_host
  
      print("Starting Indexer API service...")
      print(f"  Host: {args.host}:{args.port} (indexer only)")
      print(f"  Elasticsearch: {args.es_host}")
  
      uvicorn.run(
          "api.indexer_app:app",
          host=args.host,
          port=args.port,
          reload=args.reload
      )
  

  def cmd_search(args):
      """Test search from command line."""

      # Load config

      config_loader = ConfigLoader("config/config.yaml")
      config = config_loader.load_config()

  
      # Initialize ES and searcher
      es_client = ESClient(hosts=[args.es_host])
      if not es_client.ping():
          print(f"ERROR: Cannot connect to Elasticsearch at {args.es_host}")
          return 1
  

      from query import QueryParser
      query_parser = QueryParser(config)

      searcher = Searcher(es_client, config, query_parser)

  
      # Execute search

      print(f"Searching for: '{args.query}' (tenant: {args.tenant_id})")

      result = searcher.search(
          query=args.query,

          tenant_id=args.tenant_id,

          size=args.size,
          context=create_request_context(),

      )
  
      # Display results
      print(f"\nFound {result.total} results in {result.took_ms}ms")
      print(f"Max score: {result.max_score}")
  
      if args.json:
          print(json.dumps(result.to_dict(), indent=2, ensure_ascii=False))
      else:
          print(f"\nTop {len(result.hits)} results:")
          for i, hit in enumerate(result.hits, 1):
              source = hit['_source']
              score = hit['_score']
              print(f"\n{i}. Score: {score:.4f}")
              print(f"   ID: {source.get('skuId', 'N/A')}")
              print(f"   Name: {source.get('name', 'N/A')}")
              print(f"   Category: {source.get('categoryName', 'N/A')}")
              print(f"   Brand: {source.get('brandName', 'N/A')}")
  
      return 0
  
  

  def cmd_build_suggestions(args):

      """Build/update suggestion index for a tenant."""

      # Initialize ES client with optional authentication
      es_username = os.getenv("ES_USERNAME") or ES_CONFIG.get("username")
      es_password = os.getenv("ES_PASSWORD") or ES_CONFIG.get("password")
      if es_username and es_password:
          es_client = ESClient(hosts=[args.es_host], username=es_username, password=es_password)
      else:
          es_client = ESClient(hosts=[args.es_host])

      if not es_client.ping():
          print(f"ERROR: Cannot connect to Elasticsearch at {args.es_host}")
          return 1
  

      # Build DB config directly from environment to avoid dotenv dependency
      db_host = os.getenv("DB_HOST")
      db_port = int(os.getenv("DB_PORT", "3306"))
      db_name = os.getenv("DB_DATABASE")
      db_user = os.getenv("DB_USERNAME")
      db_pass = os.getenv("DB_PASSWORD")
      if not all([db_host, db_name, db_user, db_pass]):
          print("ERROR: DB_HOST/DB_PORT/DB_DATABASE/DB_USERNAME/DB_PASSWORD must be set in environment")
          return 1
  

      db_engine = create_db_connection(

          host=db_host,
          port=db_port,
          database=db_name,
          username=db_user,
          password=db_pass,

      )
      builder = SuggestionIndexBuilder(es_client=es_client, db_engine=db_engine)

      if args.mode == "full":
          result = builder.rebuild_tenant_index(
              tenant_id=args.tenant_id,
              days=args.days,

              batch_size=args.batch_size,
              min_query_len=args.min_query_len,
              publish_alias=args.publish_alias,
              keep_versions=args.keep_versions,

          )
      else:
          result = builder.incremental_update_tenant_index(
              tenant_id=args.tenant_id,
              min_query_len=args.min_query_len,
              fallback_days=args.incremental_fallback_days,
              overlap_minutes=args.overlap_minutes,
              bootstrap_if_missing=args.bootstrap_if_missing,
              bootstrap_days=args.bootstrap_days,
              batch_size=args.batch_size,
          )

      print(json.dumps(result, indent=2, ensure_ascii=False))
      return 0
  
  

  def main():
      """Main CLI entry point."""
      parser = argparse.ArgumentParser(

          description='saas-search - E-Commerce Search SaaS',

          formatter_class=argparse.RawDescriptionHelpFormatter
      )
  
      subparsers = parser.add_subparsers(dest='command', help='Command to execute')
  

      # Serve command

      serve_parser = subparsers.add_parser('serve', help='Start API service (multi-tenant)')

      serve_parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')

      serve_parser.add_argument('--port', type=int, default=6002, help='Port to bind to')

      serve_parser.add_argument('--es-host', default=ES_CONFIG.get('host', 'http://localhost:9200'), help='Elasticsearch host')

      serve_parser.add_argument('--reload', action='store_true', help='Enable auto-reload')
  

      # Serve-indexer command
      serve_indexer_parser = subparsers.add_parser(
          'serve-indexer',
          help='Start dedicated Indexer API service (indexer routes only)'
      )
      serve_indexer_parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
      serve_indexer_parser.add_argument('--port', type=int, default=6004, help='Port to bind to')

      serve_indexer_parser.add_argument('--es-host', default=ES_CONFIG.get('host', 'http://localhost:9200'), help='Elasticsearch host')

      serve_indexer_parser.add_argument('--reload', action='store_true', help='Enable auto-reload')
  

      # Search command
      search_parser = subparsers.add_parser('search', help='Test search from command line')
      search_parser.add_argument('query', help='Search query')

      search_parser.add_argument('--tenant-id', required=True, help='Tenant ID (required)')

      search_parser.add_argument('--es-host', default=ES_CONFIG.get('host', 'http://localhost:9200'), help='Elasticsearch host')

      search_parser.add_argument('--size', type=int, default=10, help='Number of results')
      search_parser.add_argument('--no-translation', action='store_true', help='Disable translation')
      search_parser.add_argument('--no-embedding', action='store_true', help='Disable embeddings')
      search_parser.add_argument('--json', action='store_true', help='Output JSON')
  

      # Suggestion build command
      suggest_build_parser = subparsers.add_parser(
          'build-suggestions',

          help='Build tenant suggestion index (full/incremental)'

      )
      suggest_build_parser.add_argument('--tenant-id', required=True, help='Tenant ID')

      suggest_build_parser.add_argument('--es-host', default=ES_CONFIG.get('host', 'http://localhost:9200'), help='Elasticsearch host')
      suggest_build_parser.add_argument(
          '--mode',
          choices=['full', 'incremental'],
          default='full',
          help='Build mode: full rebuild or incremental update',
      )

      suggest_build_parser.add_argument('--days', type=int, default=360, help='Query log lookback days')

      suggest_build_parser.add_argument('--batch-size', type=int, default=500, help='Product scan batch size')
      suggest_build_parser.add_argument('--min-query-len', type=int, default=1, help='Minimum query length')
      suggest_build_parser.add_argument(

          '--publish-alias',
          action=argparse.BooleanOptionalAction,
          default=True,
          help='For full mode: publish alias to new versioned index (default: true)',
      )
      suggest_build_parser.add_argument(
          '--keep-versions',
          type=int,
          default=2,
          help='For full mode: keep latest N versioned indices',
      )
      suggest_build_parser.add_argument(

          '--incremental-fallback-days',
          type=int,
          default=7,
          help='For incremental mode: default lookback days when no watermark',
      )
      suggest_build_parser.add_argument(
          '--overlap-minutes',
          type=int,
          default=30,
          help='For incremental mode: overlap window to avoid late-arrival misses',
      )
      suggest_build_parser.add_argument(
          '--bootstrap-if-missing',
          action=argparse.BooleanOptionalAction,
          default=True,
          help='For incremental mode: bootstrap with full build when active index is missing',
      )
      suggest_build_parser.add_argument(
          '--bootstrap-days',
          type=int,
          default=30,
          help='For incremental mode bootstrap full build: query log lookback days',

      )
  

      args = parser.parse_args()
  
      if not args.command:
          parser.print_help()
          return 1
  
      # Execute command

      if args.command == 'serve':

          return cmd_serve(args)

      elif args.command == 'serve-indexer':
          return cmd_serve_indexer(args)

      elif args.command == 'search':
          return cmd_search(args)

      elif args.command == 'build-suggestions':
          return cmd_build_suggestions(args)

      else:
          print(f"Unknown command: {args.command}")
          return 1
  
  
  if __name__ == "__main__":
      sys.exit(main())