"""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
from base.constants import GUARDIAN, JUNIOR, SUPERUSER
from base.messages import ERROR_CODE_REQUIRED, ERROR_CODE, SUCCESS_CODE, STATUS_CODE_ERROR


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.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_data = Junior.objects.filter(auth__email=user_tb.email).first()
                if junior_data:
                    junior_data.is_active = False
                    junior_data.is_verified = False
                    junior_data.guardian_code = '{}'
                    junior_data.save()
            elif user_type == '2' and user_type_data.user_type == '2':
                guardian_data = Guardian.objects.filter(user__email=user_tb.email).first()
                if guardian_data:
                    guardian_data.is_active = False
                    guardian_data.is_verified = False
                    guardian_data.save()
                    jun_data = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
                    for data in jun_data:
                        data.guardian_code.remove(guardian_data.guardian_code)
                        data.save()
            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()
        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()
        return instance