from unittest import mock

import pytest
from fansifter_common.utils import timezone

from email_campaigns.automated.handlers import (
    GetAutomatedEmailStatusHandler,
    GetAutomatedEmailStatusRequest,
)
from email_campaigns.automated.models import (
    AutomatedEmail,
    AutomatedEmailTrigger,
    SourceCampaign,
)
from email_campaigns.emails.exceptions import EmailNotFoundError

from tests.unit.types import CreateModel


class TestGetAutomatedEmailStatusHandler:
    @pytest.mark.db
    def test_returns_status_for_automated_email(
        self,
        handler: GetAutomatedEmailStatusHandler,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        source_campaign = create_model(SourceCampaign)
        automated_email = create_model(
            AutomatedEmail,
            has_unapplied_changes=True,
            source_campaign_connections=[
                AutomatedEmailTrigger(
                    source_campaign_id=source_campaign.id,
                    subscription_only=False,
                ),
            ],
        )

        result = handler.handle(
            GetAutomatedEmailStatusRequest(
                identity_id=identity_id,
                email_id=automated_email.id,
            )
        )

        assert result.has_unapplied_changes is True
        assert result.is_automated is True

    @pytest.mark.db
    def test_returns_status_without_triggers(
        self,
        handler: GetAutomatedEmailStatusHandler,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        automated_email = create_model(
            AutomatedEmail,
            has_unapplied_changes=False,
            source_campaign_connections=[],
        )

        result = handler.handle(
            GetAutomatedEmailStatusRequest(
                identity_id=identity_id,
                email_id=automated_email.id,
            )
        )

        assert result.has_unapplied_changes is False
        assert result.is_automated is False

    @pytest.mark.db
    def test_raises_when_not_found(
        self,
        handler: GetAutomatedEmailStatusHandler,
        identity_id: str,
    ) -> None:
        with pytest.raises(EmailNotFoundError):
            handler.handle(
                GetAutomatedEmailStatusRequest(
                    identity_id=identity_id,
                    email_id="does-not-exist",
                )
            )

    @pytest.mark.db
    def test_raises_when_deleted(
        self,
        handler: GetAutomatedEmailStatusHandler,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        automated_email = create_model(
            AutomatedEmail,
            deleted_at=timezone.now(),
        )

        with pytest.raises(EmailNotFoundError):
            handler.handle(
                GetAutomatedEmailStatusRequest(
                    identity_id=identity_id,
                    email_id=automated_email.id,
                )
            )

    @pytest.mark.db
    def test_authorizes_against_email_account(
        self,
        handler: GetAutomatedEmailStatusHandler,
        create_model: CreateModel,
        identity_id: str,
        auth_service_mock: mock.MagicMock,
    ) -> None:
        automated_email = create_model(AutomatedEmail)

        handler.handle(
            GetAutomatedEmailStatusRequest(
                identity_id=identity_id,
                email_id=automated_email.id,
            )
        )

        auth_service_mock.authorize_account.assert_called_once()
        _, kwargs = auth_service_mock.authorize_account.call_args
        assert kwargs["account"].vendor_id == automated_email.vendor_id
        assert kwargs["account"].subaccount_id == automated_email.subaccount_id
        assert kwargs["permission"] == handler.permission