from atlas_um.consts import Products, PRODUCTS_TO_AUTH0_ROLES
from atlas_um.pgdb.queries.accounts_validation import (
    get_accounts_with_statuses_by_emails,
    get_accounts_with_statuses_by_ids,
)
from tests.atlas_um.factories import (
    DNAAccountFactory,
    Auth0AccountFactory,
    ClaimValueFactory,
    Auth0RoleFactory,
)


class TestGetAccountsWithStatusesByEmails:
    def test_both_same_active(self, pgdb_session, faker):
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=None
        )
        auth0_account = Auth0AccountFactory.build(email=email)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(emails=[email])
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_both_same_dna_active(self, pgdb_session, faker):
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=None
        )
        auth0_account = Auth0AccountFactory.build(email=email, blocked=True)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(emails=[email])
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_both_same_auth0_active(self, pgdb_session, faker):
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=faker.past_date()
        )
        auth0_account = Auth0AccountFactory.build(email=email, blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(emails=[email])
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_different_active(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build(blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email]
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, True, auth0_account.last_login),
                (dna_account.email, True, None),
            ],
            key=lambda item: item[0],
        )

    def test_same_email_different_case_active(self, pgdb_session, faker):
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            expiration_date=None, email=email.lower()
        )
        auth0_account = Auth0AccountFactory.build(
            blocked=False, email=email.upper()
        )
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email]
            )
        )
        assert actual_result == [
            (auth0_account.email.lower(), True, auth0_account.last_login)
        ]

    def test_different_dna_active(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build(blocked=True)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email]
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, False, auth0_account.last_login),
                (dna_account.email, True, None),
            ],
            key=lambda item: item[0],
        )

    def test_different_auth0_active(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(
            expiration_date=faker.past_date()
        )
        auth0_account = Auth0AccountFactory.build(blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email]
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, True, auth0_account.last_login),
                (dna_account.email, False, None),
            ],
            key=lambda item: item[0],
        )

    def test_other_email(self, pgdb_session, faker):
        email = faker.email()
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build(blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(emails=[email])
        )
        assert actual_result == []

    def test_both_same_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=None
        )
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(email=email)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[email], filter_products=[product.value]
            )
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_both_same_dna_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=None
        )
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(email=email, blocked=True)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[email], filter_products=[product.value]
            )
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_both_same_auth0_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        email = faker.email()
        dna_account = DNAAccountFactory.build(
            email=email, expiration_date=faker.past_date()
        )
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(email=email, blocked=False)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[email], filter_products=[product.value]
            )
        )
        assert actual_result == [(email, True, auth0_account.last_login)]

    def test_different_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        dna_account = DNAAccountFactory.build(expiration_date=None)
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(blocked=False)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email],
                filter_products=[product.value],
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, True, auth0_account.last_login),
                (dna_account.email, True, None),
            ],
            key=lambda item: item[0],
        )

    def test_different_dna_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        dna_account = DNAAccountFactory.build(expiration_date=None)
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(blocked=True)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email],
                filter_products=[product.value],
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, False, auth0_account.last_login),
                (dna_account.email, True, None),
            ],
            key=lambda item: item[0],
        )

    def test_different_auth0_active_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        dna_account = DNAAccountFactory.build(
            expiration_date=faker.past_date()
        )
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(blocked=False)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(
                emails=[dna_account.email, auth0_account.email],
                filter_products=[product.value],
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.email, True, auth0_account.last_login),
                (dna_account.email, False, None),
            ],
            key=lambda item: item[0],
        )

    def test_other_email_by_products(self, pgdb_session, faker):
        product = Products.DECIBEL
        claim_value = ClaimValueFactory.build(
            claim_name__resource_group__namespace_url=product.value
        )
        auth0_role = Auth0RoleFactory.build(
            name=PRODUCTS_TO_AUTH0_ROLES.get(product)[0]
        )
        pgdb_session.add(claim_value)
        pgdb_session.add(auth0_role)
        email = faker.email()
        dna_account = DNAAccountFactory.build(expiration_date=None)
        dna_account.claim_values = [claim_value]
        auth0_account = Auth0AccountFactory.build(blocked=False)
        auth0_account.roles = [auth0_role]
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_emails(emails=[email])
        )
        assert actual_result == []


class TestGetAccountsWithStatusesByIds:
    def test_both_active_by_ids(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build()
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_ids(
                ids=[dna_account.sub, auth0_account.user_id]
            )
        )
        assert actual_result == sorted(
            [
                (dna_account.sub, True, dna_account.last_login),
                (auth0_account.user_id, True, auth0_account.last_login),
            ],
            key=lambda item: item[0].lower(),
        )

    def test_different_dna_active_by_ids(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build(blocked=True)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_ids(
                ids=[dna_account.sub, auth0_account.user_id]
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.user_id, False, auth0_account.last_login),
                (dna_account.sub, True, None),
            ],
            key=lambda item: item[0].lower(),
        )

    def test_different_auth0_active_by_ids(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(
            expiration_date=faker.past_date()
        )
        auth0_account = Auth0AccountFactory.build(blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_ids(
                ids=[dna_account.sub, auth0_account.user_id]
            )
        )
        assert actual_result == sorted(
            [
                (auth0_account.user_id, True, auth0_account.last_login),
                (dna_account.sub, False, None),
            ],
            key=lambda item: item[0].lower(),
        )

    def test_other_id(self, pgdb_session, faker):
        dna_account = DNAAccountFactory.build(expiration_date=None)
        auth0_account = Auth0AccountFactory.build(blocked=False)
        pgdb_session.add(dna_account)
        pgdb_session.add(auth0_account)
        pgdb_session.commit()
        actual_result = list(
            get_accounts_with_statuses_by_ids(ids=[faker.pystr()])
        )
        assert actual_result == []