from rest_framework import status
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, AllowAny
from django.db.models import Q, Avg, Count
from django.utils import timezone
from django.shortcuts import get_object_or_404

from .models import Order, OrderItem, OrderStatusHistory, OrderReview
from accounts.models import VendorProfile
from products.models import Product
from notifications.models import Notification


# ==================== CUSTOMER VIEWS ====================

class CustomerOrdersView(APIView):
    """List customer's orders"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        orders = Order.objects.filter(customer=request.user).select_related(
            'vendor__user'
        ).prefetch_related('items')

        # Filter by status
        status_filter = request.query_params.get('status')
        if status_filter:
            orders = orders.filter(status=status_filter)

        # Search
        search = request.query_params.get('search')
        if search:
            orders = orders.filter(
                Q(order_number__icontains=search) |
                Q(items__product_name__icontains=search)
            ).distinct()

        # Pagination
        page = int(request.query_params.get('page', 1))
        limit = int(request.query_params.get('limit', 20))
        offset = (page - 1) * limit
        total = orders.count()

        orders = orders[offset:offset + limit]

        data = []
        for order in orders:
            items = [{
                'id': item.id,
                'product_id': item.product_id,
                'product_name': item.product_name,
                'product_image': item.product_image,
                'quantity': item.quantity,
                'unit_price': float(item.unit_price),
                'total_price': float(item.total_price),
            } for item in order.items.all()]

            data.append({
                'id': order.id,
                'order_number': order.order_number,
                'uuid': str(order.uuid),
                'status': order.status,
                'status_display': order.status_display,
                'vendor': {
                    'id': order.vendor.id,
                    'shop_name': order.vendor.shop_name,
                    'logo': request.build_absolute_uri(order.vendor.logo.url) if order.vendor.logo else None,
                },
                'items': items,
                'subtotal': float(order.subtotal),
                'delivery_fee': float(order.delivery_fee),
                'total_amount': float(order.total_amount),
                'delivery_type': order.delivery_type,
                'is_paid': order.is_paid,
                'can_be_cancelled': order.can_be_cancelled,
                'can_be_reviewed': order.can_be_reviewed,
                'created_at': order.created_at.isoformat(),
                'delivered_at': order.delivered_at.isoformat() if order.delivered_at else None,
            })

        return Response({
            'results': data,
            'total': total,
            'page': page,
            'pages': (total + limit - 1) // limit,
        })


class CustomerOrderDetailView(APIView):
    """Get customer order details with status history"""
    permission_classes = [IsAuthenticated]

    def get(self, request, order_number):
        order = get_object_or_404(
            Order.objects.select_related('vendor__user').prefetch_related('items', 'status_history'),
            order_number=order_number,
            customer=request.user
        )

        items = [{
            'id': item.id,
            'product_id': item.product_id,
            'product_name': item.product_name,
            'product_image': item.product_image,
            'quantity': item.quantity,
            'unit_price': float(item.unit_price),
            'total_price': float(item.total_price),
            'has_been_reviewed': item.has_been_reviewed,
        } for item in order.items.all()]

        status_history = [{
            'status': h.status,
            'notes': h.notes,
            'created_at': h.created_at.isoformat(),
        } for h in order.status_history.all()]

        # Get review if exists
        review_data = None
        try:
            review = order.review
            review_data = {
                'overall_rating': review.overall_rating,
                'delivery_rating': review.delivery_rating,
                'product_rating': review.product_rating,
                'comment': review.comment,
                'vendor_response': review.vendor_response,
                'created_at': review.created_at.isoformat(),
            }
        except OrderReview.DoesNotExist:
            pass

        return Response({
            'id': order.id,
            'order_number': order.order_number,
            'uuid': str(order.uuid),
            'status': order.status,
            'status_display': order.status_display,
            'vendor': {
                'id': order.vendor.id,
                'shop_name': order.vendor.shop_name,
                'logo': request.build_absolute_uri(order.vendor.logo.url) if order.vendor.logo else None,
                'phone': order.vendor.user.phone_number,
            },
            'items': items,
            'subtotal': float(order.subtotal),
            'delivery_fee': float(order.delivery_fee),
            'total_amount': float(order.total_amount),
            'delivery_type': order.delivery_type,
            'delivery_address': order.delivery_address,
            'delivery_phone': order.delivery_phone,
            'delivery_notes': order.delivery_notes,
            'payment_method': order.payment_method,
            'payment_reference': order.payment_reference,
            'is_paid': order.is_paid,
            'paid_at': order.paid_at.isoformat() if order.paid_at else None,
            'can_be_cancelled': order.can_be_cancelled,
            'can_be_reviewed': order.can_be_reviewed,
            'cancellation_reason': order.cancellation_reason,
            'status_history': status_history,
            'review': review_data,
            'created_at': order.created_at.isoformat(),
            'confirmed_at': order.confirmed_at.isoformat() if order.confirmed_at else None,
            'delivered_at': order.delivered_at.isoformat() if order.delivered_at else None,
            'completed_at': order.completed_at.isoformat() if order.completed_at else None,
        })


class CustomerCancelOrderView(APIView):
    """Customer cancels their order"""
    permission_classes = [IsAuthenticated]

    def post(self, request, order_number):
        order = get_object_or_404(
            Order,
            order_number=order_number,
            customer=request.user
        )

        if not order.can_be_cancelled:
            return Response({
                'error': 'This order cannot be cancelled'
            }, status=status.HTTP_400_BAD_REQUEST)

        reason = request.data.get('reason', 'Cancelled by customer')

        old_status = order.status
        order.status = 'cancelled'
        order.cancellation_reason = reason
        order.save()

        # Add status history
        OrderStatusHistory.objects.create(
            order=order,
            status='cancelled',
            notes=reason,
            changed_by=request.user
        )

        # Notify vendor
        Notification.objects.create(
            recipient=order.vendor.user,
            notification_type='order',
            title='Order Cancelled',
            message=f'Order #{order.order_number} has been cancelled by the customer.',
            link=f'/vendor/orders/{order.order_number}'
        )

        return Response({
            'message': 'Order cancelled successfully',
            'order_number': order.order_number,
            'status': order.status,
        })


class CustomerOrderReviewView(APIView):
    """Customer reviews order after delivery"""
    permission_classes = [IsAuthenticated]

    def post(self, request, order_number):
        order = get_object_or_404(
            Order,
            order_number=order_number,
            customer=request.user
        )

        if not order.can_be_reviewed:
            return Response({
                'error': 'This order cannot be reviewed'
            }, status=status.HTTP_400_BAD_REQUEST)

        # Check if already reviewed
        if hasattr(order, 'review'):
            return Response({
                'error': 'Order already reviewed'
            }, status=status.HTTP_400_BAD_REQUEST)

        overall_rating = request.data.get('overall_rating')
        if not overall_rating or overall_rating not in range(1, 6):
            return Response({
                'error': 'Overall rating (1-5) is required'
            }, status=status.HTTP_400_BAD_REQUEST)

        review = OrderReview.objects.create(
            order=order,
            customer=request.user,
            vendor=order.vendor,
            overall_rating=overall_rating,
            delivery_rating=request.data.get('delivery_rating'),
            product_rating=request.data.get('product_rating'),
            comment=request.data.get('comment'),
        )

        order.has_been_reviewed = True
        order.save()

        # Notify vendor
        Notification.objects.create(
            recipient=order.vendor.user,
            notification_type='order',
            title='New Order Review',
            message=f'You received a {overall_rating}-star review for order #{order.order_number}.',
            link=f'/vendor/orders/{order.order_number}'
        )

        return Response({
            'message': 'Review submitted successfully',
            'review': {
                'overall_rating': review.overall_rating,
                'delivery_rating': review.delivery_rating,
                'product_rating': review.product_rating,
                'comment': review.comment,
            }
        }, status=status.HTTP_201_CREATED)


class CreateOrderView(APIView):
    """Create a new order (usually after M-Pesa payment)"""
    permission_classes = [IsAuthenticated]

    def post(self, request):
        vendor_id = request.data.get('vendor_id')
        items_data = request.data.get('items', [])
        delivery_type = request.data.get('delivery_type', 'delivery')
        delivery_address = request.data.get('delivery_address')
        delivery_phone = request.data.get('delivery_phone')
        delivery_notes = request.data.get('delivery_notes')
        delivery_county = request.data.get('delivery_county')  # Customer's county
        payment_method = request.data.get('payment_method', 'mpesa')

        if not vendor_id:
            return Response({'error': 'Vendor ID is required'}, status=status.HTTP_400_BAD_REQUEST)

        if not items_data:
            return Response({'error': 'At least one item is required'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            vendor = VendorProfile.objects.get(id=vendor_id)
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor not found'}, status=status.HTTP_404_NOT_FOUND)

        # Validate delivery type
        if delivery_type == 'delivery' and not vendor.delivery_enabled:
            return Response({'error': 'This vendor does not offer delivery'}, status=status.HTTP_400_BAD_REQUEST)

        if delivery_type == 'pickup' and not vendor.pickup_enabled:
            return Response({'error': 'This vendor does not allow pickup'}, status=status.HTTP_400_BAD_REQUEST)

        # Calculate totals
        subtotal = 0
        order_items = []

        for item_data in items_data:
            product_id = item_data.get('product_id')
            quantity = item_data.get('quantity', 1)

            try:
                product = Product.objects.get(id=product_id)
            except Product.DoesNotExist:
                return Response({'error': f'Product {product_id} not found'}, status=status.HTTP_404_NOT_FOUND)

            # Verify product belongs to vendor
            if product.vendor_id != vendor.id:
                return Response({'error': 'Product does not belong to this vendor'}, status=status.HTTP_400_BAD_REQUEST)

            item_total = product.price * quantity
            subtotal += item_total

            order_items.append({
                'product': product,
                'product_name': product.name,
                'product_image': request.build_absolute_uri(product.primary_image.url) if product.primary_image else None,
                'quantity': quantity,
                'unit_price': product.price,
                'total_price': item_total,
            })

        # Calculate delivery fee based on zone-based system
        delivery_fee = 0
        if delivery_type == 'delivery':
            from accounts.models import VendorDeliveryZone

            # Check if any product has custom delivery fee (not using vendor settings)
            custom_fee_product = None
            for item in order_items:
                if not item['product'].use_vendor_delivery_settings and item['product'].delivery_fee:
                    if custom_fee_product is None or item['product'].delivery_fee > custom_fee_product:
                        custom_fee_product = item['product'].delivery_fee

            if custom_fee_product:
                # Use highest product-specific delivery fee
                delivery_fee = custom_fee_product
            elif delivery_county:
                # Use vendor's zone-based fee
                zone = VendorDeliveryZone.objects.filter(
                    vendor=vendor,
                    county=delivery_county,
                    is_active=True
                ).first()

                if zone:
                    delivery_fee = zone.delivery_fee
                else:
                    # Use default delivery fee
                    delivery_fee = vendor.default_delivery_fee
            else:
                # No county provided, use default
                delivery_fee = vendor.default_delivery_fee

            # Check free delivery threshold
            if vendor.free_delivery_threshold and subtotal >= vendor.free_delivery_threshold:
                delivery_fee = 0

        total_amount = subtotal + delivery_fee

        # Create order
        order = Order.objects.create(
            customer=request.user,
            vendor=vendor,
            subtotal=subtotal,
            delivery_fee=delivery_fee,
            total_amount=total_amount,
            delivery_type=delivery_type,
            delivery_address=delivery_address,
            delivery_phone=delivery_phone or request.user.phone_number,
            delivery_notes=delivery_notes,
            payment_method=payment_method,
        )

        # Create order items
        for item_data in order_items:
            OrderItem.objects.create(
                order=order,
                product=item_data['product'],
                product_name=item_data['product_name'],
                product_image=item_data['product_image'],
                quantity=item_data['quantity'],
                unit_price=item_data['unit_price'],
                total_price=item_data['total_price'],
            )

        # Add initial status history
        OrderStatusHistory.objects.create(
            order=order,
            status='pending',
            notes='Order placed',
            changed_by=request.user
        )

        # Notify vendor
        Notification.objects.create(
            recipient=vendor.user,
            notification_type='order',
            title='New Order Received',
            message=f'You have a new order #{order.order_number} worth KES {total_amount}',
            link=f'/vendor/orders/{order.order_number}'
        )

        return Response({
            'message': 'Order created successfully',
            'order_number': order.order_number,
            'total_amount': float(total_amount),
        }, status=status.HTTP_201_CREATED)


# ==================== VENDOR VIEWS ====================

class VendorOrdersView(APIView):
    """List vendor's received orders"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        try:
            vendor = request.user.vendor_profile
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor profile not found'}, status=status.HTTP_403_FORBIDDEN)

        orders = Order.objects.filter(vendor=vendor).select_related(
            'customer'
        ).prefetch_related('items')

        # Filter by status
        status_filter = request.query_params.get('status')
        if status_filter:
            orders = orders.filter(status=status_filter)

        # Search
        search = request.query_params.get('search')
        if search:
            orders = orders.filter(
                Q(order_number__icontains=search) |
                Q(customer__full_name__icontains=search) |
                Q(delivery_phone__icontains=search)
            )

        # Pagination
        page = int(request.query_params.get('page', 1))
        limit = int(request.query_params.get('limit', 20))
        offset = (page - 1) * limit
        total = orders.count()

        orders = orders[offset:offset + limit]

        data = []
        for order in orders:
            items = [{
                'id': item.id,
                'product_name': item.product_name,
                'quantity': item.quantity,
                'total_price': float(item.total_price),
            } for item in order.items.all()]

            data.append({
                'id': order.id,
                'order_number': order.order_number,
                'status': order.status,
                'status_display': order.status_display,
                'customer': {
                    'id': order.customer.id,
                    'name': order.customer.full_name,
                    'phone': order.delivery_phone or order.customer.phone_number,
                },
                'items': items,
                'items_count': len(items),
                'total_amount': float(order.total_amount),
                'delivery_type': order.delivery_type,
                'is_paid': order.is_paid,
                'created_at': order.created_at.isoformat(),
            })

        return Response({
            'results': data,
            'total': total,
            'page': page,
            'pages': (total + limit - 1) // limit,
        })


