goodtimes/manage_subscriptions/views.py

from decimal import Decimal
import json
from django.http import HttpResponseBadRequest, HttpResponseRedirect, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
import stripe
from accounts import resource_action
from accounts.models import IAmPrincipal
from django.contrib.auth import login
import jwt
from django.utils import timezone
from django.contrib.auth import get_user_model
from manage_coupons.models import Coupon
from manage_subscriptions.forms import (
    StripeProductForm,
    SubscriptionForm,
    PrincipalSubscriptionForm,
)
from manage_wallets.models import (
    PaymentMethod,
    Transaction,
    TransactionStatus,
    TransactionType,
)
from .models import (
    Plan,
    StripeProduct,
    Subscription,
    PrincipalSubscription,
    SubscriptionStatus,
)
from django.views import generic
from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import reverse, reverse_lazy
from django.contrib import messages
from goodtimes import constants
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from django.conf import settings
from django.views.generic.base import TemplateView
from django.db.models import Q
from django.db import transaction

# Create your views here.


class SubscriptionCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_subscriptions/subscription_add.html"
    model = Subscription
    form_class = SubscriptionForm
    success_url = reverse_lazy("manage_subscriptions:subscription_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        # This code ensures that only one free plan can be created by checking for existing free plans before saving a new one.
        if form.cleaned_data.get("is_free"):
            if self.model.objects.filter(Q(is_free=True) & Q(active=True)).exists():
                messages.error(
                    self.request,
                    "A free plan is already available. Please deactivate the existing one before creating a new one.",
                )
                context = self.get_context_data(form=form)
                return render(request, self.template_name, context=context)

        # Processing Stripe price creation and handling free subscription
        success, message = self.handle_stripe_price(form)
        if not success:
            messages.error(self.request, message)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)

    def handle_stripe_price(self, form):
        try:
            stripe.api_key = settings.STRIPE_SECRET_KEY
            stripe_product_id = (
                form.instance.stripe_product.product_id
                if form.instance.stripe_product
                else None
            )
            # creating Stripe price only if the subscription is not free
            if not form.cleaned_data.get("is_free") and stripe_product_id:
                # Getting Stripe Product ID
                stripe_product = form.instance.stripe_product
                plan = form.instance.plan

                # Map the Plan interval to Stripe's recurring interval
                # It will only work if the plan title is 'month', 'year' 'week' or 'day'
                stripe_interval = plan.title
                # Create the Stripe price
                stripe_price = stripe.Price.create(
                    unit_amount=int(
                        form.cleaned_data["amount"] * 100
                    ),  # Amount in cents
                    currency="gbp",  # Adjust the currency as needed
                    recurring={
                        "interval": stripe_interval
                    },  # Use the interval from Plan
                    product=stripe_product.product_id,
                )
                # Assign the Stripe price ID to the subscription
                form.instance.price_id = stripe_price.id
            else:
                form.instance.price_id = None  # No price ID for free subscriptions

            return True, ""  # Success
        except stripe.error.StripeError as e:
            return False, f"Stripe error: {str(e)}"
        except Exception as e:
            return False, f"An error occurred: {str(e)}"


class SubscriptionView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = Subscription
    template_name = "manage_subscriptions/subscription_list.html"
    context_object_name = "subscription_obj"

    def get_queryset(self):
        queryset = (
            super()
            .get_queryset()
            .filter(deleted=False, active=True)
            .prefetch_related("principal_types")
        )
        return queryset.order_by("-created_on")

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class SubscriptionDetailView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = Subscription
    template_name = "manage_subscriptions/subscription_details.html"
    context_object_name = "subscription"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class SubscriptionDeleteView(LoginRequiredMixin, generic.View):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_DELETE
    model = Subscription
    success_url = reverse_lazy("manage_subscriptions:subscription_list")
    success_message = constants.RECORD_DELETED
    error_message = constants.RECORD_NOT_FOUND

    def get(self, request, pk):
        try:
            # Retrieve the subscription object
            subscription = self.model.objects.get(id=pk)

            # Checking if there is a Stripe Price ID associated with the subscription
            stripe_price_id = subscription.price_id
            if stripe_price_id:
                stripe.api_key = settings.STRIPE_SECRET_KEY

                try:
                    # Updating the Stripe price to mark it as inactive
                    stripe.Price.modify(stripe_price_id, active=False)
                except stripe.error.StripeError as e:
                    # Handle Stripe errors
                    messages.error(request, f"Stripe error: {str(e)}")
                    return redirect(self.success_url)

            # Updating the subscription model record
            subscription.deleted = True
            subscription.active = False
            subscription.save()

            messages.success(request, self.success_message)

        except self.model.DoesNotExist:
            messages.error(request, self.error_message)

        return redirect(self.success_url)


class StripeProductCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_subscriptions/product_add.html"
    model = StripeProduct
    form_class = StripeProductForm
    success_url = reverse_lazy("manage_subscriptions:stripe_product_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        success, message = self.handle_stripe_product(form)
        if not success:
            messages.error(self.request, message)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)

        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)

    def handle_stripe_product(self, form):
        try:
            stripe.api_key = settings.STRIPE_SECRET_KEY

            stripe_product = stripe.Product.create(
                name=form.cleaned_data.get("title"),
                description=form.cleaned_data.get("description"),
            )

            # Save Stripe Product ID to the form instance
            form.instance.product_id = stripe_product.id

            return True, ""  # Success
        except stripe.error.StripeError as e:
            return False, f"Stripe error: {str(e)}"
        except Exception as e:
            return False, f"An error occurred: {str(e)}"


class StripeProductView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = StripeProduct
    template_name = "manage_subscriptions/product_list.html"
    context_object_name = "product_obj"

    def get_queryset(self):
        queryset = super().get_queryset().filter(deleted=False, active=True)
        return queryset.order_by("-created_on")

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


""" we are not using product delete functionality because there may be multiple stripe's prices 
    attached to one product and in case of any error it will mismatch the stripe's price with 
    our database Subscription objects"""
# class StripeProductDeleteView(LoginRequiredMixin, generic.View):
#     page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
#     resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
#     action = resource_action.ACTION_DELETE
#     model = StripeProduct
#     success_url = reverse_lazy("manage_subscriptions:stripe_product_list")
#     success_message = constants.RECORD_DELETED
#     error_message = constants.RECORD_NOT_FOUND

#     def get(self, request, pk):
#         try:
#             # Retrieve the subscription object
#             product = self.model.objects.get(id=pk)

#             # Fetching the related subscriptions (prices)
#             related_subscriptions = Subscription.objects.filter(stripe_product=product)

#             # Checking if there is a Stripe Product ID associated with the subscription
#             stripe_product_id = product.product_id
#             if stripe_product_id:
#                 stripe.api_key = settings.STRIPE_SECRET_KEY

#                 # Deactivating related prices on Stripe first
#                 for subscription in related_subscriptions:
#                     price_id = subscription.price_id
#                     if price_id:
#                         try:
#                             stripe.Price.modify(price_id, active=False)
#                         except stripe.error.StripeError as e:
#                             # Handle Stripe errors
#                             messages.error(request, f"Stripe error: {str(e)}")
#                             return redirect(self.success_url)

#                 try:
#                     # Updating the Stripe price to mark it as inactive
#                     stripe.Product.modify(stripe_product_id, active=False)
#                 except stripe.error.StripeError as e:
#                     # Handle Stripe errors
#                     messages.error(request, f"Stripe error: {str(e)}")
#                     return redirect(self.success_url)

#             # Updating the subscription model record
#             product.deleted = True
#             product.active = False
#             product.save()

#             messages.success(request, self.success_message)

#         except self.model.DoesNotExist:
#             messages.error(request, self.error_message)

