from datetime import timedelta

import pytest
from fansifter_common.utils import timezone

from dmp.adapters.features import AUDIENCE_ALLOW_AUDIENCE_SHARING_TO_ALL_AD_ACCOUNTS
from dmp.audiences.models import Audience
from dmp.meta.models import MetaAdAccount, MetaUserAdAccount, MetaUserConnection
from dmp.meta.repositories import MetaUserConnectionRepository

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


class TestMetaUserConnectionRepository:
    @pytest.mark.db
    def test_get_by_identity_id_or_none(
        self, repository: MetaUserConnectionRepository, fake: FakerTyped
    ) -> None:
        identity_id = fake.uuid4_string()

        user_connection = repository.get_by_identity_id(identity_id)

        assert user_connection is None

    @pytest.mark.db
    def test_get_by_identity_id_or_none_return_user_connection(
        self,
        repository: MetaUserConnectionRepository,
        create_model: CreateModel,
        fake: FakerTyped,
    ) -> None:
        identity_id = fake.uuid4_string()

        user_connection = create_model(MetaUserConnection, identity_id=identity_id)

        result = repository.get_by_identity_id(identity_id)

        assert result
        assert result.id == user_connection.id
        assert result.identity_id == identity_id

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id(
        self,
        repository: MetaUserConnectionRepository,
        create_model: CreateModel,
        fake: FakerTyped,
    ) -> None:
        identity_id_1 = fake.uuid4_string()
        identity_id_2 = fake.uuid4_string()

        ad_account = create_model(MetaAdAccount)
        audience = create_model(Audience)

        user_connection = create_model(
            MetaUserConnection,
            identity_id=identity_id_1,
            is_valid=True,
            ad_accounts=[ad_account],
        )
        create_model(
            MetaUserConnection,
            identity_id=identity_id_2,
            is_valid=True,
            ad_accounts=[ad_account],
        )

        create_model(
            MetaUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=identity_id_1,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )

        user_connections = repository.find_active_by_audience_and_ad_account_id(
            audience_id=audience.id,
            ad_account_id=ad_account.id,
            identity_id=identity_id_1,
        )

        assert user_connections == [
            user_connection,
        ]

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_shared(
        self,
        repository: MetaUserConnectionRepository,
        create_model: CreateModel,
        fake: FakerTyped,
    ) -> None:
        identity_id_1 = fake.uuid4_string()
        identity_id_2 = fake.uuid4_string()

        audience = create_model(Audience)
        ad_account = create_model(MetaAdAccount)

        user_connection_1 = create_model(
            MetaUserConnection,
            identity_id=identity_id_1,
            is_valid=True,
            ad_accounts=[ad_account],
            updated_at=timezone.now(),
        )
        user_connection_2 = create_model(
            MetaUserConnection,
            identity_id=identity_id_2,
            is_valid=True,
            ad_accounts=[ad_account],
            updated_at=timezone.now() + timedelta(seconds=10),
        )

        create_model(
            MetaUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=identity_id_1,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )
        create_model(
            MetaUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=identity_id_2,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )

        user_connections = repository.find_active_by_audience_and_ad_account_id(
            audience_id=audience.id,
            ad_account_id=ad_account.id,
            identity_id=identity_id_2,
        )

        assert user_connections == [
            user_connection_2,
            user_connection_1,
        ]

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_empty(
        self,
        repository: MetaUserConnectionRepository,
        fake: FakerTyped,
    ) -> None:
        user_connections = repository.find_active_by_audience_and_ad_account_id(
            audience_id=fake.uuid4_string(),
            ad_account_id=fake.uuid4_string(),
            identity_id=fake.uuid4_string(),
        )

        assert user_connections == []

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_of_different_vendor(
        self,
        repository: MetaUserConnectionRepository,
        create_model: CreateModel,
        fake: FakerTyped,
        enable_features: EnableFeatures,
    ) -> None:
        identity_id = fake.uuid4_string()
        audience_vendor_id = 1000
        ad_account_vendor_id = 2000

        audience = create_model(Audience, vendor_id=audience_vendor_id, subaccount_id=0)
        ad_account = create_model(MetaAdAccount)

        user_connection = create_model(
            MetaUserConnection,
            identity_id=identity_id,
            is_valid=True,
            ad_accounts=[ad_account],
            updated_at=timezone.now(),
        )

        create_model(
            MetaUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=identity_id,
            vendor_id=ad_account_vendor_id,
            subaccount_id=0,
        )

        with enable_features([AUDIENCE_ALLOW_AUDIENCE_SHARING_TO_ALL_AD_ACCOUNTS]):
            user_connections = repository.find_active_by_audience_and_ad_account_id(
                audience_id=audience.id,
                ad_account_id=ad_account.id,
                identity_id=identity_id,
                vendor_ids=[audience_vendor_id, ad_account_vendor_id],
            )

        assert user_connections == [user_connection]