"""Account serializer"""
"""Django Imoprt"""
import random
from rest_framework import serializers
from django.contrib.auth.models import User
from rest_framework_simplejwt.tokens import RefreshToken
"""App import"""
from guardian.models import Guardian
from junior.models import Junior
from account.models import UserEmailOtp, DefaultTaskImages, UserDelete, UserNotification, UserPhoneOtp
from base.constants import GUARDIAN, JUNIOR, SUPERUSER
from base.messages import ERROR_CODE_REQUIRED, ERROR_CODE, SUCCESS_CODE, STATUS_CODE_ERROR
from .utils import junior_account_update, guardian_account_update

class GoogleLoginSerializer(serializers.Serializer):
    """google login serializer"""
    access_token = serializers.CharField(max_length=5000, required=True)

    class Meta(object):
        """meta class"""
        fields = ('access_token',)


class UpdateJuniorProfileImageSerializer(serializers.ModelSerializer):
    """update junior image"""
    class Meta(object):
        """Meta info"""
        model = Junior
        fields = ['image']

    def update(self, instance, validated_data):
        """update image """
        junior_image = validated_data.get('image', instance.image)
        instance.image = junior_image
        instance.save()
        return instance


class UpdateGuardianImageSerializer(serializers.ModelSerializer):
    """update guardian image"""
    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = ['image']

    def update(self, instance, validated_data):
        """update image """
        instance.image = validated_data.get('image', instance.image)
        instance.save()
        return instance


class ResetPasswordSerializer(serializers.Serializer):
    """Reset Password after verification"""
    verification_code = serializers.CharField(max_length=10)
    password = serializers.CharField(required=True)
    class Meta(object):
        """Meta info"""
        model = User

    def create(self, validated_data):
        verification_code = validated_data.pop('verification_code')
        password = validated_data.pop('password')
        user_opt_details = UserEmailOtp.objects.filter(otp=verification_code, is_verified=True).last()
        if user_opt_details:
            user_details = User.objects.filter(email=user_opt_details.email).last()
            if user_details:
                if user_details.check_password(password):
                    raise serializers.ValidationError({"details":ERROR_CODE['2001'],"code":"400", "status":"failed"})
                user_details.set_password(password)
                user_details.save()
                return {'password':password}
            return user_opt_details
        return ''

class ChangePasswordSerializer(serializers.Serializer):
    """Update Password after verification"""
    current_password = serializers.CharField(max_length=100)
    new_password = serializers.CharField(required=True)
    class Meta(object):
        """Meta info"""
        model = User

    def validate_current_password(self, value):
        user = self.context
        if self.context.password not in ('', None) and user.check_password(value):
            return value
        raise serializers.ValidationError(ERROR_CODE['2015'])
    def create(self, validated_data):
        new_password = validated_data.pop('new_password')
        current_password = validated_data.pop('current_password')
        if new_password == current_password:
            raise serializers.ValidationError({"details": ERROR_CODE['2026']})
        user_details = User.objects.filter(email=self.context).last()
        if user_details:
            user_details.set_password(new_password)
            user_details.save()
            return {'password':new_password}
        return ''



class ForgotPasswordSerializer(serializers.Serializer):
    """Forget password serializer"""
    email = serializers.EmailField()

class SuperUserSerializer(serializers.ModelSerializer):
    """Super admin serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')

    def get_user_type(self, obj):
        """user type"""
        return SUPERUSER

    class Meta(object):
        """Meta info"""
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name', 'is_active', 'user_type']


class GuardianSerializer(serializers.ModelSerializer):
    """guardian serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')
    email = serializers.SerializerMethodField('get_auth')
    first_name = serializers.SerializerMethodField('get_first_name')
    last_name = serializers.SerializerMethodField('get_last_name')
    auth_token = serializers.SerializerMethodField('get_auth_token')

    def get_auth_token(self, obj):
        refresh = RefreshToken.for_user(obj.user)
        access_token = str(refresh.access_token)
        return access_token


    def get_user_type(self, obj):
        """user type"""
        email_verified = UserEmailOtp.objects.filter(email=obj.user.username).last()
        if email_verified and email_verified.user_type != None:
            return email_verified.user_type
        return '2'

    def get_auth(self, obj):
        """user email address"""
        return obj.user.username

    def get_first_name(self, obj):
        """user first name"""
        return obj.user.first_name

    def get_last_name(self, obj):
        """user last name"""
        return obj.user.last_name

    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = ['id', 'auth_token', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'family_name',
                  'gender', 'dob', 'referral_code', 'is_active', 'is_complete_profile', 'passcode', 'image',
                  'created_at', 'updated_at', 'user_type', 'country_name']


