from django.core.validators import RegexValidator
from oauth2_provider.models import get_access_token_model
from rest_framework import serializers

from apps.users.models import User
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from unidecode import unidecode

from utils.exceptions import UnprocessableEntity

phone_number_validator = RegexValidator(regex=r'^\+98[1-9]\d{9}$', message=_(
        "Phone number must be entered in the format: '+989999999999'."
    ),)
class PublicUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('avatar', 'name', 'username', "first_name", "last_name", "uuid")
        read_only_fields = ['avatar', 'name', 'username', 'first_name', 'last_name', "uuid"]


class AccountSerializer(serializers.ModelSerializer):
    phone_number = serializers.CharField(validators=[phone_number_validator], required=False, read_only=True)
    class Meta:
        model = User
        fields = (
            "uuid",
            'username',
            'email',
            'phone_number',
            "first_name",
            "last_name",
            'name',
            'avatar',
            'gender',
            'education_degree',
            'education_field',
            'birthdate',
            'iban',
            'iban_verified',
            # 'country',
            'province',
            'province_name',
            'city',
            'city_name',
            'postal_code',
            'address',
            )
        read_only_fields = ['uuid', 'phone_number', 'iban_verified', 'province_name', 'city_name',]


class RequestOTPSerializer(serializers.ModelSerializer):
    phone_number = serializers.CharField(required=True, validators=[phone_number_validator])
    ttl = serializers.SerializerMethodField()

    class Meta:
        model = User
        fields = (
            'phone_number',
            'otp_expire',
            'ttl'
            )

        read_only_fields = ['otp_expire', 'ttl']

    def validate(self, attrs):
        attrs['phone_number'] = unidecode(attrs['phone_number'])
        return attrs

    def save(self, **kwargs):
        # TODO: move it to query set
        validated_data = self.validated_data
        user = User.objects.filter(phone_number=validated_data['phone_number']).first()
        if not user:
            validated_data['username'] = validated_data['phone_number']
            user = User.objects.create_user(**validated_data)

        if not user.otp_is_valid():
            user.set_otp()
            user.send_otp()

        self.instance = user
        return user

    def get_ttl(self, obj: User):
        if obj.otp_expire > timezone.now():
            ttl = obj.otp_expire - timezone.now()
            result = ttl.total_seconds()

        else:
            result = 0

        return result


class RequestOTTSerializer(serializers.ModelSerializer):
    application = serializers.CharField(required=True, write_only=True)
    class Meta:
        model = User
        fields = (
            'application',
            'ott',
            'ott_expire',
            )

        read_only_fields = ['ott', 'ott_expire']


class UserInquirySerializer(serializers.ModelSerializer):
    phone_number = serializers.CharField(required=True, validators=[phone_number_validator])

    class Meta:
        model = User
        # fields = ('avatar', 'name', 'username', "first_name", "last_name", "uuid", 'phone_number')
        # read_only_fields = ['avatar', 'name', 'username', 'first_name', 'last_name', "uuid"]

        fields = ("uuid", 'phone_number')
        read_only_fields = ["uuid"]

    def save(self, **kwargs):
        # TODO: move it to query set
        validated_data = self.validated_data
        user = User.objects.filter(phone_number=validated_data['phone_number']).first()
        if not user:
            user = User.objects.create_user(**validated_data)

        self.instance = user
        return user


class ChangePasswordSerializer(serializers.Serializer):
    old_password = serializers.CharField(required=True)
    old_password_field = serializers.CharField(default='password')
    new_password = serializers.CharField(required=True)


AccessToken = get_access_token_model()
class SessionSerializer(serializers.ModelSerializer):
    is_current = serializers.SerializerMethodField()

    def get_is_current(self, obj):
        request = self.context.get('request')
        token = request and request.auth and request.auth.token
        if token == obj.token:
            result = True

        else:
            result = False

        return result


    class Meta:
        model = AccessToken
        fields = ('uuid', 'created', "detail", "is_current")
        read_only_fields = ['uuid', 'created', "detail", "is_current"   ]


# TODO: better solution
# this is a proxy api for submit event for promotion
class ReferralSetSerializer(serializers.Serializer):
    referral = serializers.UUIDField()