from django.shortcuts import render

from entry.models import Entry
from entry.serializers import EntrySerializer
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from drf_spectacular.utils import extend_schema, OpenApiParameter
from drf_spectacular.types import OpenApiTypes
from django.utils.dateparse import parse_date, parse_datetime
from django.utils import timezone
from rest_framework.filters import SearchFilter

@extend_schema(tags=['Entry'])
class EntryViewSet(viewsets.ModelViewSet):
    queryset = Entry.objects.all()
    serializer_class = EntrySerializer
    search_fields = ['approval_status', 'payment_option']
    filter_backends = [SearchFilter]
    # permission_classes = [IsAuthenticated]
    
    @extend_schema(
        parameters=[
            OpenApiParameter(
                name='completed',
                type=OpenApiTypes.BOOL,
                location=OpenApiParameter.QUERY,
                description='Filter entries by completion status (true/false)',
                required=False
            ),
            OpenApiParameter(
                name='branch_id',
                type=OpenApiTypes.INT,
                location=OpenApiParameter.QUERY,
                description='Filter entries by branch ID',
                required=False
            ),
            OpenApiParameter(
                name='start_date',
                type=OpenApiTypes.STR,
                location=OpenApiParameter.QUERY,
                description='Filter entries created from this date (format: YYYY-MM-DD or ISO 8601)',
                required=False
            ),
            OpenApiParameter(
                name='end_date',
                type=OpenApiTypes.STR,
                location=OpenApiParameter.QUERY,
                description='Filter entries created until this date (format: YYYY-MM-DD or ISO 8601)',
                required=False
            ),
            OpenApiParameter(
                name='customer_name',
                type=OpenApiTypes.STR,
                location=OpenApiParameter.QUERY,
                description='Filter entries by customer name (case-insensitive partial match)',
                required=False
            ),
            OpenApiParameter(
                name='payment_option',
                type=OpenApiTypes.STR,
                location=OpenApiParameter.QUERY,
                description='Filter entries by payment option (cash, card, momo)',
                required=False
            ),
            OpenApiParameter(
                name='approval_status',
                type=OpenApiTypes.STR,
                location=OpenApiParameter.QUERY,
                description='Filter entries by approval status (pending, approved, declined)',
                required=False
            )
        ]
    )
    def list(self, request, *args, **kwargs):
        return super().list(request, *args, **kwargs)
    
    def get_queryset(self):
        queryset = Entry.objects.all()
        completed = self.request.query_params.get('completed', None)
        if completed is not None:
            queryset = queryset.filter(completed=completed.lower() == 'true')
        
        branch_id = self.request.query_params.get('branch_id', None)
        if branch_id is not None:
            try:
                queryset = queryset.filter(branch_id=int(branch_id))
            except ValueError:
                pass
        
        # Filter by customer name
        customer_name = self.request.query_params.get('customer_name', None)
        if customer_name:
            queryset = queryset.filter(car__customer_name__icontains=customer_name)
        
        # Filter by payment option
        payment_option = self.request.query_params.get('payment_option', None)
        if payment_option:
            queryset = queryset.filter(payment_option=payment_option)
        
        # Filter by approval status
        approval_status = self.request.query_params.get('approval_status', None)
        if approval_status:
            queryset = queryset.filter(approval_status=approval_status)
        
        # Filter by date range
        start_date = self.request.query_params.get('start_date', None)
        if start_date:
            parsed_start = parse_datetime(start_date) or parse_date(start_date)
            if parsed_start:
                if not hasattr(parsed_start, 'hour'):  # If date object
                    parsed_start = timezone.make_aware(timezone.datetime.combine(parsed_start, timezone.datetime.min.time()))
                queryset = queryset.filter(date_created__gte=parsed_start)
        
        end_date = self.request.query_params.get('end_date', None)
        if end_date:
            parsed_end = parse_datetime(end_date) or parse_date(end_date)
            if parsed_end:
                if not hasattr(parsed_end, 'hour'):  # If date object
                    parsed_end = timezone.make_aware(timezone.datetime.combine(parsed_end, timezone.datetime.max.time()))
                queryset = queryset.filter(date_created__lte=parsed_end)
        
        return queryset.order_by('-date_created')
    
    @extend_schema(
        request=None,
        responses={200: {'type': 'object', 'properties': {'message': {'type': 'string'}, 'entry': {}}}},
        tags=['Entry']
    )
    @action(detail=True, methods=['post'])
    def approve(self, request, pk=None):
        """Approve an entry"""
        entry = self.get_object()
        if entry.approval_status == 'approved':
            return Response(
                {'error': 'Entry is already approved'},
                status=status.HTTP_400_BAD_REQUEST
            )
        entry.approval_status = 'approved'
        entry.save()
        return Response({
            'message': 'Entry approved successfully',
            'entry': EntrySerializer(entry).data
        }, status=status.HTTP_200_OK)
    
    @extend_schema(
        request=None,
        responses={200: {'type': 'object', 'properties': {'message': {'type': 'string'}, 'entry': {}}}},
        tags=['Entry']
    )
    @action(detail=True, methods=['post'])
    def decline(self, request, pk=None):
        """Decline an entry"""
        entry = self.get_object()
        if entry.approval_status == 'declined':
            return Response(
                {'error': 'Entry is already declined'},
                status=status.HTTP_400_BAD_REQUEST
            )
        entry.approval_status = 'declined'
        entry.save()
        return Response({
            'message': 'Entry declined successfully',
            'entry': EntrySerializer(entry).data
        }, status=status.HTTP_200_OK)