#         return redirect(self.success_url)


# class PlanCreateOrUpdateView(LoginRequiredMixin, generic.View):
#     # Set the page_name and resource
#     page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
#     resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS

#     # Initialize the action as ACTION_CREATE (can change based on logic)
#     action = resource_action.ACTION_CREATE  # Default action

#     template_name = "manage_subscriptions/plan_add.html"
#     model = Plan
#     form_class = PlanForm
#     success_url = reverse_lazy("manage_subscriptions:plan_list")
#     error_message = "An error occurred while saving the data."

#     # Determine the success message dynamically based on whether it's an update or create
#     def get_success_message(self):
#         self.success_message = (
#             constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
#         )
#         return self.success_message

#     # Get the object (if exists) based on URL parameter 'pk'
#     def get_object(self):
#         pk = self.kwargs.get("pk")
#         return get_object_or_404(self.model, pk=pk) if pk else None

#     # Add page_name and operation to the context
#     def get_context_data(self, **kwargs):
#         context = {
#             "page_name": self.page_name,
#             "operation": "Add" if not self.object else "Edit",
#         }
#         context.update(kwargs)  # Include any additional context data passed to the view
#         return context

#     def get(self, request, *args, **kwargs):
#         self.object = self.get_object()

#         # If an object is found, change action to ACTION_UPDATE
#         if self.object is not None:
#             self.action = resource_action.ACTION_UPDATE

#         form = self.form_class(instance=self.object)
#         context = self.get_context_data(form=form)
#         return render(request, self.template_name, context=context)

#     def post(self, request, *args, **kwargs):
#         self.object = self.get_object()

#         # If an object is found, change action to ACTION_UPDATE
#         if self.object is not None:
#             self.action = resource_action.ACTION_UPDATE

#         form = self.form_class(request.POST, instance=self.object)
#         if not form.is_valid():
#             print(form.errors)
#             context = self.get_context_data(form=form)
#             return render(request, self.template_name, context=context)
#         form.save()
#         messages.success(self.request, self.get_success_message())
#         return redirect(self.success_url)


class PlanView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = Plan
    template_name = "manage_subscriptions/plan_list.html"
    context_object_name = "plan_obj"

    def get_queryset(self):
        return super().get_queryset().filter(deleted=False)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


# class PlanDeleteView(LoginRequiredMixin, generic.View):
#     page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
#     resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
#     action = resource_action.ACTION_DELETE
#     model = Plan
#     success_url = reverse_lazy("manage_subscriptions:plan_list")
#     success_message = constants.RECORD_DELETED
#     error_message = constants.RECORD_NOT_FOUND

#     def get(self, request, pk):
#         try:
#             type_obj = self.model.objects.get(id=pk)
#             type_obj.deleted = True
#             type_obj.active = False
#             type_obj.save()
#             messages.success(request, self.success_message)
#         except self.model.DoesNotExist:
#             messages.success(request, self.error_message)

#         return redirect(self.success_url)


class PrincipalSubscriptionCreateOrUpdateView(LoginRequiredMixin, generic.View):
    # Set the page_name and resource
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS

    # Initialize the action as ACTION_CREATE (can change based on logic)
    action = resource_action.ACTION_CREATE  # Default action

    template_name = "manage_subscriptions/principal_subscription_add.html"
    model = PrincipalSubscription
    form_class = PrincipalSubscriptionForm
    success_url = reverse_lazy("manage_subscriptions:principal_subscriptions_list")
    error_message = "An error occurred while saving the data."

    # Determine the success message dynamically based on whether it's an update or create
    def get_success_message(self):
        self.success_message = (
            constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
        )
        return self.success_message

    # Get the object (if exists) based on URL parameter 'pk'
    def get_object(self):
        pk = self.kwargs.get("pk")
        return get_object_or_404(self.model, pk=pk) if pk else None

    # Add page_name and operation to the context
    def get_context_data(self, **kwargs):
        context = {
            "page_name": self.page_name,
            "operation": "Add" if not self.object else "Edit",
        }
        context.update(kwargs)  # Include any additional context data passed to the view
        return context

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(instance=self.object)
        context = self.get_context_data(form=form)
        return render(request, self.template_name, context=context)

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()

        # If an object is found, change action to ACTION_UPDATE
        if self.object is not None:
            self.action = resource_action.ACTION_UPDATE

        form = self.form_class(request.POST, instance=self.object)
        if not form.is_valid():
            print(form.errors)
            context = self.get_context_data(form=form)
            return render(request, self.template_name, context=context)
        form.save()
        messages.success(self.request, self.get_success_message())
        return redirect(self.success_url)


