serializers2

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

from django.contrib.auth import get_user_model
from django.db.models import Q
from rest_framework.authtoken.models import Token
from django.utils.translation import ugettext_lazy as _
from rest_framework import serializers
from apps.contrib.api.exceptions import ValidationError, NotFound
from apps.auths.api.v1 import codes


# 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 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


def update_user_from_serializer(user, serializer):
    if "first_name" in serializer.validated_data:
        user.first_name = serializer.validated_data["first_name"]

    if "sur_name" in serializer.validated_data:
        user.sur_name = serializer.validated_data["sur_name"]

    if "last_name" in serializer.validated_data:
        user.last_name = serializer.validated_data["last_name"]

    if "husband_name" in serializer.validated_data:
        user.husband_name = serializer.validated_data["husband_name"]

    if "id_person" in serializer.validated_data:
        user.id_person = serializer.validated_data["id_person"]

    if "email" in serializer.validated_data:
        user.email = serializer.validated_data["email"]

    user.dni = serializer.validated_data["dni"]
    user.born_date = serializer.validated_data["born_date"]
    user.phone = serializer.validated_data["phone"]
    return user

# 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


class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserModel

        fields = '__all__'