from unittest import mock

import pytest

from dmp.adapters.meta.models import DebugToken, User
from dmp.audiences.enums import AudienceSharePlatform
from dmp.audiences.models import Audience, AudienceShare
from dmp.config import Settings
from dmp.meta.exceptions import (
    MetaAudienceNotFoundError,
    MetaUserConnectionNotFoundError,
)
from dmp.meta.handlers import GetMetaAudienceShareHandler, GetMetaAudienceShareRequest
from dmp.meta.models import (
    MetaAdAccount,
    MetaAudience,
    MetaUserAdAccount,
    MetaUserConnection,
)

from tests.unit.faker import FakerTyped
from tests.unit.types import BuildModel, CreateModel


class TestGetMetaAudienceShareHandler:
    @pytest.mark.db
    def test_get_audience_share(
        self,
        handler: GetMetaAudienceShareHandler,
        facebook_client_mock: mock.MagicMock,
        build_model: BuildModel,
        create_model: CreateModel,
        settings: Settings,
    ) -> None:
        audience = create_model(Audience)
        ad_account = create_model(MetaAdAccount)
        user_connection = create_model(
            MetaUserConnection, is_valid=True, ad_accounts=[ad_account]
        )
        create_model(
            MetaUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=user_connection.identity_id,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )

        share = create_model(
            AudienceShare,
            audience=audience,
            platform=AudienceSharePlatform.META,
            created_by=user_connection.identity_id,
        )

        meta_audience = create_model(MetaAudience, share=share, ad_account=ad_account)

        facebook_client_mock.debug_token.return_value = DebugToken(
            is_valid=True, scopes=settings.meta_user_required_scopes
        )
        facebook_client_mock.get_user.return_value = build_model(User)

        response = handler.handle(
            GetMetaAudienceShareRequest(share_id=meta_audience.share_id),
        )

        assert response.audience_id == meta_audience.id
        assert response.audience_name == meta_audience.name
        assert response.fans_count == meta_audience.fans_count
        assert response.ad_account_external_id == meta_audience.ad_account_external_id
        assert response.user_access_token == user_connection.token

    @pytest.mark.db
    def test_get_audience_share_not_exist(
        self, handler: GetMetaAudienceShareHandler, fake: FakerTyped
    ) -> None:
        with pytest.raises(MetaAudienceNotFoundError):
            handler.handle(
                GetMetaAudienceShareRequest(share_id=fake.uuid4_string()),
            )

    @pytest.mark.db
    def test_get_audience_share_user_connection_not_exist(
        self, handler: GetMetaAudienceShareHandler, create_model: CreateModel
    ) -> None:
        meta_audience = create_model(MetaAudience)

        with pytest.raises(MetaUserConnectionNotFoundError):
            handler.handle(
                GetMetaAudienceShareRequest(share_id=meta_audience.share_id),
            )