"""
Service factory for creating mock or real service instances based on configuration.
"""

import logging
from typing import Optional
from backend.core.config import settings
from backend.services.mock_cache import MockCacheClient
from backend.services.enhanced_cache_manager import EnhancedCacheManager
from backend.services.transcript_service import TranscriptService
from backend.services.faster_whisper_transcript_service import FasterWhisperTranscriptService
from backend.config.video_download_config import VideoDownloadConfig

logger = logging.getLogger(__name__)


class ServiceFactory:
    """Factory for creating service instances based on configuration."""
    
    @staticmethod
    def create_cache_client():
        """Create cache client based on configuration."""
        if settings.USE_MOCK_SERVICES or not settings.ENABLE_REAL_CACHE:
            logger.info("Using MockCacheClient")
            return MockCacheClient()
        else:
            try:
                logger.info("Using EnhancedCacheManager")
                return EnhancedCacheManager()
            except Exception as e:
                logger.warning(f"Failed to create EnhancedCacheManager, falling back to MockCacheClient: {e}")
                return MockCacheClient()
    
    @staticmethod
    def create_whisper_client():
        """Create Whisper client based on configuration."""
        if settings.USE_MOCK_SERVICES or not settings.ENABLE_REAL_TRANSCRIPT_EXTRACTION:
            logger.info("Using MockWhisperClient")
            # Return None to use the mock implementation in TranscriptService
            return None
        else:
            try:
                # Load configuration
                config = VideoDownloadConfig()
                logger.info(f"Using FasterWhisperTranscriptService with {config.whisper_model} model")
                return FasterWhisperTranscriptService(
                    model_size=config.whisper_model,
                    device=config.whisper_device,
                    compute_type=config.whisper_compute_type,
                    beam_size=config.whisper_beam_size,
                    vad_filter=config.whisper_vad_filter,
                    word_timestamps=config.whisper_word_timestamps,
                    temperature=config.whisper_temperature,
                    best_of=config.whisper_best_of
                )
            except Exception as e:
                logger.warning(f"Failed to create FasterWhisperTranscriptService, falling back to mock: {e}")
                return None
    
    @staticmethod
    def create_transcript_service():
        """Create transcript service with appropriate dependencies."""
        cache_client = ServiceFactory.create_cache_client()
        whisper_client = ServiceFactory.create_whisper_client()
        
        # Try to import websocket manager if available
        websocket_manager = None
        try:
            from backend.core.websocket_manager import websocket_manager as ws_manager
            websocket_manager = ws_manager
        except ImportError:
            logger.debug("WebSocket manager not available")
        
        logger.info(f"Creating TranscriptService with cache_client={type(cache_client).__name__}, whisper_client={type(whisper_client).__name__ if whisper_client else 'Mock'}, websocket={bool(websocket_manager)}")
        
        return TranscriptService(
            cache_client=cache_client,
            whisper_client=whisper_client,
            websocket_manager=websocket_manager
        )