class VendorOrderDetailView(APIView):
    """Get vendor order details"""
    permission_classes = [IsAuthenticated]

    def get(self, request, order_number):
        try:
            vendor = request.user.vendor_profile
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor profile not found'}, status=status.HTTP_403_FORBIDDEN)

        order = get_object_or_404(
            Order.objects.select_related('customer').prefetch_related('items', 'status_history'),
            order_number=order_number,
            vendor=vendor
        )

        items = [{
            'id': item.id,
            'product_id': item.product_id,
            'product_name': item.product_name,
            'product_image': item.product_image,
            'quantity': item.quantity,
            'unit_price': float(item.unit_price),
            'total_price': float(item.total_price),
        } for item in order.items.all()]

        status_history = [{
            'status': h.status,
            'notes': h.notes,
            'changed_by': h.changed_by.full_name if h.changed_by else 'System',
            'created_at': h.created_at.isoformat(),
        } for h in order.status_history.all()]

        # Get review if exists
        review_data = None
        try:
            review = order.review
            review_data = {
                'overall_rating': review.overall_rating,
                'delivery_rating': review.delivery_rating,
                'product_rating': review.product_rating,
                'comment': review.comment,
                'vendor_response': review.vendor_response,
                'created_at': review.created_at.isoformat(),
            }
        except OrderReview.DoesNotExist:
            pass

        return Response({
            'id': order.id,
            'order_number': order.order_number,
            'status': order.status,
            'status_display': order.status_display,
            'customer': {
                'id': order.customer.id,
                'name': order.customer.full_name,
                'phone': order.delivery_phone or order.customer.phone_number,
                'email': order.customer.email,
            },
            'items': items,
            'subtotal': float(order.subtotal),
            'delivery_fee': float(order.delivery_fee),
            'total_amount': float(order.total_amount),
            'delivery_type': order.delivery_type,
            'delivery_address': order.delivery_address,
            'delivery_phone': order.delivery_phone,
            'delivery_notes': order.delivery_notes,
            'payment_method': order.payment_method,
            'payment_reference': order.payment_reference,
            'is_paid': order.is_paid,
            'cancellation_reason': order.cancellation_reason,
            'hold_reason': order.hold_reason,
            'status_history': status_history,
            'review': review_data,
            'created_at': order.created_at.isoformat(),
            'confirmed_at': order.confirmed_at.isoformat() if order.confirmed_at else None,
            'delivered_at': order.delivered_at.isoformat() if order.delivered_at else None,
        })


