from datetime import datetime, timedelta

from atlas_um import tasks, consts
from atlas_um.settings import Settings
from tests.atlas_um.factories import DNAAccountFactory, ResourceGroupFactory


class TestSyncDNAAccountWithUSM:
    def test_success(self, pgdb_session, mocker):
        dna_account = DNAAccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.commit()
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services.SyncDNAAccountWithUSM.execute"
        )
        tasks.sync_dna_account_with_usm(dna_account.id)
        service_expects = mocker.call(dna_account=dna_account)
        assert mocked_service.call_args_list == [service_expects]

    def test_failure_wrong_id(self, pgdb_session, mocker):
        dna_account = DNAAccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.commit()
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services.SyncDNAAccountWithUSM.execute"
        )
        tasks.sync_dna_account_with_usm(dna_account.id + 1)
        assert not mocked_service.called


class TestSendDNAInvitation:
    def test_success(self, pgdb_session, mocker):
        resource_group = ResourceGroupFactory.build()
        pgdb_session.add(resource_group)
        dna_account = DNAAccountFactory.build()
        admin_dna_account = DNAAccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.add(admin_dna_account)
        pgdb_session.commit()
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services.SendDNAInvitationService.execute"
        )
        tasks.send_dna_invitation(
            dna_account.id, admin_dna_account.id, resource_group.id
        )
        service_expects = mocker.call(
            dna_account=dna_account,
            admin_dna_account=admin_dna_account,
            resource_group=resource_group,
        )
        assert mocked_service.call_args_list == [service_expects]

    def test_failure_wrong_id(self, pgdb_session, mocker):
        dna_account = DNAAccountFactory.build()
        admin_dna_account = DNAAccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.add(admin_dna_account)
        pgdb_session.commit()
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services.SendDNAInvitationService.execute"
        )
        tasks.send_dna_invitation(dna_account.id + 3, admin_dna_account.id + 4)
        assert not mocked_service.called


class TestSyncInternalDomainsWithUSM:
    def test_success(self, pgdb_session, mocker):
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services."
            "SyncInternalUserDomainsWithUSM.execute"
        )
        tasks.sync_internal_domains_with_usm()
        mocked_service.assert_called_once()


class TestAccessExpirationNotificationByDnaAccount:
    def test_success(self, pgdb_session, redis_session, mocker):
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services."
            "SendDNAAccessExpirationNotificationService.execute"
        )
        dna_account = DNAAccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.commit()
        tasks.task_send_access_expiration_notification_by_dna_account(
            dna_account.id,
        )
        mocked_service.assert_called_once_with(dna_account=dna_account)

    def test_duplicate_sending_notification(
        self, pgdb_session, redis_session, mocker
    ):
        mocked_task = mocker.patch(
            "atlas_um.tasks."
            "task_send_access_expiration_notification_by_dna_account.delay"
        )
        dna_account = DNAAccountFactory.build(
            expiration_date=(
                datetime.now().date()
                + timedelta(days=Settings.ACCOUNTS_EXPIRATION_NOTIFY_DAYS - 1)
            )
        )
        pgdb_session.add(dna_account)
        pgdb_session.commit()
        tasks.task_orchestrate_send_access_expiration_notifications()
        mocked_task.assert_called_once_with(dna_account.id)
        redis_session.setex(
            f"{consts.ACCOUNTS_EXPIRATION_NOTIFY_REDIS_KEY}-"
            f"{dna_account.expiration_date.strftime('%y_%m_%d')}-"
            f"{dna_account.id}",
            60 * 60 * 24 * Settings.ACCOUNTS_EXPIRATION_NOTIFY_DAYS,
            datetime.now().date().strftime("%d/%m/%y"),
        )

        # call one more (notification will not be sent)
        tasks.task_orchestrate_send_access_expiration_notifications()
        assert mocked_task.call_count == 1


class TestSyncAuth0AccountsTask:
    def test_success(self, mocker):
        mocked_service = mocker.patch(
            "atlas_um.auth0.services.SyncAuth0Account.sync_all"
        )
        tasks.sync_auth0_accounts_task()
        mocked_service.assert_called_once()


class TestSyncAuth0AccountsExternalStateTask:
    def test_success(self, mocker):
        mocked_service = mocker.patch(
            "atlas_um.auth0.services.SyncAuth0AccountExternalStates.sync_all"
        )
        tasks.sync_auth0_accounts_external_state_task()
        mocked_service.assert_called_once()


class TestSyncDNAAccountsExternalStateTask:
    def test_success(self, mocker):
        mocked_service = mocker.patch(
            "atlas_um.dna_accounts.services.SyncDNAAccountExternalStates.sync_all"  # noqa
        )
        tasks.sync_dna_accounts_external_state_task()
        mocked_service.assert_called_once()