class JuniorSerializer(serializers.ModelSerializer):
    """junior serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')
    email = serializers.SerializerMethodField('get_auth')
    first_name = serializers.SerializerMethodField('get_first_name')
    last_name = serializers.SerializerMethodField('get_last_name')
    auth_token = serializers.SerializerMethodField('get_auth_token')

    def get_auth_token(self, obj):
        refresh = RefreshToken.for_user(obj.auth)
        access_token = str(refresh.access_token)
        return access_token

    def get_user_type(self, obj):
        email_verified = UserEmailOtp.objects.filter(email=obj.auth.username).last()
        if email_verified and email_verified.user_type != None:
            return email_verified.user_type
        return '1'

    def get_auth(self, obj):
        return obj.auth.username

    def get_first_name(self, obj):
        return obj.auth.first_name

    def get_last_name(self, obj):
        return obj.auth.last_name

    class Meta(object):
        """Meta info"""
        model = Junior
        fields = ['id', 'auth_token', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
                  'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
                  'updated_at', 'user_type', 'country_name']

class EmailVerificationSerializer(serializers.ModelSerializer):
    """Email verification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserEmailOtp
        fields = '__all__'



class DefaultTaskImagesSerializer(serializers.ModelSerializer):
    """Update Password after verification"""
    class Meta(object):
        """Meta info"""
        model = DefaultTaskImages
        fields = ['task_name', 'image_url']
    def create(self, validated_data):
        data = DefaultTaskImages.objects.create(**validated_data)
        return data

class DefaultTaskImagesDetailsSerializer(serializers.ModelSerializer):
    """Update Password after verification"""
    class Meta(object):
        """Meta info"""
        model = DefaultTaskImages
        fields = '__all__'

class UserDeleteSerializer(serializers.ModelSerializer):
    """User Delete Serializer"""
    class Meta(object):
        """Meta Information"""
        model = UserDelete
        fields = ['reason']
    def create(self, validated_data):
        user = self.context['user']
        user_type = str(self.context['user_type'])
        data = validated_data.get('reason')
        passwd = self.context['password']
        random_num = random.randint(0,10000)
        user_tb = User.objects.filter(id=user.id).last()
        if user_tb and user_tb.check_password(passwd):
            user_type_data = UserEmailOtp.objects.filter(email=user.email).last()
            if user_type == '1' and user_type_data.user_type == '1':
                junior_account_update(user_tb)
            elif user_type == '2' and user_type_data.user_type == '2':
                guardian_account_update(user_tb)
            else:
                raise serializers.ValidationError({"details":ERROR_CODE['2030'],"code":"400", "status":"failed"})
            user_tb.email = str(random_num) + str('@D_') + '{}'.format(user_tb.username).lower()
            user_tb.username = str(random_num) + str('@D_') + '{}'.format(user_tb.username).lower()
            user_tb.password = 'None'
            d_email = user_tb.email
            o_mail = user.email
            instance = UserDelete.objects.create(user=user_tb, d_email=d_email, old_email=o_mail,
                                                 is_active=True, reason=data)
            user_tb.save()

            return instance
        else:
            raise serializers.ValidationError({"details": ERROR_CODE['2031'], "code": "400", "status": "failed"})


class UserNotificationSerializer(serializers.ModelSerializer):
    """User Notification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserNotification
        fields = '__all__'


class UpdateUserNotificationSerializer(serializers.ModelSerializer):
    """Update User Notification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserNotification
        fields = ['push_notification', 'email_notification', 'sms_notification']

    def create(self, validated_data):
        instance = UserNotification.objects.filter(user=self.context).last()
        if instance:
            instance.push_notification = validated_data.get('push_notification',instance.push_notification)
            instance.email_notification = validated_data.get('email_notification', instance.email_notification)
            instance.sms_notification = validated_data.get('sms_notification', instance.sms_notification)
            instance.save()
        else:
            instance = UserNotification.objects.create(user=self.context)
        return instance

class UserPhoneOtpSerializer(serializers.ModelSerializer):
    """User Phone serializers"""
    class Meta(object):
        """Meta info"""
        model = UserPhoneOtp
        fields = '__all__'