class VendorUpdateOrderStatusView(APIView):
    """Vendor updates order status"""
    permission_classes = [IsAuthenticated]

    # Valid status transitions
    VALID_TRANSITIONS = {
        'pending': ['confirmed', 'cancelled', 'on_hold'],
        'confirmed': ['processing', 'cancelled', 'on_hold'],
        'processing': ['ready_for_pickup', 'dispatched', 'cancelled', 'on_hold'],
        'ready_for_pickup': ['completed', 'cancelled'],
        'dispatched': ['out_for_delivery', 'cancelled'],
        'out_for_delivery': ['delivered', 'failed'],
        'delivered': ['completed'],
        'on_hold': ['confirmed', 'cancelled'],
        'failed': ['dispatched', 'refunded'],
        'completed': [],  # Terminal state
        'cancelled': ['refunded'],  # Can only refund
        'refunded': [],  # Terminal state
    }

    def post(self, request, order_number):
        try:
            vendor = request.user.vendor_profile
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor profile not found'}, status=status.HTTP_403_FORBIDDEN)

        order = get_object_or_404(Order, order_number=order_number, vendor=vendor)

        new_status = request.data.get('status')
        notes = request.data.get('notes', '')

        if not new_status:
            return Response({'error': 'Status is required'}, status=status.HTTP_400_BAD_REQUEST)

        # Validate transition
        valid_next = self.VALID_TRANSITIONS.get(order.status, [])
        if new_status not in valid_next:
            return Response({
                'error': f'Cannot change status from {order.status} to {new_status}',
                'valid_options': valid_next,
            }, status=status.HTTP_400_BAD_REQUEST)

        old_status = order.status
        order.status = new_status

        # Update timestamps
        if new_status == 'confirmed':
            order.confirmed_at = timezone.now()
        elif new_status == 'delivered':
            order.delivered_at = timezone.now()
        elif new_status == 'completed':
            order.completed_at = timezone.now()
        elif new_status == 'on_hold':
            order.hold_reason = notes
        elif new_status == 'cancelled':
            order.cancellation_reason = notes

        order.save()

        # Add status history
        OrderStatusHistory.objects.create(
            order=order,
            status=new_status,
            notes=notes,
            changed_by=request.user
        )

        # Notify customer
        status_messages = {
            'confirmed': 'Your order has been confirmed!',
            'processing': 'Your order is being prepared.',
            'ready_for_pickup': 'Your order is ready for pickup!',
            'dispatched': 'Your order has been dispatched.',
            'out_for_delivery': 'Your order is out for delivery!',
            'delivered': 'Your order has been delivered. Please leave a review!',
            'completed': 'Your order is complete. Thank you for shopping with us!',
            'cancelled': f'Your order has been cancelled. Reason: {notes}',
            'on_hold': f'Your order is on hold. Reason: {notes}',
            'refunded': 'Your payment has been refunded.',
        }

        Notification.objects.create(
            recipient=order.customer,
            notification_type='order',
            title=f'Order #{order.order_number} Update',
            message=status_messages.get(new_status, f'Order status updated to {new_status}'),
            link=f'/orders/{order.order_number}'
        )

        return Response({
            'message': 'Order status updated successfully',
            'order_number': order.order_number,
            'old_status': old_status,
            'new_status': new_status,
        })


