from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import Cart, CartItem,OrderItem,Order
from menu.models import MenuItem
from . serializers import *
from notifications.utils import send_notification
from rest_framework import generics
from rest_framework.permissions import IsAuthenticated
from orders.permissions import IsCustomer


def _status_notification_for_customer(status_value: str, order_id: int, actor_role: str | None = None):
    normalized = str(status_value or "").upper()
    actor = str(actor_role or "").upper()
    actor_label = "Driver" if actor == "DRIVER" else "Manager"
    if normalized == "PENDING":
        return ("Order Pending", f"{actor_label} set your order #{order_id} to pending.")
    if normalized == "READY":
        return ("Order Ready", f"{actor_label} updated your order #{order_id} to ready.")
    if normalized == "DELIVERED":
        return ("Order Delivered", f"{actor_label} marked your order #{order_id} as delivered.")
    return None
class AddToCartView(APIView):

    def post(self, request):
        user = request.user
        menu_item_id = request.data.get("menu_item")
        quantity = int(request.data.get("quantity", 1))
        serializer = CartSerializer()
        
        cart, created = Cart.objects.get_or_create(customer=user)
        menu_item = MenuItem.objects.get(id=menu_item_id)

        cart_item, created = CartItem.objects.get_or_create(
            cart=cart,
            menu_item=menu_item
        )

        if not created:
            cart_item.quantity += quantity
        else:
            cart_item.quantity = quantity

        cart_item.save()

        return Response({"message": "Item added to cart"})
    
class IncreaseQuantityView(APIView):

    def patch(self, request, item_id):
        cart_item = CartItem.objects.get(id=item_id, cart__customer=request.user)
        cart_item.quantity += 1
        cart_item.save()

        return Response({"message": "Quantity increased"})
    
class DecreaseQuantityView(APIView):

    def patch(self, request, item_id):
        cart_item = CartItem.objects.get(id=item_id, cart__customer=request.user)

        if cart_item.quantity > 1:
            cart_item.quantity -= 1
            cart_item.save()
        else:
            cart_item.delete()

        return Response({"message": "Quantity updated"})
    
class RemoveCartItemView(APIView):

    def delete(self, request, item_id):
        cart_item = CartItem.objects.get(id=item_id, cart__customer=request.user)
        cart_item.delete()
        return Response({"message": "Item removed"})
    
from orders.permissions import IsCustomer

class CheckoutView(APIView):
    permission_classes = [IsCustomer]

    def post(self, request):
        user = request.user
        order_type = request.data.get("order_type")  # ORDER or DELIVERY

        cart = Cart.objects.get(customer=user)
        items = cart.items.all()

        if not items.exists():
            return Response({"error": "Cart is empty"}, status=400)

        order = Order.objects.create(
            customer=user,
            order_type=order_type,
            status="PREPARING"
        )

        total = 0

        for item in items:
            subtotal = item.menu_item.price * item.quantity

            OrderItem.objects.create(
                order=order,
                menu_item=item.menu_item,
                quantity=item.quantity,
                subtotal=subtotal
            )

            total += subtotal

        order.total_amount = total
        order.save()

        cart.items.all().delete()

        return Response({
            "message": "Order placed successfully",
            "order_type": order_type
        })
        
class OrderListView(generics.ListAPIView):
    serializer_class = OrderListSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        user = self.request.user
        role = str(getattr(user, "role", "")).upper()

        if role in ["ADMIN", "MANAGER"]:
            return Order.objects.select_related("customer").prefetch_related("items__menu_item").all()

        if role == "CUSTOMER":
            return Order.objects.select_related("customer").prefetch_related("items__menu_item").filter(customer=user)

        if role == "DRIVER":
            return (
                Order.objects.select_related("customer")
                .prefetch_related("items__menu_item")
                .filter(order_type="DELIVERY")
            )

        return Order.objects.none()
    
from rest_framework import generics
from orders.permissions import *


class OrderCreateView(generics.CreateAPIView):
    serializer_class = OrderCreateSerializer
    permission_classes = [IsAuthenticated]
    
class OrderUpdateView(generics.UpdateAPIView):
    queryset = Order.objects.all()
    serializer_class = OrderCreateSerializer
    permission_classes = [IsAuthenticated]

    def perform_update(self, serializer):
        previous_status = str(serializer.instance.status or "").upper()
        order = serializer.save()
        current_status = str(order.status or "").upper()
        actor_role = str(getattr(self.request.user, "role", "")).upper()

        if current_status != previous_status:
            payload = _status_notification_for_customer(current_status, order.id, actor_role)
            if payload:
                title, message = payload
                send_notification(order.customer, title, message, order_id=order.id)


class OrderDeleteView(generics.DestroyAPIView):
    queryset = Order.objects.all()
    permission_classes = [IsAuthenticated]
    

class ClearOrderHistoryView(APIView):
    permission_classes = [IsAuthenticated]

    def delete(self, request):
        deleted_count, _ = Order.objects.filter(customer=request.user).delete()
        return Response({
            "message": "Order history cleared",
            "deleted_count": deleted_count
        })




class FavoriteOrderListView(generics.ListAPIView):
    serializer_class = OrderListSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        return Order.objects.select_related("customer").prefetch_related("items__menu_item").filter(
            customer=self.request.user,
            is_favorite=True
        ).order_by('-created_at')
        
class ReOrderView(APIView):
    permission_classes = [IsAuthenticated]

    def post(self, request, pk):
        try:
            old_order = Order.objects.get(pk=pk, customer=request.user)
        except Order.DoesNotExist:
            return Response({"error": "Order not found"}, status=404)

        new_order = Order.objects.create(
            customer=request.user,
            order_type=old_order.order_type,
            status="PREPARING"
        )

        total = 0

        for item in old_order.items.all():
            menu_item = item.menu_item  # get current price
            quantity = item.quantity
            subtotal = menu_item.price * quantity

            OrderItem.objects.create(
                order=new_order,
                menu_item=menu_item,
                quantity=quantity,
                subtotal=subtotal
            )

            total += subtotal

        new_order.total_amount = total
        new_order.save()

        return Response({
            "message": "Order re-created successfully",
            "new_order_id": new_order.id,
            "total_amount": total
        })
        
# orders/views.py




class ToggleFavoriteOrderView(APIView):
    permission_classes = [IsAuthenticated]

    def patch(self, request, pk):
        try:
            order = Order.objects.get(pk=pk, customer=request.user)
        except Order.DoesNotExist:
            return Response({"error": "Order not found"}, status=404)

        order.is_favorite = not order.is_favorite
        order.save()

        return Response({
            "message": "Favorite status updated",
            "is_favorite": order.is_favorite
        })