import uuid
from unittest import mock

import pytest
from anydi import Container
from cachelib import BaseCache
from fansifter_common.encrypter import Encrypter

from preference_center.config import Settings
from preference_center.songwhip.exceptions import (
    SongwhipFanDoubleOptInConsentIdCheckError,
)
from preference_center.songwhip.handlers import (
    SongwhipFanDoubleOptInConsentConfirmHandler,
    SongwhipFanDoubleOptInConsentConfirmRequest,
)


class TestSongwhipFanDoubleOptInConsentConfirmHandler:
    def test_songwhip_fan_double_opt_in_consent_confirm_wrong_encrypted_fan_consent_id(
        self,
        container: Container,
        handler: SongwhipFanDoubleOptInConsentConfirmHandler,
        producer_mock: mock.MagicMock,
    ) -> None:
        encrypted_fan_consent_id = "test"
        cache_mock = mock.MagicMock(spec=BaseCache)

        with (
            pytest.raises(SongwhipFanDoubleOptInConsentIdCheckError),
            container.override(BaseCache, cache_mock),
        ):
            handler.handle(
                SongwhipFanDoubleOptInConsentConfirmRequest(
                    fan_consent_id=encrypted_fan_consent_id,
                    country="UK",
                )
            )

        cache_mock.get.assert_not_called()
        producer_mock.publish.assert_not_called()

    def test_songwhip_fan_double_opt_in_consent_confirm_key_not_exists_in_cache(
        self,
        container: Container,
        handler: SongwhipFanDoubleOptInConsentConfirmHandler,
        dummy_encrypter: Encrypter,
        producer_mock: mock.MagicMock,
        settings: Settings,
    ) -> None:
        fan_consent_id = str(uuid.uuid4())
        encrypted_fan_consent_id = dummy_encrypter.encrypt(
            fan_consent_id.encode()
        ).decode()

        cache_mock = mock.MagicMock(spec=BaseCache)
        cache_mock.get.return_value = None

        with container.override(BaseCache, cache_mock):
            handler.handle(
                SongwhipFanDoubleOptInConsentConfirmRequest(
                    fan_consent_id=encrypted_fan_consent_id,
                    country="UK",
                )
            )

        cache_mock.get.assert_called_with(
            key=f"{handler.cache_prefix}:{fan_consent_id}"
        )

        cache_mock.add.assert_called_with(
            key=f"{handler.cache_prefix}:{fan_consent_id}",
            value=fan_consent_id,
            timeout=handler.cache_timeout,
        )

        producer_mock.publish.assert_called_with(
            topic=settings.kafka_topic_songwhip_fan_consent_double_opt_in,
            value=mock.ANY,
            key=fan_consent_id,
        )

    def test_songwhip_fan_double_opt_in_consent_confirm_key_exists_in_cache(
        self,
        container: Container,
        handler: SongwhipFanDoubleOptInConsentConfirmHandler,
        dummy_encrypter: Encrypter,
        producer_mock: mock.MagicMock,
    ) -> None:
        fan_consent_id = str(uuid.uuid4())
        encrypted_fan_consent_id = dummy_encrypter.encrypt(
            fan_consent_id.encode()
        ).decode()

        cache_mock = mock.MagicMock(spec=BaseCache)
        cache_mock.get.return_value = fan_consent_id

        with container.override(BaseCache, cache_mock):
            handler.handle(
                SongwhipFanDoubleOptInConsentConfirmRequest(
                    fan_consent_id=encrypted_fan_consent_id,
                    country="UK",
                )
            )

        cache_mock.get.assert_called_with(
            key=f"{handler.cache_prefix}:{fan_consent_id}"
        )

        cache_mock.add.assert_not_called()

        producer_mock.publish.assert_not_called()