from atlas_um.auth0.services import (
    SyncAuth0Account,
    SyncAuth0AccountExternalStates,
)
from atlas_um.auth0.services import auth0, usm
from atlas_um.consts import AccountStateSource
from atlas_um.helpers.either import Right, Left
from atlas_um.pgdb.auth0_account import Auth0Account, Auth0AccountExternalState
from tests.atlas_um.factories.auth0_account_factory import Auth0AccountFactory
from tests.atlas_um.factories.internal_user_domain_factory import (
    InternalUserDomainFactory,
)
from tests.atlas_um.factories.auth0_user_factory import (
    Auth0UserFactory,
    Auth0RoleDataFactory,
)


class TestSyncAuth0Account:
    def test_execution(self, app, mocker, pgdb_session):
        role = Auth0RoleDataFactory.build()
        user = Auth0UserFactory.build()
        mocker.patch.object(auth0, "get_user").return_value = user
        mocker.patch.object(auth0, "get_user_roles").return_value = [role]
        result = SyncAuth0Account.execute(user_id=user.user_id)
        auth0_account = Auth0Account.query.filter(
            Auth0Account.user_id == user.user_id
        ).first()
        assert result.is_right
        assert user.user_id == result.value.user_id
        assert user.user_id == auth0_account.user_id
        for k, v in user.dict().items():
            saved_v = getattr(auth0_account, k)
            assert saved_v == v, f"Wrong {k}"
        assert len(auth0_account.roles) == 1
        assert auth0_account.roles[0].id == role.id
        assert auth0_account.roles[0].name == role.name
        assert auth0_account.roles[0].description == role.description

    def test_sync_all(self, mocker, pgdb_session):
        user = Auth0UserFactory.build()
        auth0_account_to_cleanup = Auth0AccountFactory.build()
        pgdb_session.add(auth0_account_to_cleanup)
        state = Auth0AccountExternalState()
        state.auth0_account = auth0_account_to_cleanup
        state.source = AccountStateSource.USM.value
        state.is_active = False
        pgdb_session.add(state)
        pgdb_session.commit()
        id_to_cleanup = auth0_account_to_cleanup.id
        mocked_execute = mocker.patch.object(SyncAuth0Account, "execute")
        mocker.patch.object(auth0, "list_users_ids").return_value = [
            user.user_id
        ]
        mocker.patch.object(auth0, "get_user_roles").return_value = []
        SyncAuth0Account.sync_all()
        assert mocked_execute.call_args_list == [
            mocker.call(user_id=user.user_id)
        ]
        assert not Auth0Account.query.filter(
            Auth0Account.id == id_to_cleanup
        ).count()


class TestSyncAuth0AccountExternalStates:
    def test_execution_new_active_state(
        self, app, mocker, faker, pgdb_session
    ):
        auth0_account = Auth0AccountFactory.build()
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        usm_data = {
            "givenName": faker.first_name(),
            "surname": faker.last_name(),
            "country": faker.pystr(),
            "jobTitle": faker.pystr(),
        }
        mocker.patch.object(usm, "get_user").return_value = Right(usm_data)
        result = SyncAuth0AccountExternalStates.execute(
            auth0_account=auth0_account
        )
        assert result.is_right
        assert (
            result.value
            == Auth0AccountExternalState.query.filter(
                Auth0AccountExternalState.auth0_account_id == auth0_account.id,
                Auth0AccountExternalState.is_active == True,  # noqa
            ).all()
        )
        assert result.value[0].is_active

    def test_execution_updated_not_active_state(
        self, app, mocker, faker, pgdb_session
    ):
        auth0_account = Auth0AccountFactory.build()
        state = Auth0AccountExternalState()
        state.auth0_account = auth0_account
        state.source = AccountStateSource.USM.value
        state.is_active = True
        pgdb_session.add(auth0_account)
        pgdb_session.add(state)
        pgdb_session.commit()
        usm_data = {"success": False, "message": faker.pystr()}
        mocker.patch.object(usm, "get_user").return_value = Left(usm_data)
        mocker.patch.object(usm, "lookup_user").return_value = Left(usm_data)
        result = SyncAuth0AccountExternalStates.execute(
            auth0_account=auth0_account
        )
        assert result.is_right
        assert (
            result.value
            == Auth0AccountExternalState.query.filter(
                Auth0AccountExternalState.auth0_account_id == auth0_account.id,
                Auth0AccountExternalState.is_active == False,  # noqa
            ).all()
        )
        assert not result.value[0].is_active

    def test_execution_updated_not_active_state_internal_domain(
        self, app, mocker, faker, pgdb_session
    ):
        internal_domain = InternalUserDomainFactory.build()
        pgdb_session.add(internal_domain)
        auth0_account = Auth0AccountFactory.build(
            email=f"test@{internal_domain.domain}"
        )
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        usm_data = {"success": False, "message": faker.pystr()}
        mocker.patch.object(usm, "get_user").return_value = Left(usm_data)
        mocker.patch.object(usm, "lookup_user").return_value = Left(usm_data)
        result = SyncAuth0AccountExternalStates.execute(
            auth0_account=auth0_account
        )
        assert result.is_right
        assert (
            result.value
            == Auth0AccountExternalState.query.filter(
                Auth0AccountExternalState.auth0_account_id == auth0_account.id,
                Auth0AccountExternalState.is_active == False,  # noqa
            ).all()
        )
        assert not result.value[0].is_active

    def test_execution_unknown_state(self, app, mocker, faker, pgdb_session):
        auth0_account = Auth0AccountFactory.build()
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        usm_data = {"success": False, "message": faker.pystr()}
        mocker.patch.object(usm, "get_user").return_value = Left(usm_data)
        mocker.patch.object(usm, "lookup_user").return_value = Left(usm_data)
        result = SyncAuth0AccountExternalStates.execute(
            auth0_account=auth0_account
        )
        assert result.is_right
        assert result.value == []
        assert (
            Auth0AccountExternalState.query.filter(
                Auth0AccountExternalState.auth0_account_id == auth0_account.id,
                Auth0AccountExternalState.is_active == False,  # noqa
            ).count()
            == 0
        )