class VendorRespondToReviewView(APIView):
    """Vendor responds to customer review"""
    permission_classes = [IsAuthenticated]

    def post(self, request, order_number):
        try:
            vendor = request.user.vendor_profile
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor profile not found'}, status=status.HTTP_403_FORBIDDEN)

        order = get_object_or_404(Order, order_number=order_number, vendor=vendor)

        try:
            review = order.review
        except OrderReview.DoesNotExist:
            return Response({'error': 'No review found for this order'}, status=status.HTTP_404_NOT_FOUND)

        response_text = request.data.get('response')
        if not response_text:
            return Response({'error': 'Response is required'}, status=status.HTTP_400_BAD_REQUEST)

        review.vendor_response = response_text
        review.vendor_responded_at = timezone.now()
        review.save()

        return Response({
            'message': 'Response submitted successfully',
            'vendor_response': review.vendor_response,
        })


class VendorOrderStatsView(APIView):
    """Get vendor order statistics"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        try:
            vendor = request.user.vendor_profile
        except VendorProfile.DoesNotExist:
            return Response({'error': 'Vendor profile not found'}, status=status.HTTP_403_FORBIDDEN)

        orders = Order.objects.filter(vendor=vendor)

        # Status counts
        status_counts = orders.values('status').annotate(count=Count('id'))
        status_dict = {s['status']: s['count'] for s in status_counts}

        # Today's orders
        today = timezone.now().date()
        today_orders = orders.filter(created_at__date=today).count()

        # Review stats
        review_stats = OrderReview.objects.filter(vendor=vendor).aggregate(
            average_rating=Avg('overall_rating'),
            total_reviews=Count('id'),
        )

        return Response({
            'total_orders': orders.count(),
            'today_orders': today_orders,
            'status_breakdown': status_dict,
            'pending_count': status_dict.get('pending', 0),
            'processing_count': (
                status_dict.get('confirmed', 0) +
                status_dict.get('processing', 0)
            ),
            'completed_count': status_dict.get('completed', 0),
            'cancelled_count': status_dict.get('cancelled', 0),
            'average_rating': round(review_stats['average_rating'] or 0, 1),
            'total_reviews': review_stats['total_reviews'],
        })


# ==================== ADMIN VIEWS ====================

class AdminOrdersView(APIView):
    """Admin view of all orders"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not request.user.is_staff and request.user.user_type != 'admin':
            return Response({'error': 'Admin access required'}, status=status.HTTP_403_FORBIDDEN)

        orders = Order.objects.select_related('customer', 'vendor__user').prefetch_related('items')

        # Filter by status
        status_filter = request.query_params.get('status')
        if status_filter:
            orders = orders.filter(status=status_filter)

        # Filter by vendor
        vendor_id = request.query_params.get('vendor_id')
        if vendor_id:
            orders = orders.filter(vendor_id=vendor_id)

        # Search
        search = request.query_params.get('search')
        if search:
            orders = orders.filter(
                Q(order_number__icontains=search) |
                Q(customer__full_name__icontains=search) |
                Q(vendor__shop_name__icontains=search)
            )

        # Date filter
        date_from = request.query_params.get('date_from')
        date_to = request.query_params.get('date_to')
        if date_from:
            orders = orders.filter(created_at__date__gte=date_from)
        if date_to:
            orders = orders.filter(created_at__date__lte=date_to)

        # Pagination
        page = int(request.query_params.get('page', 1))
        limit = int(request.query_params.get('limit', 20))
        offset = (page - 1) * limit
        total = orders.count()

        orders = orders[offset:offset + limit]

        data = []
        for order in orders:
            data.append({
                'id': order.id,
                'order_number': order.order_number,
                'status': order.status,
                'status_display': order.status_display,
                'customer': {
                    'id': order.customer.id,
                    'name': order.customer.full_name,
                },
                'vendor': {
                    'id': order.vendor.id,
                    'shop_name': order.vendor.shop_name,
                },
                'items_count': order.items.count(),
                'total_amount': float(order.total_amount),
                'is_paid': order.is_paid,
                'created_at': order.created_at.isoformat(),
            })

        return Response({
            'results': data,
            'total': total,
            'page': page,
            'pages': (total + limit - 1) // limit,
        })


