from datetime import timedelta

import pytest
from dirty_equals import IsList
from fansifter_common.auth.account import Account
from fansifter_common.utils import timezone

from dmp.audiences.models import Audience
from dmp.google.models import (
    GoogleAdAccount,
    GoogleUserAdAccount,
    GoogleUserConnection,
    GoogleUserConnectionAdAccount,
)
from dmp.google.repositories import GoogleUserConnectionRepository

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


class TestGoogleUserConnectionRepository:
    @pytest.mark.db
    def test_get_by_identity_id_and_user_id_empty(
        self, repository: GoogleUserConnectionRepository, fake: FakerTyped
    ) -> None:
        identity_id = fake.uuid4_string()
        user_id = fake.uuid4_string()

        user_connection = repository.get_by_identity_id_and_user_id(
            identity_id=identity_id, user_id=user_id
        )

        assert user_connection is None

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

        user_connection = create_model(
            GoogleUserConnection,
            identity_id=identity_id,
            user_id=user_id,
        )

        result = repository.get_by_identity_id_and_user_id(
            identity_id=identity_id,
            user_id=user_id,
        )

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

    @pytest.mark.db
    def test_find_by_identity_id_empty(
        self,
        repository: GoogleUserConnectionRepository,
        fake: FakerTyped,
    ) -> None:
        user_connections = repository.find_by_identity_id(
            identity_id=fake.uuid4_string(),
        )

        assert user_connections == []

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

        user_connection_1 = create_model(
            GoogleUserConnection, identity_id=identity_id_1
        )
        user_connection_2 = create_model(
            GoogleUserConnection, identity_id=identity_id_1
        )
        create_model(GoogleUserConnection, identity_id=identity_id_2)

        user_connections = repository.find_by_identity_id(
            identity_id=identity_id_1,
        )

        assert user_connections == IsList(
            user_connection_1,
            user_connection_2,
            check_order=False,
        )

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_prioritize_valid(
        self,
        repository: GoogleUserConnectionRepository,
        create_model: CreateModel,
        build_model: BuildModel,
        identity_id: str,
    ) -> None:
        account = build_model(Account)
        ad_account = create_model(GoogleAdAccount)

        create_model(
            GoogleUserConnection,
            identity_id=identity_id,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=False,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        user_connection = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection.identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        audience = create_model(
            Audience, vendor_id=account.vendor_id, subaccount_id=account.subaccount_id
        )

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

        assert result
        assert result == [user_connection]

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_prioritize_owned(
        self,
        repository: GoogleUserConnectionRepository,
        create_model: CreateModel,
        build_model: BuildModel,
        identity_id: str,
    ) -> None:
        account = build_model(Account)

        ad_account = create_model(GoogleAdAccount)

        user_connection_1 = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection_1.identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        user_connection_2 = create_model(
            GoogleUserConnection,
            identity_id=identity_id,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        user_connection_3 = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection_3.identity_id,
            ad_account_id=ad_account.id,
        )

        audience = create_model(
            Audience, vendor_id=account.vendor_id, subaccount_id=account.subaccount_id
        )

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

        assert result
        assert result == IsList(
            user_connection_2,
            user_connection_1,
            check_order=False,
        )

    @pytest.mark.db
    def test_find_active_by_audience_and_ad_account_id_prioritize_latest(
        self,
        repository: GoogleUserConnectionRepository,
        create_model: CreateModel,
        build_model: BuildModel,
        identity_id: str,
    ) -> None:
        timestamp_1 = timezone.now()
        timestamp_2 = timestamp_1 - timedelta(days=3)
        timestamp_3 = timestamp_1 - timedelta(days=5)

        account = build_model(Account)

        ad_account = create_model(GoogleAdAccount)

        user_connection_1 = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
            updated_at=timestamp_3,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection_1.identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        user_connection_2 = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
            updated_at=timestamp_2,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection_2.identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        user_connection_3 = create_model(
            GoogleUserConnection,
            connection_ad_accounts=[
                GoogleUserConnectionAdAccount(ad_account=ad_account),
            ],
            is_valid=True,
            updated_at=timestamp_1,
        )
        create_model(
            GoogleUserAdAccount,
            identity_id=user_connection_3.identity_id,
            ad_account_id=ad_account.id,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
        )

        audience = create_model(
            Audience, vendor_id=account.vendor_id, subaccount_id=account.subaccount_id
        )

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

        assert result
        assert result == [user_connection_3, user_connection_2, user_connection_1]