from unittest import mock

import pytest
from anydi import Container
from faker import Faker
from fansifter_common.auth.identity import Identity

from dmp.audiences.enums import AudienceTarget
from dmp.audiences.filters import AudienceFilters
from dmp.audiences.handlers import GetAudienceSizeHandler, GetAudienceSizeRequest
from dmp.audiences.types import FanDataListId
from dmp.fandata.models import (
    GlobalAudienceFiltersAdCampaignDbt,
    GlobalAudienceFiltersEmailCampaignDbt,
)
from dmp.rosters.exceptions import (
    FanDataListIdIsRequiredError,
    MainRepArtistOnlyAllowedError,
)
from dmp.rosters.models import ArtistRosterMainRep
from dmp.rosters.services import GlobalFanDataAccessService

from tests.unit.faker import FakerTyped
from tests.unit.types import CreateReportingModel


class TestGetAudienceSizeHandler:
    @pytest.mark.db
    def test_get_audience_size(
        self, handler: GetAudienceSizeHandler, identity: Identity, fake: FakerTyped
    ) -> None:
        size = handler.handle(
            GetAudienceSizeRequest(
                identity=identity,
                fandata_list_ids=[
                    FanDataListId.from_artist_id(fake.uuid4_string()),
                ],
                vendor_id=fake.integer(),
                subaccount_id=fake.integer(),
                filters=AudienceFilters.model_construct(),
                target=AudienceTarget.ADS,
            )
        )

        assert size == 0

    @pytest.mark.db
    def test_get_audience_size_fandata_list_id_required(
        self, handler: GetAudienceSizeHandler, identity: Identity, fake: FakerTyped
    ) -> None:
        with pytest.raises(FanDataListIdIsRequiredError):
            handler.handle(
                GetAudienceSizeRequest(
                    identity=identity,
                    fandata_list_ids=[],
                    vendor_id=fake.integer(),
                    subaccount_id=fake.integer(),
                    filters=AudienceFilters.model_construct(),
                    target=AudienceTarget.ADS,
                )
            )

    @pytest.mark.db
    def test_get_audience_size_global_list_enabled(
        self,
        container: Container,
        handler: GetAudienceSizeHandler,
        identity: Identity,
        faker: Faker,
        create_reporting_model: CreateReportingModel,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()
        global_participant_id = faker.uuid4()

        create_reporting_model(
            ArtistRosterMainRep,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            global_participant_id=global_participant_id,
        )

        create_reporting_model(
            GlobalAudienceFiltersAdCampaignDbt,
            global_participant_id=global_participant_id,
        )

        global_fandata_access_service_mock = mock.MagicMock(
            spec=GlobalFanDataAccessService,
            is_enabled_for_any_vendor=mock.MagicMock(return_value=True),
        )

        with container.override(
            GlobalFanDataAccessService, global_fandata_access_service_mock
        ):
            size = handler.handle(
                GetAudienceSizeRequest(
                    identity=identity,
                    fandata_list_ids=[
                        FanDataListId.from_artist_id(global_participant_id)
                    ],
                    vendor_id=vendor_id,
                    subaccount_id=subaccount_id,
                    filters=AudienceFilters.model_construct(),
                    target=AudienceTarget.ADS,
                )
            )

        assert size == 1

    @pytest.mark.db
    def test_get_audience_size_global_list_enabled_main_rep_only(
        self,
        container: Container,
        handler: GetAudienceSizeHandler,
        identity: Identity,
        faker: Faker,
        create_reporting_model: CreateReportingModel,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()
        global_participant_id = faker.uuid4()

        create_reporting_model(
            GlobalAudienceFiltersEmailCampaignDbt,
            global_participant_id=global_participant_id,
        )

        global_fandata_access_service_mock = mock.MagicMock(
            spec=GlobalFanDataAccessService,
            is_enabled_for_any_vendor=mock.MagicMock(return_value=True),
        )

        with (
            container.override(
                GlobalFanDataAccessService, global_fandata_access_service_mock
            ),
            pytest.raises(MainRepArtistOnlyAllowedError) as exc_info,
        ):
            _ = handler.handle(
                GetAudienceSizeRequest(
                    identity=identity,
                    fandata_list_ids=[
                        FanDataListId.from_artist_id(global_participant_id)
                    ],
                    vendor_id=vendor_id,
                    subaccount_id=subaccount_id,
                    filters=AudienceFilters.model_construct(),
                    target=AudienceTarget.EMAIL,
                )
            )

        assert exc_info.value.global_participant_id == global_participant_id

    @pytest.mark.db
    def test_get_audience_size_with_exclude_countries(
        self,
        handler: GetAudienceSizeHandler,
        identity: Identity,
        fake: FakerTyped,
        create_reporting_model: CreateReportingModel,
    ) -> None:
        from dmp.fandata.models import AudienceFiltersAdCampaignDbt

        vendor_id = fake.integer()
        subaccount_id = fake.integer()
        global_participant_id = fake.uuid4_string()
        country_1 = "US"
        country_2 = "GB"
        country_3 = "EE"
        country_4 = None

        for _ in range(3):
            create_reporting_model(
                AudienceFiltersAdCampaignDbt,
                vendor_id=vendor_id,
                subaccount_id=subaccount_id,
                global_participant_id=global_participant_id,
                country_iso2=country_1,
            )

        for _ in range(2):
            create_reporting_model(
                AudienceFiltersAdCampaignDbt,
                vendor_id=vendor_id,
                subaccount_id=subaccount_id,
                global_participant_id=global_participant_id,
                country_iso2=country_2,
            )

        for _ in range(4):
            create_reporting_model(
                AudienceFiltersAdCampaignDbt,
                vendor_id=vendor_id,
                subaccount_id=subaccount_id,
                global_participant_id=global_participant_id,
                country_iso2=country_3,
            )

        for _ in range(10):
            create_reporting_model(
                AudienceFiltersAdCampaignDbt,
                vendor_id=vendor_id,
                subaccount_id=subaccount_id,
                global_participant_id=global_participant_id,
                country_iso2=country_4,
            )

        size = handler.handle(
            GetAudienceSizeRequest(
                identity=identity,
                fandata_list_ids=[
                    FanDataListId.from_artist_id(global_participant_id),
                ],
                vendor_id=vendor_id,
                subaccount_id=subaccount_id,
                filters=AudienceFilters.model_construct(
                    countries=[country_1, country_2],
                    exclude_countries=True,
                ),
                target=AudienceTarget.ADS,
            )
        )

        assert size == 14