main.py

#!/usr/bin/env python3
"""
Main entry point for the Webex Contact Center BYOVA Gateway.

This script loads configuration, initializes the virtual agent router,
creates the gRPC server, and starts listening for requests.
"""

import logging
import os
import sys
import threading
from concurrent import futures
from pathlib import Path
from typing import Optional

import grpc
import yaml

# Add src and src/core to Python path for imports
sys.path.insert(0, str(Path(__file__).parent / "src"))
sys.path.insert(0, str(Path(__file__).parent / "src" / "core"))

from grpc_health.v1 import health_pb2_grpc

from auth.jwt_interceptor import JWTAuthInterceptor

# Import JWT authentication components (required)
from auth.jwt_validator import JWTValidator
from core.datasource_lifecycle import create_data_source_lifecycle
from core.health_service import HealthCheckService
from core.virtual_agent_router import VirtualAgentRouter
from core.wxcc_gateway_server import WxCCGatewayServer
from monitoring.app import run_web_app
from src.generated.voicevirtualagent_pb2_grpc import (
    add_VoiceVirtualAgentServicer_to_server,
)


def setup_logging(config: dict) -> None:
    """
    Set up logging configuration.

    Args:
        config: Configuration dictionary containing logging settings
    """
    logging_config = config.get("logging", {})

    # Configure gateway logging
    gateway_config = logging_config.get("gateway", {})
    gateway_log_level = getattr(logging, gateway_config.get("level", "INFO").upper())
    gateway_log_format = gateway_config.get(
        "format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    gateway_log_file = gateway_config.get("file", "logs/gateway.log")

    # Create logs directory if it doesn't exist
    if gateway_log_file:
        log_path = Path(gateway_log_file)
        log_path.parent.mkdir(parents=True, exist_ok=True)
        print(f"Gateway log file path: {log_path.absolute()}")

    # Clear any existing handlers
    logging.getLogger().handlers.clear()

    # Configure gateway logging handlers
    handlers = [logging.StreamHandler(sys.stdout)]

    # Add file handler for gateway logging
    if gateway_log_file:
        try:
            file_handler = logging.FileHandler(gateway_log_file)
            file_handler.setFormatter(logging.Formatter(gateway_log_format))
            handlers.append(file_handler)
            print(f"Gateway logging enabled: {gateway_log_file}")
        except Exception as e:
            print(f"Warning: Could not create gateway log file {gateway_log_file}: {e}")

    # Configure gateway logging
    logging.basicConfig(
        level=gateway_log_level,
        format=gateway_log_format,
        handlers=handlers,
        force=True,  # Force reconfiguration
    )

    # Test logging
    logging.info("Gateway logging system initialized")
    print(
        f"Gateway logging level set to: {logging.getLevelName(logging.getLogger().level)}"
    )

    # Configure web logging separately
    web_config = logging_config.get("web", {})
    web_log_level = getattr(logging, web_config.get("level", "WARNING").upper())
    web_log_format = web_config.get(
        "format", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    web_log_file = web_config.get("file", "logs/web.log")

    # Create web log file if specified
    if web_log_file:
        web_log_path = Path(web_log_file)
        web_log_path.parent.mkdir(parents=True, exist_ok=True)
        print(f"Web log file path: {web_log_path.absolute()}")

        try:
            # Configure web-specific loggers
            web_logger = logging.getLogger("werkzeug")
            web_logger.setLevel(web_log_level)

            # Add file handler for web logging
            web_file_handler = logging.FileHandler(web_log_file)
            web_file_handler.setFormatter(logging.Formatter(web_log_format))
            web_logger.addHandler(web_file_handler)

            # Also configure Flask logger
            flask_logger = logging.getLogger("flask")
            flask_logger.setLevel(web_log_level)
            flask_logger.addHandler(web_file_handler)

            print(f"Web logging enabled: {web_log_file}")
        except Exception as e:
            print(f"Warning: Could not create web log file {web_log_file}: {e}")


def load_config(config_path: str = "config/config.yaml") -> dict:
    """
    Load configuration from YAML file.

    Args:
        config_path: Path to the configuration file

    Returns:
        Configuration dictionary

    Raises:
        FileNotFoundError: If config file doesn't exist
        yaml.YAMLError: If config file is invalid
    """
    try:
        with open(config_path) as file:
            config = yaml.safe_load(file)

        logging.info(f"Configuration loaded from {config_path}")
        return config

    except FileNotFoundError:
        logging.error(f"Configuration file not found: {config_path}")
        raise
    except yaml.YAMLError as e:
        logging.error(f"Invalid YAML in configuration file: {e}")
        raise


def create_router_config(config: dict) -> dict:
    """
    Extract router configuration from the main config.

    Args:
        config: Main configuration dictionary

    Returns:
        Router configuration dictionary
    """
    # The connectors config is already in the correct dictionary format
    connectors_config = config.get("connectors", {})

    # Ensure each connector has the required fields
    for connector_id, connector_config in connectors_config.items():
        if not isinstance(connector_config, dict):
            raise ValueError(
                f"Connector {connector_id} configuration must be a dictionary"
            )

        # Ensure required fields exist
        if "class" not in connector_config:
            raise ValueError(f"Connector {connector_id} missing required 'class' field")
        if "module" not in connector_config:
            raise ValueError(
                f"Connector {connector_id} missing required 'module' field"
            )
        if "config" not in connector_config:
            connectors_config[connector_id]["config"] = {}

    return {"connectors": connectors_config}


def create_jwt_interceptor(
    config: dict, logger: logging.Logger
) -> Optional[JWTAuthInterceptor]:
    """
    Create JWT authentication interceptor if configured.

    Args:
        config: Configuration dictionary containing JWT settings
        logger: Logger instance

    Returns:
        JWTAuthInterceptor instance or None if not configured

    Raises:
        ValueError: If JWT validation is enabled but datasource_url is not configured
    """
    jwt_config = config.get("jwt_validation", {})

    if not jwt_config.get("enabled", False):
        logger.info("JWT validation is disabled in configuration")
        return None

    # Validate required configuration
    datasource_url = jwt_config.get("datasource_url", "")
    if not datasource_url:
        error_msg = (
            "JWT validation is enabled but datasource_url is not configured. "
            "Please set jwt_validation.datasource_url in config.yaml or disable JWT validation."
        )
        logger.error(error_msg)
        raise ValueError(error_msg)

    # Get configuration values
    datasource_schema_uuid = jwt_config.get(
        "datasource_schema_uuid", "5397013b-7920-4ffc-807c-e8a3e0a18f43"
    )
    cache_duration_minutes = jwt_config.get("cache_duration_minutes", 60)
    enforce_validation = jwt_config.get("enforce_validation", True)

    try:
        # Create JWT validator
        validator = JWTValidator(
            datasource_url=datasource_url,
            datasource_schema_uuid=datasource_schema_uuid,
            cache_duration_minutes=cache_duration_minutes,
        )

        # Create interceptor
        interceptor = JWTAuthInterceptor(
            jwt_validator=validator,
            enabled=True,
            enforce=enforce_validation,
        )

        logger.info("JWT authentication interceptor created successfully")
        logger.info(f"Datasource URL: {datasource_url}")
        logger.info(
            f"Enforcement: {'ENABLED' if enforce_validation else 'DISABLED (logging only)'}"
        )

        return interceptor

    except Exception as e:
        logger.error(f"Failed to create JWT interceptor: {e}")

        # If JWT validation is enabled, this is a fatal error
        jwt_config = config.get("jwt_validation", {})
        if jwt_config.get("enabled", True):
            error_msg = (
                "Failed to create JWT interceptor but JWT validation is enabled. "
                "This is a fatal configuration error. Please check your configuration and dependencies."
            )
            logger.error(error_msg)
            raise RuntimeError(error_msg) from e
        else:
            logger.warning(
                "JWT validation is disabled, continuing without JWT interceptor"
            )
            return None


def create_streaming_executor(servicer, max_workers: int):
    """Create and attach a dedicated executor for caller streaming RPCs."""
    executor = futures.ThreadPoolExecutor(
        max_workers=max_workers,
        thread_name_prefix="byova-stream",
    )
    servicer.ProcessCallerInput.__func__.experimental_thread_pool = executor
    return executor


def main():
    """
    Main entry point for the BYOVA Gateway.

    This function:
    1. Loads configuration from YAML file
    2. Sets up logging
    3. Creates and configures the VirtualAgentRouter
    4. Creates the WxCCGatewayServer
    5. Starts the gRPC server
    """
    logger = None
    server = None
    grpc_server = None
    data_source_lifecycle = None
    streaming_executor = None
    try:
        # Select an environment-specific configuration when requested.
        config_path = os.environ.get("GATEWAY_CONFIG", "config/config.yaml")
        config = load_config(config_path)

        # Set up logging
        setup_logging(config)
        logger = logging.getLogger(__name__)

        logger.info("Starting Webex Contact Center BYOVA Gateway")

        # Create VirtualAgentRouter
        router = VirtualAgentRouter()
        logger.info("VirtualAgentRouter created")

        # Load connectors
        router_config = create_router_config(config)
        router.load_connectors(router_config)
        logger.info("Connectors loaded successfully")

        # Get server configuration
        gateway_config = config.get("gateway", {})

        # Create WxCCGatewayServer
        vad_config = config.get("voice_activity_detection", {})
        server = WxCCGatewayServer(
            router,
            vad_config,
            max_terminal_playback_seconds=float(
                gateway_config.get("max_terminal_playback_seconds", 30.0)
            ),
            request_queue_maxsize=int(
                gateway_config.get("request_queue_maxsize", 100)
            ),
            response_queue_maxsize=int(
                gateway_config.get("response_queue_maxsize", 100)
            ),
        )
        logger.info("WxCCGatewayServer created")

        # Create health service with router for real health monitoring
        health_service = HealthCheckService(router)
        logger.info("HealthCheckService created with real health monitoring")

        host = gateway_config.get("host", "0.0.0.0")
        port = int(os.environ.get("PORT", gateway_config.get("port", 50051)))

        # Create JWT interceptor if configured
        jwt_interceptor = create_jwt_interceptor(config, logger)
        interceptors = []
        if jwt_interceptor:
            interceptors.append(jwt_interceptor)

        # Establish the BYODS registration before accepting gRPC traffic.
        data_source_lifecycle = create_data_source_lifecycle(config, logger)
        if data_source_lifecycle:
            try:
                data_source_lifecycle.start()
            except Exception:
                if config.get("data_source", {}).get("fail_startup_on_error", True):
                    raise
                logger.exception(
                    "BYODS data source lifecycle failed to start; "
                    "continuing because fail_startup_on_error is false"
                )
                data_source_lifecycle.stop()
                data_source_lifecycle = None

        # Create gRPC server with interceptors
        if interceptors:
            grpc_server = grpc.server(
                futures.ThreadPoolExecutor(max_workers=10),
                interceptors=interceptors,
                options=[
                    ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
                    ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
                    ("grpc.max_concurrent_streams", 100),
                ],
            )
            logger.info(f"gRPC server created with {len(interceptors)} interceptor(s)")
        else:
            grpc_server = grpc.server(
                futures.ThreadPoolExecutor(max_workers=10),
                options=[
                    ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
                    ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
                    ("grpc.max_concurrent_streams", 100),
                ],
            )
            logger.info("gRPC server created without interceptors")

        # Keep long-lived bidirectional caller streams, including response-
        # derived playback waits, off the shared executor used by health and
        # unary RPCs. gRPC Python selects this method-specific pool through the
        # handler's supported experimental_thread_pool attribute.
        streaming_executor = create_streaming_executor(
            server,
            int(gateway_config.get("streaming_max_workers", 100)),
        )

        # Add servicer to the server
        add_VoiceVirtualAgentServicer_to_server(server, grpc_server)

        # Add health service to the server
        health_pb2_grpc.add_HealthServicer_to_server(health_service, grpc_server)
        logger.info("Health service registered with gRPC server")

        # Bind server to address
        server_address = f"{host}:{port}"
        grpc_server.add_insecure_port(server_address)

        # Start the server
        grpc_server.start()

        # Start Flask monitoring app in a separate thread
        monitoring_config = config.get("monitoring", {})
        if monitoring_config.get("enabled", True):  # Enable by default
            monitoring_host = monitoring_config.get("host", "0.0.0.0")
            monitoring_port = monitoring_config.get("port", 8080)

            # Create and start Flask app in a separate thread
            flask_thread = threading.Thread(
                target=run_web_app,
                args=(router, server),
                kwargs={
                    "host": monitoring_host,
                    "port": monitoring_port,
                    "debug": monitoring_config.get("debug", False),
                },
                daemon=True,  # Make it a daemon thread so it stops when main thread stops
            )
            flask_thread.start()
            logger.info(
                f"Flask monitoring app started on {monitoring_host}:{monitoring_port}"
            )

        # Print startup information
        print("\n" + "=" * 60)
        print("🚀 Webex Contact Center BYOVA Gateway")
        print("=" * 60)
        print(f"📡 gRPC Server: {server_address}")
        print(f"🌐 Access URL: grpc://{host}:{port}")
        print(f"📁 Configuration: {config_path}")
        print(f"📝 Log Level: {gateway_config.get('level', 'INFO')}")
        print(f"🔧 Gateway Version: {gateway_config.get('version', '1.1.0')}")
        print()

        # Print connector information
        print("🔌 Loaded Connectors:")
        router_info = router.get_connector_info()
        for connector_name in router_info["loaded_connectors"]:
            print(f"   • {connector_name}")

        print()
        print("🎯 Available Agents:")
        available_agents = router.get_all_available_agents()
        for agent in available_agents:
            print(f"   • {agent}")

        print()
        print("📊 Monitoring Interface:")
        if monitoring_config.get("enabled", True):
            print(f"   • Web UI: http://{monitoring_host}:{monitoring_port}")
            print(f"   • Status: http://{monitoring_host}:{monitoring_port}/status")
            print(f"   • Health: http://{monitoring_host}:{monitoring_port}/health")
        else:
            print("   • Disabled")

        print()
        print("🔐 JWT Authentication:")
        jwt_config = config.get("jwt_validation", {})
        if jwt_config.get("enabled", False) and jwt_interceptor:
            print("   • Status: ENABLED")
            print(
                f"   • Enforcement: {'ENABLED' if jwt_config.get('enforce_validation', True) else 'DISABLED (logging only)'}"
            )
            print(
                f"   • Datasource URL: {jwt_config.get('datasource_url', 'Not configured')}"
            )
        else:
            print("   • Status: DISABLED")

        print()
        print("🗂️  BYODS Datasource:")
        if data_source_lifecycle:
            current_data_source = data_source_lifecycle.current_data_source or {}
            print("   • Management: ENABLED")
            print(f"   • ID: {data_source_lifecycle.data_source_id}")
            print(
                "   • Token Expires: "
                f"{current_data_source.get('tokenExpiryTime', 'Not provided')}"
            )
        else:
            print("   • Management: DISABLED")

        print()
        print("✅ Gateway is running! Press Ctrl+C to stop.")
        print("=" * 60)

        # Keep the server running
        try:
            grpc_server.wait_for_termination()
        except KeyboardInterrupt:
            logger.info("Received shutdown signal")
        finally:
            # Graceful shutdown
            logger.info("Shutting down gateway...")
            if server:
                server.shutdown()
            grpc_server.stop(grace=5)
            if data_source_lifecycle:
                data_source_lifecycle.stop()
            if streaming_executor:
                streaming_executor.shutdown(wait=False, cancel_futures=True)
            logger.info("Gateway shutdown complete")

    except Exception as e:
        if grpc_server:
            grpc_server.stop(grace=0)
        if server:
            server.shutdown()
        if data_source_lifecycle:
            data_source_lifecycle.stop()
        if streaming_executor:
            streaming_executor.shutdown(wait=False, cancel_futures=True)
        if logger:
            logger.error(f"Failed to start gateway: {e}")
        else:
            print(f"Failed to start gateway: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()