from rest_framework import generics, status
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework.pagination import PageNumberPagination
from django.db.models import Q
from .models import TaskType
from .serializers import TaskTypeSerializer
import logging

logger = logging.getLogger(__name__)

class StandardResultsSetPagination(PageNumberPagination):
    page_size = 10
    page_size_query_param = 'page_size'
    max_page_size = 100

class TaskTypeListCreateView(generics.ListCreateAPIView):
    """
    API endpoint for listing and creating task types
    """
    serializer_class = TaskTypeSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = StandardResultsSetPagination

    def get_queryset(self):
        """
        Filter task types based on query parameters
        """
        queryset = TaskType.objects.all().order_by('-created_at')

        # Search
        search = self.request.query_params.get('search', None)
        if search:
            queryset = queryset.filter(
                Q(name__icontains=search) |
                Q(code__icontains=search) |
                Q(description__icontains=search)
            )

        # Status filter
        is_active = self.request.query_params.get('is_active', None)
        if is_active is not None:
            if is_active.lower() == 'true':
                queryset = queryset.filter(is_active=True)
            elif is_active.lower() == 'false':
                queryset = queryset.filter(is_active=False)

        return queryset

    def list(self, request, *args, **kwargs):
        """
        Override list to return consistent response format
        """
        try:
            queryset = self.filter_queryset(self.get_queryset())
            page = self.paginate_queryset(queryset)
            
            if page is not None:
                serializer = self.get_serializer(page, many=True)
                return self.get_paginated_response(serializer.data)

            serializer = self.get_serializer(queryset, many=True)
            return Response({
                'success': True,
                'results': serializer.data,
                'count': queryset.count()
            })
        except Exception as e:
            logger.error(f"Error in TaskTypeListCreateView: {str(e)}")
            return Response(
                {'success': False, 'message': 'Failed to fetch task types'},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

    def create(self, request, *args, **kwargs):
        """
        Override create to handle validation errors properly
        """
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            try:
                self.perform_create(serializer)
                return Response(
                    {
                        'success': True,
                        'message': 'Task type created successfully',
                        'data': serializer.data
                    },
                    status=status.HTTP_201_CREATED
                )
            except Exception as e:
                logger.error(f"Error creating task type: {str(e)}")
                return Response(
                    {'success': False, 'message': 'Failed to create task type'},
                    status=status.HTTP_500_INTERNAL_SERVER_ERROR
                )
        return Response(
            {
                'success': False,
                'message': 'Validation failed',
                'errors': serializer.errors
            },
            status=status.HTTP_400_BAD_REQUEST
        )

class TaskTypeRetrieveUpdateDestroyView(generics.RetrieveUpdateDestroyAPIView):
    """
    API endpoint for retrieving, updating and deleting task types
    """
    queryset = TaskType.objects.all()
    serializer_class = TaskTypeSerializer
    permission_classes = [IsAuthenticated]

    def retrieve(self, request, *args, **kwargs):
        try:
            instance = self.get_object()
            serializer = self.get_serializer(instance)
            return Response({
                'success': True,
                'data': serializer.data
            })
        except Exception as e:
            logger.error(f"Error retrieving task type: {str(e)}")
            return Response(
                {'success': False, 'message': 'Task type not found'},
                status=status.HTTP_404_NOT_FOUND
            )

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        
        if serializer.is_valid():
            try:
                self.perform_update(serializer)
                return Response({
                    'success': True,
                    'message': 'Task type updated successfully',
                    'data': serializer.data
                })
            except Exception as e:
                logger.error(f"Error updating task type: {str(e)}")
                return Response(
                    {'success': False, 'message': 'Failed to update task type'},
                    status=status.HTTP_500_INTERNAL_SERVER_ERROR
                )
        return Response(
            {
                'success': False,
                'message': 'Validation failed',
                'errors': serializer.errors
            },
            status=status.HTTP_400_BAD_REQUEST
        )

    def destroy(self, request, *args, **kwargs):
        try:
            instance = self.get_object()
            instance.delete()
            return Response({
                'success': True,
                'message': 'Task type deleted successfully'
            }, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error(f"Error deleting task type: {str(e)}")
            return Response(
                {'success': False, 'message': 'Failed to delete task type'},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

class TaskTypeToggleActiveView(generics.GenericAPIView):
    """
    API endpoint to toggle active status of task type
    """
    queryset = TaskType.objects.all()
    permission_classes = [IsAuthenticated]

    def patch(self, request, pk):
        try:
            task_type = self.get_queryset().get(pk=pk)
            task_type.is_active = not task_type.is_active
            task_type.save()
            
            serializer = TaskTypeSerializer(task_type)
            status_text = 'activated' if task_type.is_active else 'deactivated'
            
            return Response({
                'success': True,
                'message': f'Task type {status_text} successfully',
                'data': serializer.data
            })
        except TaskType.DoesNotExist:
            return Response(
                {'success': False, 'message': 'Task type not found'},
                status=status.HTTP_404_NOT_FOUND
            )
        except Exception as e:
            logger.error(f"Error toggling task type status: {str(e)}")
            return Response(
                {'success': False, 'message': 'Failed to toggle task type status'},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )