serializers

# -*- encoding:utf-8 -*-

from django.contrib.auth import get_user_model
from django.conf import settings
from django.db.models import Q
from django.utils.translation import ugettext_lazy as _
from rest_framework.authtoken.models import Token

from rest_framework import serializers

from apps.auths.models import UserAction
from apps.contrib.utils.strings import get_uuid, get_lapse
from apps.auths import codes
from apps.contrib.api.exceptions import ValidationError, NotFound
from apps.users.forms import JWT_TOKEN_KEY, session_request, sereci_validation

try:
    from allauth.account import app_settings as allauth_settings
    from allauth.utils import (
        email_address_exists, get_username_max_length)
    from allauth.account.adapter import get_adapter
    from allauth.account.utils import setup_user_email
except ImportError:
    raise ImportError("allauth needs to be added to INSTALLED_APPS.")
from constance import config
from django.core.cache import cache

UserModel = get_user_model()


class LoginSerializer(serializers.Serializer):
    login = serializers.CharField()
    password = serializers.CharField(style={'input_type': 'password'})

    def validate(self, attrs):
        login = attrs.get('login')
        password = attrs.get('password')

        user = None

        if UserModel.objects.filter(Q(username=login) | Q(email=login)).exists():
            user = UserModel.objects.get(Q(username=login) | Q(email=login))
            if not user.is_active:
                raise ValidationError(**codes.INACTIVE_ACCOUNT)

            if "allauth" in settings.INSTALLED_APPS:
                from allauth.account import app_settings
                if hasattr(settings, "EMAIL_VERIFICATION") and \
                   settings.EMAIL_VERIFICATION == app_settings.EmailVerificationMethod.MANDATORY:

                    email_address = user.emailaddress_set.get(email=user.email)
                    if not email_address.verified:
                        raise ValidationError(**codes.UNVERIFIED_EMAIL)

            if not user.check_password(password):
                raise ValidationError(**codes.INVALID_CREDENTIALS)

            attrs['user'] = user
            return attrs
        else:
            raise ValidationError(**codes.INVALID_CREDENTIALS)


class PasswordResetSerializer(serializers.Serializer):
    """
    Serializer for requesting a password reset e-mail.
    """
    login = serializers.CharField()
    redirect_uri = serializers.URLField(required=False)

    def validate(self, attrs):
        if not UserModel.objects.filter(Q(username=attrs["login"]) | Q(email=attrs["login"])).exists():
            raise NotFound(**codes.USER_NOT_FOUND)

        user = UserModel.objects.get(Q(username=attrs["login"]) | Q(email=attrs["login"]))

        if UserAction.objects.filter(user=user, type=UserAction.ACTION_RESET_PASSWORD).exists():
            action = UserAction.objects.get(user=user, type=UserAction.ACTION_RESET_PASSWORD)
        else:
            action = UserAction(user=user, type=UserAction.ACTION_RESET_PASSWORD)

        action.token = get_uuid()
        action.creation_date, action.expiration_date = get_lapse()
        action.save()


        attrs["action"] = action
        return attrs


class PasswordResetConfirmSerializer(serializers.Serializer):
    """
    Serializer for requesting a password reset e-mail.
    """
    token = serializers.CharField()
    password1 = serializers.CharField(max_length=128)
    password2 = serializers.CharField(max_length=128)

    def validate(self, attrs):

        if not UserAction.objects.filter(token=attrs["token"],
                                         type=UserAction.ACTION_RESET_PASSWORD).exists():
            raise ValidationError(**codes.INVALID_TOKEN)

        if attrs["password1"] != attrs["password2"]:
            raise ValidationError(**codes.PASSWORD_MISTMATCH)

        action = UserAction.objects.get(token=attrs["token"], type=UserAction.ACTION_RESET_PASSWORD)
        attrs["password"] = attrs["password2"]
        attrs["action"] = action
        return attrs


class RegisterSerializer(serializers.Serializer):

    dni = serializers.CharField()
    born_date = serializers.DateField()
    email = serializers.EmailField(required=allauth_settings.EMAIL_REQUIRED)
    phone = serializers.CharField()
    password = serializers.CharField(write_only=True)

    cleaned_data = None


    def validate_email(self, email):
        email = get_adapter().clean_email(email)
        if allauth_settings.UNIQUE_EMAIL:
            if email and email_address_exists(email):
                raise ValidationError(**codes.UNAVAILABLE_EMAIL)
        return email


    def validate(self, attrs):
        attrs = validate_sereci_data(attrs)
        return attrs


    def save(self, request):
        adapter = get_adapter()
        user = adapter.new_user(request)
        user = update_user_from_serializer(user, self)
        self.cleaned_data = self.validated_data
        adapter.save_user(request, user, self)
        setup_user_email(request, user, [])
        return user


class VerifyEmailSerializer(serializers.Serializer):
    key = serializers.CharField()


class TokenSerializer(serializers.Serializer):
    token = serializers.CharField()

    def validate(self, attrs):

        if not Token.objects.filter(key=attrs['token']).exists():
            raise ValidationError(**codes.INVALID_TOKEN)
        else:
            attrs["token"] = Token.objects.get(key=attrs['token'])

        return attrs