"""
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.whisper_transcript_service import WhisperTranscriptService

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:
                logger.info("Using WhisperTranscriptService")
                return WhisperTranscriptService()
            except Exception as e:
                logger.warning(f"Failed to create WhisperTranscriptService, 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()
        
        logger.info(f"Creating TranscriptService with cache_client={type(cache_client).__name__}, whisper_client={type(whisper_client).__name__ if whisper_client else 'Mock'}")
        
        return TranscriptService(
            cache_client=cache_client,
            whisper_client=whisper_client
        )