import pytest
from dirty_equals import IsList

from dmp.meta.dtos import MetaUserAdAccountLabel
from dmp.meta.models import (
    MetaAdAccount,
    MetaAdReportingConnection,
    MetaUserAdAccount,
    MetaUserConnection,
)
from dmp.meta.repositories import MetaAdAccountRepository

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


class TestMetaAdAccountRepository:
    @pytest.mark.db
    def test_find_by_identity_id_for_assignment(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        ad_account_1 = create_model(
            MetaAdAccount,
            name="ad_account_1",
            business_account_picture_key=None,
        )
        ad_account_2 = create_model(
            MetaAdAccount,
            name="ad_account_2",
            business_account_picture_key=None,
        )
        ad_account_3 = create_model(
            MetaAdAccount,
            name="ad_account_3",
            business_account_picture_key=None,
        )

        user_ad_account_1 = create_model(
            MetaUserAdAccount, identity_id=identity_id, ad_account_id=ad_account_1.id
        )
        user_ad_account_2 = create_model(
            MetaUserAdAccount, identity_id=identity_id, ad_account_id=ad_account_2.id
        )

        create_model(
            MetaUserConnection,
            identity_id=identity_id,
            ad_accounts=[ad_account_1, ad_account_2],
        )
        create_model(
            MetaAdReportingConnection,
            identity_id=identity_id,
            ad_accounts=[ad_account_2, ad_account_3],
        )

        ad_accounts = repository.find_by_identity_id_for_assigment(identity_id)

        assert ad_accounts == [
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_1.id,
                external_id=ad_account_1.external_id,
                name=ad_account_1.name or "",
                business_account_name=ad_account_1.business_account_name,
                business_account_picture=ad_account_1.business_account_picture,
                campaigns_count=ad_account_1.campaigns_count,
                vendor_id=user_ad_account_1.vendor_id,
                subaccount_id=user_ad_account_1.subaccount_id,
            ),
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_2.id,
                external_id=ad_account_2.external_id,
                name=ad_account_2.name or "",
                business_account_name=ad_account_2.business_account_name,
                business_account_picture=ad_account_2.business_account_picture,
                campaigns_count=ad_account_2.campaigns_count,
                vendor_id=user_ad_account_2.vendor_id,
                subaccount_id=user_ad_account_2.subaccount_id,
            ),
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_3.id,
                external_id=ad_account_3.external_id,
                name=ad_account_3.name or "",
                business_account_name=ad_account_3.business_account_name,
                business_account_picture=ad_account_3.business_account_picture,
                campaigns_count=ad_account_3.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
        ]

    @pytest.mark.db
    def test_find_by_identity_id_for_assignment_user_connected(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        ad_account = create_model(
            MetaAdAccount,
            business_account_picture_key=None,
        )

        create_model(
            MetaUserConnection,
            identity_id=identity_id,
            ad_accounts=[ad_account],
        )

        ad_accounts = repository.find_by_identity_id_for_assigment(identity_id)

        assert ad_accounts == [
            MetaUserAdAccountLabel.model_construct(
                id=ad_account.id,
                external_id=ad_account.external_id,
                name=ad_account.name or "",
                business_account_name=ad_account.business_account_name,
                business_account_picture=ad_account.business_account_picture,
                campaigns_count=ad_account.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
        ]

    @pytest.mark.db
    def test_find_by_identity_id_for_assignment_ad_reporting_connected(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        ad_account_1 = create_model(
            MetaAdAccount,
            name="ad_account_1",
            business_account_picture_key=None,
        )
        ad_account_2 = create_model(
            MetaAdAccount,
            name="ad_account_2",
            business_account_picture_key=None,
        )

        create_model(
            MetaAdReportingConnection,
            identity_id=identity_id,
            ad_accounts=[ad_account_1, ad_account_2],
        )

        ad_accounts = repository.find_by_identity_id_for_assigment(identity_id)

        assert ad_accounts == [
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_1.id,
                external_id=ad_account_1.external_id,
                name=ad_account_1.name or "",
                business_account_name=ad_account_1.business_account_name,
                business_account_picture=ad_account_1.business_account_picture,
                campaigns_count=ad_account_1.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_2.id,
                external_id=ad_account_2.external_id,
                name=ad_account_2.name or "",
                business_account_name=ad_account_2.business_account_name,
                business_account_picture=ad_account_2.business_account_picture,
                campaigns_count=ad_account_2.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
        ]

    @pytest.mark.db
    def test_find_by_identity_id_for_association_ad_reporting_no_name_available_yet(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        ad_account_1 = create_model(
            MetaAdAccount,
            name=None,
            business_account_picture_key=None,
        )
        ad_account_2 = create_model(
            MetaAdAccount,
            name=None,
            business_account_picture_key=None,
        )

        create_model(
            MetaAdReportingConnection,
            identity_id=identity_id,
            ad_accounts=[ad_account_1, ad_account_2],
        )

        ad_accounts = repository.find_by_identity_id_for_assigment(identity_id)

        assert ad_accounts == IsList(
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_1.id,
                external_id=ad_account_1.external_id,
                name=ad_account_1.external_id,
                business_account_name=ad_account_1.business_account_name,
                business_account_picture=ad_account_1.business_account_picture,
                campaigns_count=ad_account_1.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
            MetaUserAdAccountLabel.model_construct(
                id=ad_account_2.id,
                external_id=ad_account_2.external_id,
                name=ad_account_2.external_id,
                business_account_name=ad_account_2.business_account_name,
                business_account_picture=ad_account_2.business_account_picture,
                campaigns_count=ad_account_2.campaigns_count,
                vendor_id=None,
                subaccount_id=None,
            ),
            check_order=False,
        )

    @pytest.mark.db
    def test_find_by_identity_id_for_assignment_not_connected(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        ad_account_1 = create_model(MetaAdAccount, name="ad_account_1")
        ad_account_2 = create_model(MetaAdAccount, name="ad_account_2")

        create_model(
            MetaUserAdAccount, identity_id=identity_id, ad_account_id=ad_account_1.id
        )
        create_model(
            MetaUserAdAccount, identity_id=identity_id, ad_account_id=ad_account_2.id
        )

        ad_accounts = repository.find_by_identity_id_for_assigment(identity_id)

        assert ad_accounts == []

    @pytest.mark.db
    def test_find_by_external_ids(
        self, repository: MetaAdAccountRepository, create_model: CreateModel
    ) -> None:
        ad_account_1 = create_model(MetaAdAccount)
        ad_account_2 = create_model(MetaAdAccount)
        create_model(MetaAdAccount)

        result = repository.find_by_external_ids(
            [ad_account_1.external_id, ad_account_2.external_id]
        )

        assert result
        assert len(result) == 2

    @pytest.mark.db
    def test_exists_by_id(
        self,
        repository: MetaAdAccountRepository,
        create_model: CreateModel,
        fake: FakerTyped,
    ) -> None:
        ad_account = create_model(MetaAdAccount)

        assert repository.exists_by_id(ad_account.id)

        assert not repository.exists_by_id(fake.pystr())