#!/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 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)
    result = builder.rebuild_tenant_index(
        tenant_id=args.tenant_id,
        days=args.days,
        recreate=args.recreate,
        batch_size=args.batch_size,
        min_query_len=args.min_query_len,
    )
    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='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='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='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 rebuild)'
    )
    suggest_build_parser.add_argument('--tenant-id', required=True, help='Tenant ID')
    suggest_build_parser.add_argument('--es-host', default='http://localhost:9200', help='Elasticsearch host')
    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(
        '--recreate',
        action='store_true',
        help='Delete and recreate suggestion index before build'
    )

    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())