"""Tests for dependency injection."""

from unittest.mock import AsyncMock, Mock, patch

import pytest

from capa_de_integracion.config import Settings
from capa_de_integracion.dependencies import (
    get_conversation_manager,
    get_dlp_service,
    get_firestore_service,
    get_notification_manager,
    get_quick_reply_content_service,
    get_rag_service,
    get_redis_service,
    init_services,
    shutdown_services,
    startup_services,
)
from capa_de_integracion.services import (
    ConversationManagerService,
    DLPService,
    NotificationManagerService,
    QuickReplyContentService,
)
from capa_de_integracion.services.firestore_service import FirestoreService
from capa_de_integracion.services.rag import EchoRAGService, HTTPRAGService
from capa_de_integracion.services.redis_service import RedisService


def test_get_redis_service():
    """Test get_redis_service returns RedisService."""
    # Clear cache first
    get_redis_service.cache_clear()

    service = get_redis_service()
    assert isinstance(service, RedisService)

    # Should return same instance (cached)
    service2 = get_redis_service()
    assert service is service2


def test_get_firestore_service():
    """Test get_firestore_service returns FirestoreService."""
    get_firestore_service.cache_clear()

    service = get_firestore_service()
    assert isinstance(service, FirestoreService)

    # Should return same instance (cached)
    service2 = get_firestore_service()
    assert service is service2


def test_get_dlp_service():
    """Test get_dlp_service returns DLPService."""
    get_dlp_service.cache_clear()

    service = get_dlp_service()
    assert isinstance(service, DLPService)

    # Should return same instance (cached)
    service2 = get_dlp_service()
    assert service is service2


def test_get_quick_reply_content_service():
    """Test get_quick_reply_content_service returns QuickReplyContentService."""
    get_quick_reply_content_service.cache_clear()

    service = get_quick_reply_content_service()
    assert isinstance(service, QuickReplyContentService)

    # Should return same instance (cached)
    service2 = get_quick_reply_content_service()
    assert service is service2


def test_get_notification_manager():
    """Test get_notification_manager returns NotificationManagerService."""
    get_notification_manager.cache_clear()
    get_redis_service.cache_clear()
    get_firestore_service.cache_clear()
    get_dlp_service.cache_clear()

    service = get_notification_manager()
    assert isinstance(service, NotificationManagerService)

    # Should return same instance (cached)
    service2 = get_notification_manager()
    assert service is service2


def test_get_rag_service_http():
    """Test get_rag_service returns HTTPRAGService when echo disabled."""
    get_rag_service.cache_clear()

    with patch("capa_de_integracion.dependencies.settings") as mock_settings, \
         patch("capa_de_integracion.dependencies.HTTPRAGService") as mock_http_rag:
        mock_settings.rag_echo_enabled = False
        mock_settings.rag_endpoint_url = "http://test.example.com"

        mock_http_rag.return_value = Mock(spec=HTTPRAGService)

        service = get_rag_service()

        mock_http_rag.assert_called_once()
        assert service is not None


def test_get_rag_service_echo():
    """Test get_rag_service returns EchoRAGService when echo enabled."""
    get_rag_service.cache_clear()

    with patch("capa_de_integracion.dependencies.settings") as mock_settings:
        mock_settings.rag_echo_enabled = True

        service = get_rag_service()
        assert isinstance(service, EchoRAGService)


def test_get_conversation_manager():
    """Test get_conversation_manager returns ConversationManagerService."""
    get_conversation_manager.cache_clear()
    get_redis_service.cache_clear()
    get_firestore_service.cache_clear()
    get_dlp_service.cache_clear()
    get_rag_service.cache_clear()

    with patch("capa_de_integracion.dependencies.get_rag_service") as mock_get_rag:
        mock_get_rag.return_value = Mock(spec=EchoRAGService)

        service = get_conversation_manager()
        assert isinstance(service, ConversationManagerService)

        # Should return same instance (cached)
        service2 = get_conversation_manager()
        assert service is service2


def test_init_services():
    """Test init_services (placeholder function)."""
    settings = Settings.model_validate({})
    # Should not raise - it's a placeholder
    init_services(settings)


@pytest.mark.asyncio
async def test_startup_services(emulator_settings):
    """Test startup_services connects to Redis."""
    get_redis_service.cache_clear()

    # Mock Redis service to avoid actual connection
    with patch("capa_de_integracion.dependencies.get_redis_service") as mock_get_redis:
        from unittest.mock import AsyncMock

        mock_redis = Mock(spec=RedisService)
        mock_redis.connect = AsyncMock()
        mock_get_redis.return_value = mock_redis

        await startup_services()

        mock_redis.connect.assert_called_once()


@pytest.mark.asyncio
async def test_shutdown_services(emulator_settings):
    """Test shutdown_services closes all services."""
    get_redis_service.cache_clear()
    get_firestore_service.cache_clear()
    get_dlp_service.cache_clear()
    get_rag_service.cache_clear()

    # Create mock services
    with patch("capa_de_integracion.dependencies.get_redis_service") as mock_get_redis, \
         patch("capa_de_integracion.dependencies.get_firestore_service") as mock_get_firestore, \
         patch("capa_de_integracion.dependencies.get_dlp_service") as mock_get_dlp, \
         patch("capa_de_integracion.dependencies.get_rag_service") as mock_get_rag:

        from unittest.mock import AsyncMock

        mock_redis = Mock(spec=RedisService)
        mock_redis.close = AsyncMock()
        mock_get_redis.return_value = mock_redis

        mock_firestore = Mock(spec=FirestoreService)
        mock_firestore.close = AsyncMock()
        mock_get_firestore.return_value = mock_firestore

        mock_dlp = Mock(spec=DLPService)
        mock_dlp.close = AsyncMock()
        mock_get_dlp.return_value = mock_dlp

        mock_rag = Mock(spec=EchoRAGService)
        mock_rag.close = AsyncMock()
        mock_get_rag.return_value = mock_rag

        await shutdown_services()

        # Verify each service's close method was called
        mock_redis.close.assert_called_once()
        mock_firestore.close.assert_called_once()
        mock_dlp.close.assert_called_once()
        mock_rag.close.assert_called_once()