import pytest

from dmp.meta.dtos import AssignMetaUserAdAccountLabelData
from dmp.meta.exceptions import InvalidMetaAdAccountId, MetaConnectionNotFoundError
from dmp.meta.handlers import (
    AssignLabelsToMetaUserAdAccountsHandler,
    AssignLabelsToMetaUserAdAccountsRequest,
)
from dmp.meta.models import (
    MetaAdAccount,
    MetaAdReportingConnection,
    MetaUserAdAccount,
    MetaUserConnection,
)
from dmp.meta.repositories import MetaUserAdAccountRepository

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


class TestAssignLabelsToMetaUserAdAccountsHandler:
    @pytest.mark.db
    def test_assign_labels_to_the_user_ad_account(
        self,
        handler: AssignLabelsToMetaUserAdAccountsHandler,
        user_ad_account_repository: MetaUserAdAccountRepository,
        create_model: CreateModel,
        identity_id: str,
        fake: FakerTyped,
    ) -> None:
        ad_account = create_model(MetaAdAccount)
        ad_account2 = create_model(MetaAdAccount)
        create_model(MetaAdAccount)
        user_ad_account = create_model(
            MetaUserAdAccount,
            identity_id=identity_id,
            ad_account_id=ad_account.id,
            vendor_id=fake.integer(),
            subaccount_id=fake.integer(),
        )

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

        new_vendor_id = fake.integer()
        new_subaccount_id = fake.integer()

        handler.handle(
            AssignLabelsToMetaUserAdAccountsRequest(
                identity_id=identity_id,
                assignments=[
                    AssignMetaUserAdAccountLabelData(
                        ad_account_id=ad_account.id,
                        vendor_id=user_ad_account.vendor_id,
                        subaccount_id=user_ad_account.subaccount_id,
                    ),
                    AssignMetaUserAdAccountLabelData(
                        ad_account_id=ad_account2.id,
                        vendor_id=new_vendor_id,
                        subaccount_id=new_subaccount_id,
                    ),
                ],
            )
        )

        user_ad_accounts = user_ad_account_repository.find_by_identity_id(
            identity_id=identity_id
        )

        assert user_ad_accounts
        assert len(user_ad_accounts) == 2
        assert user_ad_accounts[0].ad_account_id == ad_account.id
        assert user_ad_accounts[0].vendor_id == user_ad_account.vendor_id
        assert user_ad_accounts[0].subaccount_id == user_ad_account.subaccount_id

        assert user_ad_accounts[1].ad_account_id == ad_account2.id
        assert user_ad_accounts[1].vendor_id == new_vendor_id
        assert user_ad_accounts[1].subaccount_id == new_subaccount_id

    @pytest.mark.db
    def test_assign_labels_to_the_user_ad_account_with_invalid_ad_account_id(
        self,
        handler: AssignLabelsToMetaUserAdAccountsHandler,
        create_model: CreateModel,
        identity_id: str,
        fake: FakerTyped,
    ) -> None:
        ad_account = create_model(MetaAdAccount)

        with pytest.raises(InvalidMetaAdAccountId):
            handler.handle(
                AssignLabelsToMetaUserAdAccountsRequest(
                    identity_id=identity_id,
                    assignments=[
                        AssignMetaUserAdAccountLabelData(
                            ad_account_id=ad_account.id,
                            vendor_id=fake.integer(),
                            subaccount_id=fake.integer(),
                        ),
                        AssignMetaUserAdAccountLabelData(
                            ad_account_id=fake.pystr(),
                            vendor_id=fake.integer(),
                            subaccount_id=fake.integer(),
                        ),
                    ],
                )
            )

    @pytest.mark.db
    def test_assign_labels_to_the_user_ad_account_with_missed_connection_for_ad_account(
        self,
        handler: AssignLabelsToMetaUserAdAccountsHandler,
        create_model: CreateModel,
        identity_id: str,
        fake: FakerTyped,
    ) -> None:
        ad_account = create_model(MetaAdAccount)
        ad_account2 = create_model(MetaAdAccount)
        create_model(MetaAdAccount)
        user_ad_account = create_model(
            MetaUserAdAccount,
            identity_id=identity_id,
            ad_account_id=ad_account.id,
            vendor_id=fake.integer(),
            subaccount_id=fake.integer(),
        )

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

        new_vendor_id = fake.integer()
        new_subaccount_id = fake.integer()

        with pytest.raises(MetaConnectionNotFoundError):
            handler.handle(
                AssignLabelsToMetaUserAdAccountsRequest(
                    identity_id=identity_id,
                    assignments=[
                        AssignMetaUserAdAccountLabelData(
                            ad_account_id=ad_account.id,
                            vendor_id=user_ad_account.vendor_id,
                            subaccount_id=user_ad_account.subaccount_id,
                        ),
                        AssignMetaUserAdAccountLabelData(
                            ad_account_id=ad_account2.id,
                            vendor_id=new_vendor_id,
                            subaccount_id=new_subaccount_id,
                        ),
                    ],
                )
            )