class AdminOrderDetailView(APIView):
    """Admin view order details"""
    permission_classes = [IsAuthenticated]

    def get(self, request, order_number):
        if not request.user.is_staff and request.user.user_type != 'admin':
            return Response({'error': 'Admin access required'}, status=status.HTTP_403_FORBIDDEN)

        order = get_object_or_404(
            Order.objects.select_related('customer', 'vendor__user').prefetch_related('items', 'status_history'),
            order_number=order_number
        )

        items = [{
            'id': item.id,
            'product_id': item.product_id,
            'product_name': item.product_name,
            'quantity': item.quantity,
            'unit_price': float(item.unit_price),
            'total_price': float(item.total_price),
        } for item in order.items.all()]

        status_history = [{
            'status': h.status,
            'notes': h.notes,
            'changed_by': h.changed_by.full_name if h.changed_by else 'System',
            'created_at': h.created_at.isoformat(),
        } for h in order.status_history.all()]

        return Response({
            'id': order.id,
            'order_number': order.order_number,
            'status': order.status,
            'status_display': order.status_display,
            'customer': {
                'id': order.customer.id,
                'name': order.customer.full_name,
                'phone': order.customer.phone_number,
                'email': order.customer.email,
            },
            'vendor': {
                'id': order.vendor.id,
                'shop_name': order.vendor.shop_name,
                'phone': order.vendor.user.phone_number,
            },
            'items': items,
            'subtotal': float(order.subtotal),
            'delivery_fee': float(order.delivery_fee),
            'total_amount': float(order.total_amount),
            'delivery_type': order.delivery_type,
            'delivery_address': order.delivery_address,
            'payment_method': order.payment_method,
            'is_paid': order.is_paid,
            'cancellation_reason': order.cancellation_reason,
            'status_history': status_history,
            'created_at': order.created_at.isoformat(),
        })


