from wtforms import fields, validators
from wtforms_alchemy.validators import Unique, ValidationError
from wtforms_alchemy.fields import QuerySelectField

from atlas_um import pgdb
from atlas_um.helpers.forms import BaseForm
from atlas_um.helpers.fields import JSONField
from atlas_um.helpers.validators import UniqueSlug
from atlas_um.tokens.claim_values_serializers import RegisteredSerializers
from atlas_um.settings import Settings


class BusinessUnitForm(BaseForm):
    name = fields.StringField(
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(pgdb.BusinessUnit.name, message="Name already exists."),
            UniqueSlug(pgdb.BusinessUnit.name, pgdb.BusinessUnit.slug),
        ]
    )
    is_active = fields.BooleanField()


class JobCategoryForm(BaseForm):
    name = fields.StringField(
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(pgdb.JobCategory.name, message="Name already exists."),
            UniqueSlug(pgdb.JobCategory.name, pgdb.JobCategory.slug),
        ]
    )
    is_active = fields.BooleanField()


class PersonnelTypeForm(BaseForm):
    name = fields.StringField(
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(pgdb.PersonnelType.name, message="Name already exists."),
            UniqueSlug(pgdb.PersonnelType.name, pgdb.PersonnelType.slug),
        ]
    )
    is_active = fields.BooleanField()


class TagForm(BaseForm):
    name = fields.StringField(
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(pgdb.Tag.name, message="Name already exists."),
            UniqueSlug(pgdb.Tag.name, pgdb.Tag.slug),
        ]
    )
    is_active = fields.BooleanField()


class ResourceGroupForm(BaseForm):
    name = fields.StringField(
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(pgdb.ResourceGroup.name, message="Name already exists."),
            UniqueSlug(
                pgdb.ResourceGroup.name, pgdb.ResourceGroup.namespace_url
            ),
            UniqueSlug(
                pgdb.ResourceGroup.name, pgdb.ResourceGroup.external_id
            ),
        ]
    )
    external_id = fields.StringField(
        validators=[
            validators.Optional(),
            Unique(pgdb.ResourceGroup.external_id),
        ]
    )
    service_url = fields.StringField(
        validators=[validators.Optional(), validators.URL(require_tld=False)]
    )
    session_ttl = fields.IntegerField(
        default=Settings.DEFAULT_REFRESH_TOKEN_TTL
    )
    active_session_ttl = fields.IntegerField(
        default=Settings.DEFAULT_REFRESH_TOKEN_TTL
    )
    is_active = fields.BooleanField()

    def validate_session_ttl(self, field):
        if not field.data or field.data <= 0:
            raise ValidationError("Session TTL should be positive number")

    def validate_active_session_ttl(self, field):
        if not field.data or field.data <= 0:
            raise ValidationError(
                "Active session TTL should be positive number"
            )


class InternalUserDomainForm(BaseForm):
    domain = fields.StringField(
        validators=[
            validators.DataRequired(),
            Unique(pgdb.InternalUserDomain.domain),
        ]
    )


class ClaimNameForm(BaseForm):
    resource_group_id = fields.IntegerField()
    friendly = fields.StringField(
        label="Name",
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(
                (pgdb.ClaimName.friendly, pgdb.ClaimName.resource_group_id),
                message="Name already exists.",
            ),
            UniqueSlug(
                pgdb.ClaimName.friendly,
                pgdb.ClaimName.path,
                pgdb.ClaimName.resource_group_id,
            ),
            UniqueSlug(
                pgdb.ClaimName.friendly,
                pgdb.ClaimName.external_id,
                pgdb.ClaimName.resource_group_id,
            ),
        ],
    )
    external_id = fields.StringField(
        validators=[
            validators.Optional(),
            Unique(
                (pgdb.ClaimName.external_id, pgdb.ClaimName.resource_group_id)
            ),
        ]
    )
    claim_values_serializer = fields.SelectField(
        validators=[validators.Optional()],
        choices=[s.name for s in RegisteredSerializers],
        default=RegisteredSerializers.BooleanAnd.name,
    )
    claim_values_source = QuerySelectField(
        query_factory=lambda: pgdb.ClaimName.query.filter_global().active(),
        validators=[validators.Optional()],
        allow_blank=True,
        blank_text="N/A",
    )
    parent = QuerySelectField(
        query_factory=lambda: pgdb.ClaimName.query.active(),
        validators=[validators.Optional()],
        allow_blank=True,
        blank_text="N/A",
    )
    optional = fields.BooleanField()
    is_active = fields.BooleanField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.parent.query = self.parent.query_factory().by_resource_group_id(
            self.data.get("resource_group_id")
        )

    def validate_holder(self, field):
        if self.obj and field.data == self.obj:
            raise ValidationError("Can't assign self")


class ClaimValueForm(BaseForm):
    claim_name_id = fields.IntegerField()
    friendly = fields.StringField(
        label="Name",
        validators=[
            validators.DataRequired(message="Name is required"),
            Unique(
                (pgdb.ClaimValue.friendly, pgdb.ClaimValue.claim_name_id),
                message="Name already exists.",
            ),
            UniqueSlug(
                pgdb.ClaimValue.friendly,
                pgdb.ClaimValue.external_id,
                pgdb.ClaimValue.claim_name_id,
            ),
        ],
    )
    external_id = fields.StringField(
        validators=[
            validators.Optional(),
            Unique(
                (pgdb.ClaimValue.external_id, pgdb.ClaimValue.claim_name_id)
            ),
        ]
    )
    components = JSONField(validators=[validators.Optional()])
    parent = QuerySelectField(
        query_factory=lambda: pgdb.ClaimValue.query.active(),
        validators=[validators.Optional()],
        allow_blank=True,
        blank_text="N/A",
    )
    is_active = fields.BooleanField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.parent.query = (
            self.parent.query_factory().parents_by_claim_name_id(
                self.data.get("claim_name_id")
            )
        )


class GlobalClaimNameForm(ClaimNameForm):
    def validate(self, *args, **kwargs):
        is_valid = super().validate(*args, **kwargs)
        self["resource_group_id"].data = None
        return is_valid