from rest_framework import viewsets, status, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAdminUser
from django_filters.rest_framework import DjangoFilterBackend
from .models import Notification, Favorite, Activity, Report
from .serializers import NotificationSerializer, FavoriteSerializer, ActivitySerializer, ReportSerializer
from common.pagination import StandardResultsSetPagination


class NotificationViewSet(viewsets.ReadOnlyModelViewSet):
    """Notification ViewSet"""
    serializer_class = NotificationSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = StandardResultsSetPagination
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter]
    filterset_fields = ['type', 'is_read']
    ordering_fields = ['created_at']
    ordering = ['-created_at']
    
    def get_queryset(self):
        return Notification.objects.filter(user=self.request.user)
    
    @action(detail=True, methods=['post'])
    def mark_read(self, request, pk=None):
        """Mark notification as read"""
        notification = self.get_object()
        notification.mark_as_read()
        return Response(NotificationSerializer(notification).data)
    
    @action(detail=False, methods=['post'])
    def mark_all_read(self, request):
        """Mark all notifications as read"""
        count = Notification.objects.filter(
            user=request.user,
            is_read=False
        ).update(is_read=True)
        return Response({'message': f'{count} notifications marked as read'})
    
    @action(detail=False, methods=['get'])
    def unread_count(self, request):
        """Get unread notifications count"""
        count = Notification.objects.filter(
            user=request.user,
            is_read=False
        ).count()
        return Response({'count': count})


class FavoriteViewSet(viewsets.ModelViewSet):
    """Favorite ViewSet"""
    serializer_class = FavoriteSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = StandardResultsSetPagination
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter]
    ordering_fields = ['created_at']
    ordering = ['-created_at']
    
    def get_queryset(self):
        return Favorite.objects.filter(user=self.request.user)
    
    def perform_create(self, serializer):
        serializer.save(user=self.request.user)
    
    @action(detail=False, methods=['post'])
    def toggle(self, request):
        """Toggle favorite status for a place"""
        from places.models import Place
        import logging
        
        logger = logging.getLogger(__name__)
        
        # Get place_id from request
        place_id = request.data.get('place_id') or request.query_params.get('place_id')
        logger.info(f"Toggle favorite request - User: {request.user.id}, Place ID: {place_id}")
        
        if not place_id:
            logger.warning(f"Toggle favorite failed - place_id is missing")
            return Response(
                {'error': 'place_id is required'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        try:
            place = Place.objects.get(pk=place_id)
        except Place.DoesNotExist:
            logger.warning(f"Toggle favorite failed - Place {place_id} not found")
            return Response(
                {'error': 'Place not found'},
                status=status.HTTP_404_NOT_FOUND
            )
        
        favorite = Favorite.objects.filter(
            user=request.user,
            place=place
        ).first()
        
        if favorite:
            # If favorite exists, remove it
            favorite.delete()
            is_favorite = False
            logger.info(f"Favorite removed - User: {request.user.id}, Place: {place_id}")
        else:
            # Create new favorite
            Favorite.objects.create(user=request.user, place=place)
            is_favorite = True
            logger.info(f"Favorite added - User: {request.user.id}, Place: {place_id}")
        
        return Response({
            'is_favorite': is_favorite,
            'place_id': place.id,
            'message': 'تم إضافة المكان إلى المفضلة' if is_favorite else 'تم إزالة المكان من المفضلة'
        })


class ActivityViewSet(viewsets.ModelViewSet):
    """Activity ViewSet"""
    serializer_class = ActivitySerializer
    permission_classes = [IsAuthenticated]
    pagination_class = StandardResultsSetPagination
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter]
    filterset_fields = ['type']
    ordering_fields = ['created_at']
    ordering = ['-created_at']
    
    def get_queryset(self):
        return Activity.objects.filter(user=self.request.user)
    
    def perform_create(self, serializer):
        serializer.save(user=self.request.user)
    
    @action(detail=False, methods=['post'])
    def clear(self, request):
        """Clear all activities"""
        count = Activity.objects.filter(user=request.user).delete()[0]
        return Response({'message': f'{count} activities cleared'})


class ReportViewSet(viewsets.ModelViewSet):
    """Report ViewSet"""
    serializer_class = ReportSerializer
    pagination_class = StandardResultsSetPagination
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter, filters.SearchFilter]
    filterset_fields = ['report_type', 'status', 'place', 'review']
    ordering_fields = ['created_at', 'updated_at']
    ordering = ['-created_at']
    search_fields = ['reason', 'description']
    
    def get_permissions(self):
        """Set permissions based on action"""
        if self.action in ['list', 'retrieve', 'update', 'partial_update', 'destroy']:
            return [IsAdminUser()]
        return [IsAuthenticated()]
    
    def get_queryset(self):
        """Filter queryset based on user permissions"""
        if self.request.user.is_staff:
            return Report.objects.all()
        return Report.objects.filter(reporter=self.request.user)
    
    def perform_create(self, serializer):
        """Set reporter to current user"""
        serializer.save(reporter=self.request.user)
    
    @action(detail=True, methods=['post'], permission_classes=[IsAdminUser])
    def resolve(self, request, pk=None):
        """Mark report as resolved (Admin only)"""
        report = self.get_object()
        notes = request.data.get('notes', '')
        report.mark_as_resolved(request.user, notes)
        return Response(ReportSerializer(report).data)
    
    @action(detail=True, methods=['post'], permission_classes=[IsAdminUser])
    def reject(self, request, pk=None):
        """Mark report as rejected (Admin only)"""
        report = self.get_object()
        notes = request.data.get('notes', '')
        report.mark_as_rejected(request.user, notes)
        return Response(ReportSerializer(report).data)
    
    @action(detail=True, methods=['post'], permission_classes=[IsAdminUser])
    def under_review(self, request, pk=None):
        """Mark report as under review (Admin only)"""
        from .models import ReportStatus
        report = self.get_object()
        report.status = ReportStatus.UNDER_REVIEW
        report.save(update_fields=['status'])
        return Response(ReportSerializer(report).data)