from datetime import date

from atlas_um.pgdb import ClaimName, ClaimValue, Product, pgdb
from atlas_um.pgdb.associations import dna_account_claim_table
from tests.atlas_um import factories


class TestProduct:
    def test_no_claims(self, pgdb_session, faker):
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)

        product = Product(resource_group, account)
        assert len(product.claims) == 0
        assert product.created_at is None
        assert product.updated_at is None
        assert product.is_disabled

    def test_active_claims(self, pgdb_session, faker):
        rand_factor = 5
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)
        claim_names = factories.ClaimNameFactory.create_batch(
            faker.pyint(1, rand_factor), resource_group=resource_group
        )
        claims = {}
        for claim_name in claim_names:
            values = factories.ClaimValueFactory.create_batch(
                faker.pyint(1, rand_factor), claim_name=claim_name
            )
            account.claim_values.extend(values)
            claims[claim_name] = values

        pgdb_session.add(account)
        pgdb_session.commit()

        product = Product(resource_group, account)
        for k, v in claims.items():
            assert set(v) == set(product.claims.get(k))
        assert product.claims.values()
        assert product.created_at.date() == date.today()
        assert product.updated_at.date() == date.today()
        assert not product.is_disabled

    def test_disabled_claims(self, pgdb_session, faker):
        rand_factor = 5
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)
        claim_names = factories.ClaimNameFactory.create_batch(
            faker.pyint(1, rand_factor), resource_group=resource_group
        )
        claims = {}
        for claim_name in claim_names:
            values = factories.ClaimValueFactory.create_batch(
                faker.pyint(1, rand_factor), claim_name=claim_name
            )
            account.claim_values.extend(values)
            claims[claim_name] = values
        pgdb_session.add(account)
        pgdb_session.commit()
        pgdb_session.execute(
            pgdb.update(dna_account_claim_table)
            .where(
                dna_account_claim_table.c.dna_account_id == account.id,
                dna_account_claim_table.c.claim_value_id == ClaimValue.id,
                ClaimValue.claim_name_id == ClaimName.id,
                ClaimName.resource_group_id == resource_group.id,
            )
            .values(is_disabled=True)
        )
        pgdb_session.commit()

        product = Product(resource_group, account)
        for k, v in claims.items():
            assert set(v) == set(product.claims.get(k))
        assert product.created_at.date() == date.today()
        assert product.updated_at.date() == date.today()
        assert product.is_disabled

    def test_name(self, pgdb_session):
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)

        product = Product(resource_group, account)
        assert product.name == resource_group.name

    def test_code(self, pgdb_session):
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)

        product = Product(resource_group, account)
        assert product.code == resource_group.id

    def test_eq(self, pgdb_session):
        account = factories.DNAAccountFactory.build()
        pgdb_session.add(account)
        other_account = factories.DNAAccountFactory.build()
        pgdb_session.add(other_account)
        resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(resource_group)
        other_resource_group = factories.ResourceGroupFactory.build()
        pgdb_session.add(other_resource_group)
        pgdb_session.commit()

        product = Product(resource_group, account)
        other_instance_product = Product(resource_group, account)
        assert product == other_instance_product

        other_account_product = Product(resource_group, other_account)
        assert product != other_account_product

        other_resource_group_product = Product(other_resource_group, account)
        assert product != other_resource_group_product

        other_product = Product(other_resource_group, other_account)
        assert product != other_product