"""Dependency injection and service lifecycle management."""

from functools import lru_cache

from capa_de_integracion.services.rag import (
    EchoRAGService,
    HTTPRAGService,
    RAGServiceBase,
)

from .config import Settings, settings
from .services import (
    ConversationManagerService,
    DLPService,
    NotificationManagerService,
    QuickReplyContentService,
    QuickReplySessionService,
)
from .services.storage import FirestoreService, RedisService


@lru_cache(maxsize=1)
def get_redis_service() -> RedisService:
    """Get Redis service instance."""
    return RedisService(settings)


@lru_cache(maxsize=1)
def get_firestore_service() -> FirestoreService:
    """Get Firestore service instance."""
    return FirestoreService(settings)


@lru_cache(maxsize=1)
def get_dlp_service() -> DLPService:
    """Get DLP service instance."""
    return DLPService(settings)


@lru_cache(maxsize=1)
def get_quick_reply_content_service() -> QuickReplyContentService:
    """Get quick reply content service instance."""
    return QuickReplyContentService(settings)


@lru_cache(maxsize=1)
def get_quick_reply_session_service() -> QuickReplySessionService:
    """Get quick reply session service instance."""
    return QuickReplySessionService(
        redis_service=get_redis_service(),
        firestore_service=get_firestore_service(),
        quick_reply_content_service=get_quick_reply_content_service(),
    )


@lru_cache(maxsize=1)
def get_notification_manager() -> NotificationManagerService:
    """Get notification manager instance."""
    return NotificationManagerService(
        settings,
        redis_service=get_redis_service(),
        firestore_service=get_firestore_service(),
        dlp_service=get_dlp_service(),
    )


@lru_cache(maxsize=1)
def get_rag_service() -> RAGServiceBase:
    """Get RAG service instance."""
    if settings.rag_echo_enabled:
        return EchoRAGService()
    return HTTPRAGService(
        endpoint_url=settings.rag_endpoint_url,
        max_connections=100,
        max_keepalive_connections=20,
        timeout=30.0,
    )


@lru_cache(maxsize=1)
def get_conversation_manager() -> ConversationManagerService:
    """Get conversation manager instance."""
    return ConversationManagerService(
        settings,
        redis_service=get_redis_service(),
        firestore_service=get_firestore_service(),
        dlp_service=get_dlp_service(),
        rag_service=get_rag_service(),
    )


# Lifecycle management functions


def init_services(settings: Settings) -> None:
    """Initialize services (placeholder for compatibility)."""
    # Services are lazy-loaded via lru_cache, no explicit init needed


async def startup_services() -> None:
    """Connect to external services on startup."""
    # Connect to Redis
    redis = get_redis_service()
    await redis.connect()


async def shutdown_services() -> None:
    """Close all service connections on shutdown."""
    # Close Redis
    redis = get_redis_service()
    await redis.close()

    # Close Firestore
    firestore = get_firestore_service()
    await firestore.close()

    # Close DLP
    dlp = get_dlp_service()
    await dlp.close()

    # Close RAG
    rag = get_rag_service()
    await rag.close()