from rest_framework import serializers
from rest_framework_simplejwt.serializers import TokenObtainPairSerializer
from .validators import validate_password_strength
from django.utils.translation import gettext_lazy as _
from .models import CustomUser
from payment.utils.stripe import StripeUtils
import stripe
from django.conf import settings
import uuid

from user_notification.models import NotificationToken

stripe.api_key = settings.STRIPE_SECRET_KEY

class LoginSerializer(serializers.Serializer):
    email = serializers.EmailField()
    password = serializers.CharField(write_only=True, min_length=6)
    device_token = serializers.CharField(required=False, allow_blank=True)
    notification_token = serializers.CharField(
        required=False, allow_blank=True, min_length=100, max_length=255
    )
    device_type = serializers.ChoiceField(
        required=False, allow_blank=True, choices=NotificationToken.DEVICE_CHOICES
    )

    def validate(self, attrs):
        if attrs.get("notification_token") and not attrs.get("device_type"):
            raise serializers.ValidationError("Please provide device type")
        return attrs


class UserSignupSerializer(serializers.ModelSerializer):
    password = serializers.CharField(
        write_only=True, validators=[validate_password_strength]
    )
    confirm_password = serializers.CharField(write_only=True)
    notification_token = serializers.CharField(
        required=False, allow_blank=True, min_length=100, max_length=255
    )
    device_type = serializers.ChoiceField(
        required=False, allow_blank=True, choices=NotificationToken.DEVICE_CHOICES
    )

    class Meta:
        model = CustomUser  # Use your custom user model
        fields = [
            "first_name",
            "last_name",
            "email",
            "password",
            "confirm_password",
            "notification_token",
            "device_type",
        ]
        extra_kwargs = {
            "first_name": {"required": True},
            "last_name": {"required": True},
            "email": {"required": True},
            "password": {"required": True, "write_only": True},
            "confirm_password": {"required": True, "write_only": True},
        }

    def validate_email(self, value):
        if CustomUser.objects.filter(email=value, is_active=True).exists():
            raise serializers.ValidationError("Email ID already exists.")
        return value

    def validate(self, attrs):
        # Check if password and confirm_password are the same
        if attrs["password"] != attrs["confirm_password"]:
            raise serializers.ValidationError(
                {"confirm_password": "Passwords and confirm_password do not match."}
            )

        if attrs.get("notification_token") and not attrs.get("device_type"):
            raise serializers.ValidationError("Please provide device type")
        return attrs

    def create(self, validated_data):
        validated_data.pop("confirm_password")

        # Create a new user instance with UUID
        unique_username = str(uuid.uuid4())
        user = CustomUser(
            first_name=validated_data["first_name"],
            last_name=validated_data["last_name"],
            username=unique_username,
            email=validated_data["email"],
            is_verified=False,
        )
        user.set_password(validated_data["password"])  # Hash the password
        user.save()  # Save the user instance

        try:
            customer_id = StripeUtils.create_customer(
                name=f"{user.first_name} {user.last_name}",
                email=user.email,
            )
            user.stripe_customer_id = customer_id
            user.save()
        except Exception as e:
            raise serializers.ValidationError({"stripe_error": str(e)})

        return user


class PasswordResetRequestSerializer(serializers.Serializer):
    email = serializers.EmailField()

    def validate_email(self, value):
        try:
            CustomUser.objects.get(email=value,is_active = True)
        except CustomUser.DoesNotExist:
            raise serializers.ValidationError("Email address not found.")
        return value


class PasswordResetConfirmSerializer(serializers.Serializer):
    password = serializers.CharField(write_only=True)
    token = serializers.CharField()
    uidb64 = serializers.CharField()

    def validate(self, attrs):
        # You can add token validation here if needed
        return attrs
    

class ChangePasswordSerializer(serializers.Serializer):
    old_password = serializers.CharField(required=True, write_only=True)
    new_password = serializers.CharField(required=True, write_only=True)
    confirm_password = serializers.CharField(required=True, write_only=True)

    def validate_old_password(self, value):
        user = self.context['request'].user
        if not user.check_password(value):
            raise serializers.ValidationError(_("Old password is incorrect."))
        return value

    def validate(self, attrs):
        if attrs['new_password'] != attrs['confirm_password']:
            raise serializers.ValidationError({"confirm_password": _("New password and confirm password do not match.")})
        return attrs

    def update(self, instance, validated_data):
        user = instance
        user.set_password(validated_data['new_password'])
        user.save()
        return user