from django.shortcuts import get_object_or_404
from rest_framework import generics, status, viewsets
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import AllowAny
from django.db.models import Q
from .models import Notification, SiteStatistic, NotificationCategory, NotificationTag
from .serializers import (
    NotificationListSerializer, 
    NotificationDetailSerializer, 
    SiteStatisticSerializer,
    NotificationStatsResponseSerializer,
    NotificationCategorySerializer,
    NotificationTagSerializer
)


class NotificationPagination(PageNumberPagination):
    page_size = 6  # 6 notifications per page (2 slides of 3 each)
    page_size_query_param = 'page_size'
    max_page_size = 50


class NotificationListView(generics.ListAPIView):
    """
    List all active notifications with pagination
    """
    serializer_class = NotificationListSerializer
    pagination_class = NotificationPagination
    
    def get_queryset(self):
        queryset = Notification.objects.filter(is_active=True)
        
        # Filter by category
        category = self.request.query_params.get('category', None)
        if category:
            queryset = queryset.filter(category__name__iexact=category)
        
        # Filter by priority
        priority = self.request.query_params.get('priority', None)
        if priority:
            queryset = queryset.filter(priority=priority)
        
        # Filter by featured
        featured = self.request.query_params.get('featured', None)
        if featured and featured.lower() == 'true':
            queryset = queryset.filter(is_featured=True)
        
        # Search functionality
        search = self.request.query_params.get('search', None)
        if search:
            queryset = queryset.filter(
                Q(title__icontains=search) | 
                Q(description__icontains=search) |
                Q(content__icontains=search)
            )
        
        return queryset.select_related('category').prefetch_related('notification_tags__tag')


class NotificationDetailView(generics.RetrieveAPIView):
    """
    Retrieve a specific notification by slug
    """
    queryset = Notification.objects.filter(is_active=True)
    serializer_class = NotificationDetailSerializer
    lookup_field = 'slug'
    
    def get_object(self):
        slug = self.kwargs.get('slug')
        return get_object_or_404(
            Notification.objects.select_related('category').prefetch_related('notification_tags__tag'),
            slug=slug,
            is_active=True
        )


class SiteStatisticListView(generics.ListAPIView):
    """
    List all active site statistics
    """
    queryset = SiteStatistic.objects.filter(is_active=True)
    serializer_class = SiteStatisticSerializer


@api_view(['GET'])
def notifications_and_stats(request):
    """
    Combined endpoint to get notifications and statistics for the homepage
    """
    # Get notifications with pagination
    notification_view = NotificationListView()
    notification_view.request = request
    notification_view.format_kwarg = None
    
    notifications_queryset = notification_view.get_queryset()
    paginator = NotificationPagination()
    paginated_notifications = paginator.paginate_queryset(notifications_queryset, request)
    notification_serializer = NotificationListSerializer(paginated_notifications, many=True)
    
    # Get statistics
    statistics_queryset = SiteStatistic.objects.filter(is_active=True)
    statistics_serializer = SiteStatisticSerializer(statistics_queryset, many=True)
    
    # Prepare pagination info
    pagination_info = {
        'count': paginator.page.paginator.count,
        'next': paginator.get_next_link(),
        'previous': paginator.get_previous_link(),
        'total_pages': paginator.page.paginator.num_pages,
        'current_page': paginator.page.number,
        'page_size': paginator.page_size
    } if paginated_notifications else {}
    
    return Response({
        'notifications': notification_serializer.data,
        'statistics': statistics_serializer.data,
        'pagination': pagination_info
    })


@api_view(['GET'])
def notification_categories(request):
    """
    Get all notification categories
    """
    categories = NotificationCategory.objects.all()
    serializer = NotificationCategorySerializer(categories, many=True)
    return Response(serializer.data)


@api_view(['GET'])
def featured_notifications(request):
    """
    Get only featured notifications (for homepage highlights)
    """
    notifications = Notification.objects.filter(is_active=True, is_featured=True)[:6]
    serializer = NotificationListSerializer(notifications, many=True)
    return Response(serializer.data)


class NotificationTagViewSet(viewsets.ReadOnlyModelViewSet):
    """
    Read-only ViewSet for NotificationTag model (GET only)
    Provides list and retrieve operations
    
    Available endpoints:
    - GET /notification-tags/ - List all tags
    - GET /notification-tags/{id}/ - Retrieve a specific tag
    
    Query parameters:
    - ?search=tag_name - Filter tags by name (partial match)
    """
    queryset = NotificationTag.objects.all()
    serializer_class = NotificationTagSerializer
    permission_classes = [AllowAny]
    
    def get_queryset(self):
        """
        Optionally filter tags by a search query
        ?search=tag_name
        """
        queryset = NotificationTag.objects.all()
        search = self.request.query_params.get('search', None)
        if search:
            queryset = queryset.filter(name__icontains=search)
        return queryset.order_by('name')