import itertools
import typing

from flask_sqlalchemy import BaseQuery
from sqlalchemy import or_, and_, select

from atlas_um import pgdb
from atlas_um.pgdb.queries.mixins import DeletedMixin
from atlas_um.pgdb.views import dna_accounts_global_claims


class ClaimValueQuery(BaseQuery, DeletedMixin):
    def by_claim_name(self, claim_name: pgdb.ClaimName):
        global_claims = (
            pgdb.ClaimValue.query.join(
                pgdb.ClaimName,
                pgdb.ClaimName.claim_values_source_id
                == pgdb.ClaimValue.claim_name_id,
            )
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ClaimName.id == claim_name.id)
            .filter(
                pgdb.ClaimName.is_deleted == False,  # noqa
                pgdb.ClaimValue.is_deleted == False,  # noqa
                pgdb.ResourceGroup.is_deleted == False,  # noqa
            )
        )
        return (
            self.join(pgdb.ClaimName)
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ClaimName.id == claim_name.id)
            .union(global_claims)
        )

    def by_claim_name_external_id(
        self, claim_name: pgdb.ClaimName, claim_value_id: str
    ):
        global_claims = (
            pgdb.ClaimValue.query.join(
                pgdb.ClaimName,
                pgdb.ClaimName.claim_values_source_id
                == pgdb.ClaimValue.claim_name_id,
            )
            .filter(pgdb.ClaimName.id == claim_name.id)
            .filter(pgdb.ClaimValue.external_id == claim_value_id)
            .filter(
                pgdb.ClaimName.is_deleted == False,  # noqa
                pgdb.ClaimValue.is_deleted == False,  # noqa
                pgdb.ResourceGroup.is_deleted == False,  # noqa
            )
        )

        return (
            self.join(pgdb.ClaimName)
            .filter(pgdb.ClaimName.id == claim_name.id)
            .filter(pgdb.ClaimValue.external_id == claim_value_id)
            .union(global_claims)
        )

    def global_by_claim_name(self, claim_name: pgdb.ClaimName):
        return (
            self.join(pgdb.ClaimName)
            .filter(pgdb.ClaimName.resource_group_id == None)  # noqa
            .filter(pgdb.ClaimName.id == claim_name.id)
        )

    def by_name_external_ids(self, resource_group_id: str, claim_name_id: str):
        global_claims = (
            pgdb.ClaimValue.query.join(
                pgdb.ClaimName,
                pgdb.ClaimName.claim_values_source_id
                == pgdb.ClaimValue.claim_name_id,
            )
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ResourceGroup.external_id == resource_group_id)
            .filter(pgdb.ClaimName.external_id == claim_name_id)
            .filter(
                pgdb.ClaimName.is_deleted == False,  # noqa
                pgdb.ClaimValue.is_deleted == False,  # noqa
                pgdb.ResourceGroup.is_deleted == False,  # noqa
            )
        )

        return (
            self.join(pgdb.ClaimName)
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ResourceGroup.external_id == resource_group_id)
            .filter(pgdb.ClaimName.external_id == claim_name_id)
            .union(global_claims)
        )

    def by_value_external_ids(
        self, resource_group_id: str, claim_name_id: str, claim_value_id: str
    ):
        global_claims = (
            self.join(
                pgdb.ClaimName,
                pgdb.ClaimName.claim_values_source_id
                == pgdb.ClaimValue.claim_name_id,
            )
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ResourceGroup.external_id == resource_group_id)
            .filter(pgdb.ClaimName.external_id == claim_name_id)
            .filter(pgdb.ClaimValue.external_id == claim_value_id)
        )

        return (
            self.join(pgdb.ClaimName)
            .join(pgdb.ResourceGroup)
            .filter(pgdb.ResourceGroup.external_id == resource_group_id)
            .filter(pgdb.ClaimName.external_id == claim_name_id)
            .filter(pgdb.ClaimValue.external_id == claim_value_id)
            .union(global_claims)
        )

    def by_dna_account_sub_name_external_ids(
        self, sub: str, resource_group_id: str, claim_name_id: str
    ):
        return (
            self.join(dna_accounts_global_claims)
            .distinct()
            .join(pgdb.DNAAccount)
            .join(
                pgdb.ClaimName,
                dna_accounts_global_claims.c.claim_name_id
                == pgdb.ClaimName.id,
            )
            .join(pgdb.ResourceGroup)
            .filter(dna_accounts_global_claims.c.is_disabled == False)  # noqa
            .filter(pgdb.DNAAccount.sub == sub)
            .filter(pgdb.ResourceGroup.external_id == resource_group_id)
            .filter(pgdb.ClaimName.external_id == claim_name_id)
            .filter(pgdb.ClaimName.is_deleted == False)  # noqa
            .filter(pgdb.ClaimValue.is_deleted == False)  # noqa
        )

    def by_dna_account_claim_name(
        self, dna_account, claim_name: pgdb.ClaimName
    ):
        return (
            self.join(dna_accounts_global_claims)
            .distinct()
            .join(pgdb.DNAAccount)
            .join(
                pgdb.ClaimName,
                dna_accounts_global_claims.c.claim_name_id
                == pgdb.ClaimName.id,
            )
            .join(pgdb.ResourceGroup)
            .filter(dna_accounts_global_claims.c.is_disabled == False)  # noqa
            .filter(pgdb.DNAAccount.id == dna_account.id)
            .filter(pgdb.ClaimName.id == claim_name.id)
            .filter(pgdb.ClaimName.is_deleted == False)  # noqa
            .filter(pgdb.ClaimValue.is_deleted == False)  # noqa
        )

    def children_by_dna_account_id_claim_value_id(
        self,
        dna_account_id: typing.Union[str, int],
        claim_value_id: typing.Union[str, int],
    ):
        return self.filter(
            pgdb.ClaimValue.parent_id == claim_value_id,
            pgdb.ClaimValue.id.in_(
                select(dna_accounts_global_claims.c.claim_value_id).filter(
                    dna_accounts_global_claims.c.dna_account_id
                    == dna_account_id,
                )
            ),
        )

    def global_by_name_external_ids(self, claim_name_id: str):
        return (
            self.join(pgdb.ClaimName)
            .filter(pgdb.ClaimName.resource_group_id == None)  # noqa
            .filter(pgdb.ClaimName.external_id == claim_name_id)
        )

    def active(self, is_global=False):
        query = (
            super()
            .active()
            .filter(
                pgdb.ClaimName.is_deleted == False,  # noqa
                pgdb.ClaimValue.claim_name_id == pgdb.ClaimName.id,
            )
        )
        return query

    def deleted(self):
        return (
            super()
            .active()
            .filter(
                or_(
                    and_(
                        pgdb.ResourceGroup.is_deleted == True,  # noqa
                        pgdb.ClaimName.resource_group_id
                        == pgdb.ResourceGroup.id,
                    ),
                    and_(
                        pgdb.ClaimName.is_deleted == True,  # noqa
                        pgdb.ClaimValue.claim_name_id == pgdb.ClaimName.id,
                    ),
                )
            )
        )

    def parents_by_claim_name_id(self, claim_name_id):
        parent_ids = pgdb.pgdb.session.query(pgdb.ClaimName.parent_id).filter(
            pgdb.ClaimName.id == claim_name_id
        )
        return self.filter(
            pgdb.ClaimValue.claim_name_id.in_(parent_ids)
        ).order_by(pgdb.ClaimValue.friendly)

    def tree_by_claim_name(self, claim_name):
        values = (
            self.active()
            .by_claim_name(claim_name)
            .order_by(pgdb.ClaimValue.parent)
            .all()
        )
        tree = {}
        with_parents = (v for v in values if v.parent)
        without_parents = (v for v in values if not v.parent)
        sorted_values = itertools.chain(
            sorted(with_parents, key=lambda v: v.parent.friendly),
            sorted(without_parents, key=lambda v: v.friendly),
        )
        for value in sorted_values:
            if value.parent:
                tree.setdefault(value.parent, []).append(value)
            else:
                tree.setdefault(None, []).append(value)
        return tree