"""
Provider factories with lazy imports.

All provider classes are imported lazily to avoid loading heavy dependencies
(torch, selenium, playwright) at module import time. Use the factory functions
to get provider instances.
"""

from __future__ import annotations

from providers.registry import get_provider_registry  # noqa: F401

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from models import VoiceSettings


def get_tts_provider(settings: "VoiceSettings"):
    """
    Factory function to get the appropriate TTS provider based on settings.

    Args:
        settings: VoiceSettings with tts_provider field

    Returns:
        TTS provider instance (ElevenLabsTTSProvider or PollinationsTTSProvider)
    """
    provider = getattr(settings, "tts_provider", "elevenlabs")

    if provider == "pollinations":
        from providers.pollinations_tts_provider import PollinationsTTSProvider

        # Get pollinations TTS settings from VoiceSettings if available
        model = getattr(settings, "pollinations_model", "openai")
        voice = getattr(settings, "pollinations_voice", "nova")
        speed = getattr(settings, "pollinations_speed", 1.0)
        audio_format = getattr(settings, "pollinations_format", "mp3")
        api_key = getattr(settings, "pollinations_api_key", None)
        
        return PollinationsTTSProvider(
            api_key=api_key,
            model=model,
            voice=voice,
            speed=float(speed) if speed else 1.0,
            audio_format=audio_format,
        )
    else:
        from providers.tts_provider import ElevenLabsTTSProvider

        return ElevenLabsTTSProvider(settings)


def get_image_provider(name: str, **kwargs):
    """
    Factory function to get an image provider by name.

    Args:
        name: Provider name — 'dalle3', 'google_flow', 'google_flow_v2'

    Returns:
        Image provider instance
    """
    if name == "dalle3":
        from providers.image_provider import DallE3ImageProvider

        return DallE3ImageProvider(**kwargs)
    elif name == "google_flow":
        from providers.google_flow_provider import GoogleFlowImageProvider

        return GoogleFlowImageProvider(**kwargs)
    elif name == "google_flow_v2":
        from providers.google_flow_v2_provider import GoogleFlowV2ImageProvider

        return GoogleFlowV2ImageProvider(**kwargs)
    elif name == "pollinations":
        from providers.pollinations_image_provider import PollinationsImageProvider

        return PollinationsImageProvider(**kwargs)
    else:
        raise ValueError(
            f"Unknown image provider: {name}. Choose from: dalle3, google_flow, google_flow_v2, pollinations"
        )


def get_video_provider(name: str, **kwargs):
    """
    Factory function to get a video provider by name.

    Args:
        name: Provider name — 'runway', 'grok', 'google_veo'

    Returns:
        Video provider instance
    """
    if name == "runway":
        from providers.video_provider import RunwayVideoProvider

        return RunwayVideoProvider(**kwargs)
    elif name == "grok":
        from providers.grok_video_provider import GrokVideoProvider

        return GrokVideoProvider(**kwargs)
    elif name == "grok_camoufox":
        from providers.grok_camoufox_provider import GrokCamoufoxProvider

        return GrokCamoufoxProvider(**kwargs)
    elif name == "google_veo":
        from providers.google_veo_provider import GoogleVeoVideoProvider

        return GoogleVeoVideoProvider(**kwargs)
    elif name == "leonardo":
        from providers.leonardo_video_provider import LeonardoVideoProvider

        return LeonardoVideoProvider(**kwargs)
    elif name == "pollinations":
        from providers.pollinations_video_provider import PollinationsVideoProvider

        return PollinationsVideoProvider(**kwargs)
    else:
        raise ValueError(
            f"Unknown video provider: {name}. Choose from: runway, grok, google_veo, leonardo, pollinations"
        )


# For backward compatibility, provide lazy attribute access
def __getattr__(name: str):
    """Lazy import provider classes for backward compatibility."""
    _LAZY_IMPORTS = {
        "ElevenLabsTTSProvider": "providers.tts_provider",
        "DallE3ImageProvider": "providers.image_provider",
        "RunwayVideoProvider": "providers.video_provider",
        "GoogleFlowImageProvider": "providers.google_flow_provider",
        "GoogleFlowV2ImageProvider": "providers.google_flow_v2_provider",
        "GoogleVeoVideoProvider": "providers.google_veo_provider",
        "GrokVideoProvider": "providers.grok_video_provider",
        "GrokCamoufoxProvider": "providers.grok_camoufox_provider",
        "GrokPlaywrightProvider": "providers.grok_playwright_provider",
        "FlowBrowserEngine": "providers.flow_browser_engine",
        "FlowCamoufoxEngine": "providers.flow_camoufox_engine",
        "LeonardoVideoProvider": "providers.leonardo_video_provider",
        "PollinationsImageProvider": "providers.pollinations_image_provider",
        "PollinationsVideoProvider": "providers.pollinations_video_provider",
        "PollinationsTTSProvider": "providers.pollinations_tts_provider",
        "GoogleFlowBrowserAdapter": "providers.google_flow_adapter",
    }
    if name in _LAZY_IMPORTS:
        import importlib

        module = importlib.import_module(_LAZY_IMPORTS[name])
        return getattr(module, name)
    raise AttributeError(f"module 'providers' has no attribute {name!r}")


__all__ = [
    "get_tts_provider",
    "get_image_provider",
    "get_video_provider",
    "get_provider_registry",
    "ElevenLabsTTSProvider",
    "DallE3ImageProvider",
    "RunwayVideoProvider",
    "GoogleFlowImageProvider",
    "GoogleFlowV2ImageProvider",
    "GoogleFlowBrowserAdapter",
    "GoogleVeoVideoProvider",
    "GrokVideoProvider",
    "GrokCamoufoxProvider",
    "GrokPlaywrightProvider",
    "FlowBrowserEngine",
    "FlowCamoufoxEngine",
    "LeonardoVideoProvider",
    "PollinationsImageProvider",
    "PollinationsVideoProvider",
    "PollinationsTTSProvider",
]