class AdminOrderStatsView(APIView):
    """Admin order statistics"""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not request.user.is_staff and request.user.user_type != 'admin':
            return Response({'error': 'Admin access required'}, status=status.HTTP_403_FORBIDDEN)

        orders = Order.objects.all()

        # Status counts
        status_counts = orders.values('status').annotate(count=Count('id'))
        status_dict = {s['status']: s['count'] for s in status_counts}

        # Today's orders
        today = timezone.now().date()
        today_orders = orders.filter(created_at__date=today)

        # This week
        week_ago = today - timezone.timedelta(days=7)
        week_orders = orders.filter(created_at__date__gte=week_ago)

        return Response({
            'total_orders': orders.count(),
            'today_orders': today_orders.count(),
            'week_orders': week_orders.count(),
            'status_breakdown': status_dict,
            'pending_count': status_dict.get('pending', 0),
            'completed_count': status_dict.get('completed', 0),
            'cancelled_count': status_dict.get('cancelled', 0),
        })


# ==================== PUBLIC VIEW ====================

class TrackOrderView(APIView):
    """Public order tracking by order number"""
    permission_classes = [AllowAny]

    def get(self, request, order_number):
        order = get_object_or_404(
            Order.objects.prefetch_related('status_history'),
            order_number=order_number
        )

        status_history = [{
            'status': h.status,
            'notes': h.notes,
            'created_at': h.created_at.isoformat(),
        } for h in order.status_history.all()]

        return Response({
            'order_number': order.order_number,
            'status': order.status,
            'status_display': order.status_display,
            'items_count': order.items.count(),
            'total_amount': float(order.total_amount),
            'delivery_type': order.delivery_type,
            'status_history': status_history,
            'created_at': order.created_at.isoformat(),
            'delivered_at': order.delivered_at.isoformat() if order.delivered_at else None,
        })