class PrincipalSubscriptionView(LoginRequiredMixin, generic.ListView):
    page_name = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = PrincipalSubscription
    template_name = "manage_subscriptions/principal_subscriptions_list.html"
    context_object_name = "principal_subscription_obj"

    def get_queryset(self):
        return super().get_queryset().all()

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class PrincipalSubscriptionDetailView(LoginRequiredMixin, generic.DetailView):
    page_name = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_PRINCIPAL_SUBSCRIPTIONS
    action = resource_action.ACTION_READ
    model = PrincipalSubscription
    template_name = "manage_subscriptions/principal_subscription_details.html"
    context_object_name = "principal_subscription_obj"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class PrincipalSubscriptionDeleteView(LoginRequiredMixin, generic.View):
    page_name = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    resource = resource_action.RESOURCE_MANAGE_SUBSCRIPTIONS
    action = resource_action.ACTION_DELETE
    model = PrincipalSubscription
    success_url = reverse_lazy("manage_subscriptions:principal_subscriptions_list")
    success_message = constants.RECORD_DELETED
    error_message = constants.RECORD_NOT_FOUND

    def get(self, request, pk):
        try:
            type_obj = self.model.objects.get(id=pk)
            type_obj.deleted = True
            type_obj.active = False
            type_obj.save()
            messages.success(request, self.success_message)
        except self.model.DoesNotExist:
            messages.success(request, self.error_message)

        return redirect(self.success_url)


class SubscriptionPageView(TemplateView):
    template_name = "stripe_html/index.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        request = self.request
        if request.user.is_authenticated:
            print("request.user: ", request.user)
            subscriptions = Subscription.objects.filter(
                principal_types=request.user.principal_type,
                active=True,
                deleted=False,
                is_free=False,
            )

            if subscriptions.exists():
                context["subscriptions"] = subscriptions
                context["stripeCheckoutUrl"] = settings.STRIPE_CHECKOUT_URL
                context["stripeFinalUrl"] = settings.STRIPE_FINAL_URL
                context["couponValidityCheckUrl"] = settings.COUPON_VALIDITY_CHECK_URL
            else:
                # Handling the case where no subscriptions are found for the principal type.
                context["error"] = "No subscriptions found for your user type."
        return context


