from django.shortcuts import render, get_object_or_404
from rest_framework import generics, permissions
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework import status
from order.models import *
from product.models import *
from ..serializers import *
from django.db import transaction
from suscription.custom_pagination import CustomPagination
from Help_Support.decorators import cache_response
from rest_framework.exceptions import ValidationError
from setting.views import *
from decimal import Decimal
from rest_framework.views import APIView
from rest_framework import viewsets
from rest_framework.generics import UpdateAPIView
from rest_framework.decorators import action
import json
import hashlib
import hmac
from rest_framework.permissions import AllowAny
from login_signup.custom_permissions import IsCustomAdmin

class SubscriptionPlanDurationUpdateView(generics.UpdateAPIView):
    permission_classes = [IsAuthenticated, IsCustomAdmin]
    queryset = CategoriesPlanDuration.objects.all()
    serializer_class = PlanDurationUpdateSerializer

    def update(self, request, *args, **kwargs):


        partial = kwargs.pop('partial', False)
        instance = self.get_object()

        plan_id = kwargs.get('pk')

        duration_plan = CategoriesPlanDuration.objects.filter(id=plan_id).first()

        if duration_plan and duration_plan.category_plan.name == "FREE":

            if not request.data.get('product_limit'):
                return Response({
                    "status": False,
                    "message": "Missing required fields",
                    "errors": {
                        "product_limit": [
                            "This field is required."
                        ]
                    }
                }, status=status.HTTP_400_BAD_REQUEST)

            duration_plan.product_limit = request.data.get('product_limit')
            duration_plan.save()

            response_data = PlanDurationUpdateSerializer(duration_plan).data

            return Response({
                "status": True,
                "message": "Plan duration updated successfully",
                "data": response_data
            }, status=status.HTTP_200_OK)


        required_fields = ['price_1_month', 'price_3_month', 'price_6_month', 'price_12_month', 'product_limit', 'boost_product_limit']
        missing_fields = {field: ["This field is required."] for field in required_fields if field not in request.data}

        if missing_fields:
            return Response({
                "status": False,
                "message": "Missing required fields",
                "errors": missing_fields  # Returns an array for each missing field
            }, status=status.HTTP_400_BAD_REQUEST)

        price_fields = ['price_1_month', 'price_3_month', 'price_6_month', 'price_12_month']
        updated_prices = {}

        for price_field in price_fields:
            try:
                updated_prices[price_field] = Decimal(str(request.data.get(price_field)).strip())
            except (ValueError, TypeError, InvalidOperation):
                return Response({
                    "status": False,
                    "message": "Invalid price value",
                    "errors": {price_field: "Invalid decimal value."}
                }, status=status.HTTP_400_BAD_REQUEST)

        # instance.product_limit = request.data.get('product_limit', instance.product_limit)
        # instance.boost_product_limit = request.data.get('boost_product_limit', instance.boost_product_limit)
        # instance.status = request.data.get('status', instance.status)
        # instance.save()

        fields_updated = False 

        if "product_limit" in request.data and request.data["product_limit"] != instance.product_limit:
            instance.product_limit = request.data["product_limit"]
            fields_updated = True

        if "boost_product_limit" in request.data and request.data["boost_product_limit"] != instance.boost_product_limit:
            instance.boost_product_limit = request.data["boost_product_limit"]
            fields_updated = True

        if fields_updated:
            instance.save()

        for price_field, new_price in updated_prices.items():
            self.handle_price_update(instance, price_field, new_price)

        instance.refresh_from_db()
        response_data = PlanDurationUpdateSerializer(instance).data

        return Response({
            "status": True,
            "message": "Plan duration updated successfully",
            "data": response_data
        }, status=status.HTTP_200_OK)

    def handle_price_update(self, instance, price_field, new_price):
        """Update price in DurationPrice model and assign new price reference."""
        price_name = price_field.replace("price_", "").replace("_", " ")
        category_plan_id = instance.category_plan.id  

        old_price_obj = DurationPrice.objects.filter(
            # duration=instance,
            category_plan=category_plan_id,
            name=price_name
        ).first()

        if old_price_obj is None or old_price_obj.price != new_price:
            if old_price_obj:
                old_price_obj.deleted_at = now()
                old_price_obj.save()

            new_price_obj = DurationPrice.objects.create(
                category_plan=instance.category_plan,
                name=price_name,
                price=new_price
            )

            setattr(instance, price_field, new_price_obj)

        instance.save()


class AdminSubscriptionTransactionsAPIView(generics.ListAPIView):
    permission_classes = [IsAuthenticated, IsCustomAdmin]
    serializer_class = PlanPurchaseListingSerializer
    pagination_class = CustomPagination

    def get_queryset(self):
        queryset = PlanPurchase.objects.order_by("-created_at")
        category_id = self.request.query_params.get('category_id')
        if category_id is not None:
            queryset = queryset.filter(main_category=category_id)
        return queryset

    def list(self, request, *args, **kwargs):

        queryset = self.get_queryset()

        page = self.paginate_queryset(queryset)  
        if page is not None:
            serializer = self.get_serializer(page, many=True, context={'request': request})
            paginated_response = self.get_paginated_response(serializer.data)  
            
            return Response({
                "status": True,
                "message": "Subscription transactions fetched successfully",
                "data": paginated_response.data 
            })

        serializer = self.get_serializer(queryset, many=True, context={'request': request})
        return Response({
            "status": True,
            "message": "Subscription transactions fetched successfully",
            "data": serializer.data
        })