from rest_framework import viewsets, status, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticatedOrReadOnly, IsAuthenticated
from django_filters.rest_framework import DjangoFilterBackend
from .models import Review, ReviewHelpful
from .serializers import ReviewSerializer, ReviewResponseSerializer
from common.permissions import IsPlaceAdmin, IsPlaceOwner
from common.pagination import StandardResultsSetPagination


class ReviewViewSet(viewsets.ModelViewSet):
    """Review ViewSet"""
    permission_classes = [IsAuthenticatedOrReadOnly]
    pagination_class = StandardResultsSetPagination
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ['place', 'rating', 'is_verified']
    search_fields = ['comment']
    ordering_fields = ['rating', 'created_at', 'helpful_count']
    ordering = ['-created_at']
    
    def get_serializer_class(self):
        if self.action == 'respond':
            return ReviewResponseSerializer
        return ReviewSerializer
    
    def get_queryset(self):
        queryset = Review.objects.filter(is_active=True).select_related(
            'place', 'user'
        )
        
        # Filter by place if provided
        place_id = self.request.query_params.get('place')
        if place_id:
            queryset = queryset.filter(place_id=place_id)
        
        return queryset
    
    def perform_create(self, serializer):
        serializer.save(user=self.request.user)
    
    @action(detail=True, methods=['post'])
    def respond(self, request, pk=None):
        """Place admin responds to a review"""
        review = self.get_object()
        
        # Check if user is place admin of this place
        user = request.user
        if user.role not in ['super_admin', 'admin']:
            if user.role != 'place_admin' or not hasattr(user, 'place_admin_profile') or \
               user.place_admin_profile.place != review.place:
                return Response(
                    {'error': 'You do not have permission to respond to this review'},
                    status=status.HTTP_403_FORBIDDEN
                )
        
        serializer = ReviewResponseSerializer(review, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(ReviewSerializer(review).data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
    @action(detail=True, methods=['post', 'delete'])
    def helpful(self, request, pk=None):
        """Mark review as helpful or remove helpful vote"""
        review = self.get_object()
        
        if request.method == 'POST':
            helpful, created = ReviewHelpful.objects.get_or_create(
                review=review,
                user=request.user
            )
            if created:
                review.helpful_count += 1
                review.save(update_fields=['helpful_count'])
                return Response({'message': 'Marked as helpful'}, status=status.HTTP_201_CREATED)
            return Response({'message': 'Already marked as helpful'}, status=status.HTTP_200_OK)
        
        elif request.method == 'DELETE':
            deleted = ReviewHelpful.objects.filter(review=review, user=request.user).delete()[0]
            if deleted:
                review.helpful_count = max(0, review.helpful_count - 1)
                review.save(update_fields=['helpful_count'])
                return Response({'message': 'Removed helpful vote'}, status=status.HTTP_200_OK)
            return Response({'message': 'Not found'}, status=status.HTTP_404_NOT_FOUND)