class ActiveSubscriptionView(TemplateView):
    template_name = "stripe_html/active_subscription.html"

    def get(self, request, *args, **kwargs):
        token = request.GET.get("token") or request.session.get("jwt")
        print("token: ", token)
        if token:
            request.session["jwt"] = token
            print("request.session: ", request.session)
            try:
                # Decode and validate token
                payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
                print("payload: ", payload)
                user = get_user_model().objects.get(id=payload["user_id"])
                # Manually specify the authentication backend
                user.backend = "django.contrib.auth.backends.ModelBackend"
                # Log the user in
                login(request, user)
                print("Logged in user: ", user)
            except (
                IAmPrincipal.DoesNotExist,
                jwt.ExpiredSignatureError,
                jwt.InvalidTokenError,
            ):
                return HttpResponseBadRequest("Invalid token or user not found")
        today = timezone.now().date()
        if request.user.is_authenticated:
            active_subscription = (
                PrincipalSubscription.objects.filter(
                    principal=request.user,
                    is_paid=True,
                    cancelled=False,
                    deleted=False,
                    active=True,
                    status=SubscriptionStatus.ACTIVE,
                )
                .select_related("principal")  # Optimize query
                .order_by("-grace_period_end_date")
                .first()
            )

            if not active_subscription or active_subscription.end_date < today:
                return HttpResponseRedirect(reverse("manage_subscriptions:stripe"))
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        request = self.request
        today = timezone.now().date()
        if request.user.is_authenticated:
            active_subscription = (
                PrincipalSubscription.objects.filter(
                    principal=request.user,
                    is_paid=True,
                    cancelled=False,
                    deleted=False,
                    active=True,
                    status=SubscriptionStatus.ACTIVE,
                )
                .select_related("principal")  # Optimize query
                .order_by("-grace_period_end_date")
                .first()
            )
            context["active_subscription"] = active_subscription
        return context


class CancelSubscriptionView(LoginRequiredMixin, generic.View):
    def post(self, request, *args, **kwargs):
        subscription_id = request.POST.get("subscription_id")

        try:
            subscription = PrincipalSubscription.objects.get(
                stripe_subscription_id=subscription_id, principal=request.user
            )
        except PrincipalSubscription.DoesNotExist:
            messages.error(request, "Subscription not found.")
            return redirect("manage_subscriptions:cancel")

        try:
            with transaction.atomic():
                if subscription.is_stripe_subscription:
                    # Cancel Stripe subscription
                    stripe.Subscription.modify(
                        subscription.stripe_subscription_id, cancel_at_period_end=True
                    )

                # Updating subscription status in the local database
                subscription.status = SubscriptionStatus.INACTIVE
                subscription.cancelled = True
                subscription.active = False
                subscription.cancelled_date_time = timezone.now()
                subscription.save()

            messages.success(request, "Subscription cancelled successfully.")
            return redirect("manage_subscriptions:success")
        except stripe.error.InvalidRequestError as e:
            messages.error(request, f"Stripe error: {str(e)}")
            return redirect("manage_subscriptions:cancel")


@csrf_exempt
def stripe_config(request):
    if request.method == "GET":
        stripe_config = {"publicKey": settings.STRIPE_PUBLISH_KEY}
        return JsonResponse(stripe_config, safe=False)


@csrf_exempt
@require_POST
def validate_coupon(request):
    data = json.loads(request.body)
    coupon_code = data.get("couponCode", None)
    subscription_id = data.get("subscriptionId", None)
    final_amount = None

    try:
        subscription = Subscription.objects.get(id=subscription_id)
    except Subscription.DoesNotExist:
        return JsonResponse({"error": "Subscription not found."}, status=404)

    # If no coupon code is provided, assume no discount and proceed
    if not coupon_code:
        return JsonResponse({"message": "No coupon code provided."}, status=200)

    # Validating Coupon
    try:
        coupon = Coupon.objects.get(coupon_code=coupon_code)

        if not coupon.is_valid():
            return JsonResponse({"error": "Coupon is not valid."}, status=400)

        # Check discount amount
        if coupon.discount_amount and coupon.discount_amount > subscription.amount:
            final_amount = subscription.amount - coupon.discount_amount
            return JsonResponse(
                {"error": "Coupon discount amount exceeds subscription amount."},
                status=400,
            )

        # Check discount percentage
        if coupon.discount_percentage:
            discount = (
                coupon.discount_percentage / Decimal("100")
            ) * subscription.amount
            if discount > subscription.amount:
                return JsonResponse(
                    {
                        "error": "Coupon discount percentage exceeds subscription amount."
                    },
                    status=400,
                )
            final_amount = subscription.amount - discount
        # Retrieving coupon from Stripe if applicable
        if coupon.coupon_id:
            try:
                stripe_coupon = stripe.Coupon.retrieve(coupon.coupon_id)
                print("stripe_coupon: ", stripe_coupon)
                if (
                    stripe_coupon.max_redemptions
                    and stripe_coupon.times_redeemed >= stripe_coupon.max_redemptions
                ):
                    return JsonResponse(
                        {"error": "Coupon max redeems reached."}, status=400
                    )
                return JsonResponse(
                    {"data": {"coupon": stripe_coupon, "finalAmount": final_amount}},
                    status=200,
                )
            except stripe.error.InvalidRequestError:
                return JsonResponse(
                    {"error": f"Invalid coupon code: {coupon_code}"}, status=400
                )
            except stripe.error.StripeError as e:
                return JsonResponse({"error": f"Stripe error: {str(e)}"}, status=400)
        else:
            return JsonResponse(
                {
                    "error": "Coupon is either invalid, expired, or not associated with Stripe."
                },
                status=400,
            )
    except Coupon.DoesNotExist:
        return JsonResponse({"error": "Coupon not found."}, status=404)


