from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import IsAuthenticated
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from django.shortcuts import get_object_or_404
from django.db import transaction

from common.pagination.custom_pagination import CustomPageNumberPagination
from notification.models import Notification
from service.models.services import Services, ServicesReview
from service.serializers.services_serializer import ServiceSerializer


class ServiceFlagAPIView(APIView):
    """
    Flag a service and create a flagged review with a message.
    """
    permission_classes = [IsAuthenticated]
    
    @swagger_auto_schema(
        operation_description="Flag a service and create a flagged review",
        request_body=openapi.Schema(
            type=openapi.TYPE_OBJECT,
            required=['message'],
            properties={
                'message': openapi.Schema(
                    type=openapi.TYPE_STRING,
                    description='Reason for flagging the service'
                )
            }
        )
    )
    def post(self, request, pk):
        service = get_object_or_404(Services, pk=pk, is_active=True)
        
        # if request.user.role != 'admin' and service.created_by != request.user:
        #     return Response(
        #         {"error": "You don't have permission to flag this service"}, 
        #         status=status.HTTP_403_FORBIDDEN
        #     )
        
        message = request.data.get('message')
        if not message:
            return Response(
                {"error": "Message is required when flagging a service"},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        review_star = 1
        if not isinstance(review_star, int) or review_star < 1 or review_star > 5:
            review_star = 1
        
        with transaction.atomic():
            service.is_flag = True
            service.save(update_fields=['is_flag'])
            
            flagged_review = ServicesReview.objects.create(
                service=service,
                created_by=request.user,
                message=message,
                review_star=review_star,
                is_flagged_review=True
            )

            Notification.objects.create(
                notification_type='service_report',
                service_report_id=flagged_review.id,
                title=f'Service Flagged: {service.name if hasattr(service, "name") else "Service"} (ID: {service.id})',
                message=message,
                status='unread'
            )
        
        return Response({
            "success": "Service flagged successfully",
            "service_id": service.id,
            "is_flag": service.is_flag,
            "flagged_review_id": flagged_review.id
        }, status=status.HTTP_200_OK)


class ServiceUnflagAPIView(APIView):
    """
    Unflag a service. Note: This does not delete flagged reviews.
    """
    permission_classes = [IsAuthenticated]
    
    @swagger_auto_schema(
        operation_description="Unflag a service (does not affect flagged reviews)",
        
    )
    def post(self, request, pk):
        service = get_object_or_404(Services, pk=pk, is_active=True)
        
        # Permission check
        if request.user.role != 'admin' and service.created_by != request.user:
            return Response(
                {"error": "You don't have permission to unflag this service"}, 
                status=status.HTTP_403_FORBIDDEN
            )
        
        service.is_flag = False
        service.save(update_fields=['is_flag'])
        
        return Response({
            "success": "Service unflagged successfully",
            "service_id": service.id,
            "is_flag": service.is_flag
        }, status=status.HTTP_200_OK)


class ServiceFlaggedListAPIView(APIView):
    """
    List all flagged services.
    Admin sees all, regular users see only their own.
    """
    permission_classes = [IsAuthenticated]
    
    @swagger_auto_schema(
        operation_description="Get paginated list of flagged services",
        manual_parameters=[
            openapi.Parameter('page', openapi.IN_QUERY, description="Page number", type=openapi.TYPE_INTEGER),
            openapi.Parameter('page_size', openapi.IN_QUERY, description="Number of items per page", type=openapi.TYPE_INTEGER),
            openapi.Parameter('service_category', openapi.IN_QUERY, description="Filter by service category", type=openapi.TYPE_INTEGER),
            openapi.Parameter('category_services', openapi.IN_QUERY, description="Filter by category services ID", type=openapi.TYPE_INTEGER),
        ],
        responses={200: ServiceSerializer(many=True)}
    )
    def get(self, request):
        services = Services.objects.filter(is_flag=True, is_active=True).select_related(
            'company', 'category_services', 'created_by'
        ).order_by('-created_at')
        
        user = request.user
        if user.role != 'admin':
            services = services.filter(created_by=user)
        
        service_category = request.query_params.get('service_category')
        category_services = request.query_params.get('category_services')
        
        if service_category:
            services = services.filter(service_category=service_category)
        if category_services:
            services = services.filter(category_services_id=category_services)
        
        paginator = CustomPageNumberPagination()
        result_page = paginator.paginate_queryset(services, request)
        serializer = ServiceSerializer(result_page, many=True, context={'request': request})
        return paginator.get_paginated_response(serializer.data)