from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.decorators import action
from rest_framework.permissions import AllowAny, IsAuthenticated, IsAdminUser
from django.db.models import Q
from blogs.models import Blog
from blogs.api.serializers import (
    BlogListSerializer, 
    BlogDetailSerializer, 
    BlogCreateUpdateSerializer
)


class BlogViewSet(viewsets.ModelViewSet):
    """
    ViewSet for blogs API.
    
    Permissions:
    - list, retrieve: Public (AllowAny)
    - create, update, partial_update, destroy: Admin only (IsAdminUser)
    """
    lookup_field = 'slug'
    
    def get_queryset(self):
        """
        Filter blogs based on user type.
        - Admin: See all blogs
        - Public: See only published blogs
        """
        user = self.request.user
        if user and user.is_staff and user.is_superuser:
            return Blog.objects.all()
        return Blog.objects.filter(is_published=True)
    
    def get_serializer_class(self):
        """Return appropriate serializer based on action"""
        if self.action == 'list':
            return BlogListSerializer
        elif self.action in ['create', 'update', 'partial_update']:
            return BlogCreateUpdateSerializer
        return BlogDetailSerializer
    
    def get_permissions(self):
        """
        Set permissions based on action.
        """
        if self.action in ['list', 'retrieve']:
            return [AllowAny()]
        elif self.action in ['create', 'update', 'partial_update', 'destroy', 'featured']:
            return [IsAdminUser()]
        return [IsAuthenticated()]
    
    def create(self, request, *args, **kwargs):
        """Create a new blog"""
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        
        # Assign author to current user
        blog = serializer.save(author=request.user)
        
        # Return detail view of created blog
        output_serializer = BlogDetailSerializer(blog)
        return Response(output_serializer.data, status=status.HTTP_201_CREATED)
    
    @action(detail=False, methods=['get'])
    def featured(self, request):
        """Get featured blogs"""
        blogs = self.get_queryset().filter(is_featured=True)
        serializer = BlogListSerializer(blogs, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def by_tag(self, request):
        """Get blogs by tag"""
        tag = request.query_params.get('tag')
        if not tag:
            return Response(
                {'error': 'tag parameter is required'}, 
                status=status.HTTP_400_BAD_REQUEST
            )
        
        # Search blogs with the tag
        blogs = self.get_queryset().filter(tags__icontains=tag)
        serializer = BlogListSerializer(blogs, many=True)
        return Response(serializer.data)
    
    @action(detail=False, methods=['get'])
    def search(self, request):
        """Search blogs by title or content"""
        query = request.query_params.get('q')
        if not query:
            return Response(
                {'error': 'q parameter is required'}, 
                status=status.HTTP_400_BAD_REQUEST
            )
        
        blogs = self.get_queryset().filter(
            Q(title__icontains=query) | 
            Q(content__icontains=query)
        )
        serializer = BlogListSerializer(blogs, many=True)
        return Response(serializer.data)