from unittest import mock

import pytest

from dmp.adapters.tiktok.exceptions import TikTokClientError
from dmp.adapters.tiktok.models import User
from dmp.audiences.models import Audience
from dmp.tiktok.models import TikTokAdAccount, TikTokUserAdAccount, TikTokUserConnection
from dmp.tiktok.repositories import TikTokUserConnectionRepository
from dmp.tiktok.services import TikTokUserConnectionService

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


class TestTikTokUserConnectionService:
    @pytest.mark.db
    def test_create_or_update_user_connection_new_connection(
        self,
        service: TikTokUserConnectionService,
        tiktok_client_mock: mock.MagicMock,
        build_model: BuildModel,
        fake: FakerTyped,
        identity_id: str,
    ) -> None:
        token = fake.plain_token()
        user = build_model(User)
        tiktok_client_mock.get_user.return_value = user
        user_connection = service.create_or_update_user_connection(
            identity_id=identity_id, access_token=token
        )

        assert user_connection
        assert user_connection.is_valid
        assert user_connection.user_id == user.core_user_id
        assert user_connection.user_name == user.display_name
        assert user_connection.identity_id == identity_id

    @pytest.mark.db
    def test_create_or_update_user_connection_existed_connection(
        self,
        service: TikTokUserConnectionService,
        tiktok_client_mock: mock.MagicMock,
        build_model: BuildModel,
        create_model: CreateModel,
        fake: FakerTyped,
        identity_id: str,
    ) -> None:
        user = build_model(User)
        existed_user_connection = create_model(
            TikTokUserConnection,
            identity_id=identity_id,
            user_id=user.core_user_id,
            is_valid=False,
        )

        token = fake.plain_token()
        user = build_model(User)
        tiktok_client_mock.get_user.return_value = user
        user_connection = service.create_or_update_user_connection(
            identity_id=identity_id, access_token=token
        )

        assert user_connection
        assert user_connection.is_valid
        assert user_connection.user_id == user.core_user_id
        assert user_connection.user_name == user.display_name
        assert user_connection.user_picture == user.avatar_url
        assert user_connection.identity_id == identity_id
        assert user_connection.token != existed_user_connection.token

    @pytest.mark.db
    def test_get_active_audience_sharing_connection(
        self,
        service: TikTokUserConnectionService,
        tiktok_client_mock: mock.MagicMock,
        build_model: BuildModel,
        create_model: CreateModel,
    ) -> None:
        audience = create_model(Audience)
        ad_account = create_model(TikTokAdAccount)
        user_connection = create_model(
            TikTokUserConnection, is_valid=True, ad_accounts=[ad_account]
        )
        create_model(
            TikTokUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=user_connection.identity_id,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )

        tiktok_client_mock.get_user.return_value = build_model(User)

        ad_account_connection = service.get_active_audience_sharing_connection(
            audience_id=audience.id,
            ad_account_id=ad_account.id,
            identity_id=user_connection.identity_id,
        )

        assert ad_account_connection == user_connection

    @pytest.mark.db
    def test_test_get_active_audience_sharing_connection_disconnect_user(
        self,
        service: TikTokUserConnectionService,
        user_connection_repository: TikTokUserConnectionRepository,
        tiktok_client_mock: mock.MagicMock,
        create_model: CreateModel,
    ) -> None:
        audience = create_model(Audience)
        ad_account = create_model(TikTokAdAccount)
        user_connection = create_model(
            TikTokUserConnection, is_valid=True, ad_accounts=[ad_account]
        )
        create_model(
            TikTokUserAdAccount,
            ad_account_id=ad_account.id,
            identity_id=user_connection.identity_id,
            vendor_id=audience.vendor_id,
            subaccount_id=audience.subaccount_id,
        )

        tiktok_client_mock.get_user.side_effect = TikTokClientError

        ad_account_connection = service.get_active_audience_sharing_connection(
            audience_id=audience.id,
            ad_account_id=ad_account.id,
            identity_id=user_connection.identity_id,
        )

        assert not ad_account_connection

        result = user_connection_repository.get(user_connection.id)

        assert result
        assert not result.is_valid