@csrf_exempt
@require_POST
def create_checkout_session(request):
    stripe.api_key = settings.STRIPE_SECRET_KEY
    data = json.loads(request.body)
    subscription_id = data.get("subscriptionId")
    coupon_code = data.get("couponCode")
    transaction_amount = data.get("discountAmount")
    principal_id = request.user.id

    try:
        subscription = Subscription.objects.get(id=subscription_id)
    except Subscription.DoesNotExist:
        return JsonResponse({"error": "Subscription not found."}, status=404)

    order_id = f"order_{timezone.localtime().timestamp()}_{request.user.email}"

    # Default transaction amount based on subscription amount
    print("Before Session Data")
    session_data = {
        "payment_method_types": ["card"],
        "success_url": request.build_absolute_uri("/subscriptions/success/"),
        "cancel_url": request.build_absolute_uri("/subscriptions/cancel/"),
        "metadata": {
            "transaction_amount": str(transaction_amount),
            "principal": str(request.user.id),
            "order_id": order_id,
            "subscription_id": str(subscription.id),
            "product_id": str(
                subscription.stripe_product.product_id
                if subscription.stripe_product
                else None
            ),
            "couponCode": coupon_code if coupon_code else None,
        },
    }
    print("session_data: ", session_data)
    # Coupon Handling
    if coupon_code:
        try:
            stripe_coupon = stripe.Coupon.retrieve(coupon_code)
            session_data["discounts"] = [{"coupon": stripe_coupon.id}]
        except stripe.error.InvalidRequestError:
            return JsonResponse(
                {"error": f"Invalid coupon code: {coupon_code}"}, status=400
            )
        except stripe.error.StripeError as e:
            return JsonResponse({"error": f"Stripe error: {str(e)}"}, status=400)

    # Creating the Stripe Checkout Session
    try:
        if subscription.price_id:
            session_data["line_items"] = [
                {
                    "price": subscription.price_id,
                    "quantity": 1,
                }
            ]
            session_data["mode"] = "subscription"
            session_data["subscription_data"] = {
                "metadata": session_data["metadata"],
            }
        else:
            session_data["line_items"] = [
                {
                    "price_data": {
                        "currency": "gbp",
                        "product_data": {
                            "name": subscription.title,
                            "description": subscription.short_description,
                        },
                        "unit_amount": int(subscription.amount * 100),
                    },
                    "quantity": 1,
                }
            ]
            session_data["mode"] = "payment"
        checkout_session = stripe.checkout.Session.create(**session_data)
        return JsonResponse({"sessionId": checkout_session["id"]})
    except Exception as e:
        return JsonResponse({"error": str(e)}, status=500)


class SuccessView(TemplateView):
    template_name = "stripe_html/success.html"


class CancelView(TemplateView):
    template_name = "stripe_html/cancel.html"