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 notification.models import Notification
from producers_products.models.producers_products import ProducersProducts, ProductsReview
from producers_products.serializers.producers_products_serializer import ProducersProductsSerializer
from common.pagination.custom_pagination import CustomPageNumberPagination
from producers_products.serializers.product_review_serializer import ProductsReviewSerializer


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

            Notification.objects.create(
                notification_type='producer_report',
                producer_report_id=product.id,
                title=f'Product Flagged: {product.name if hasattr(product, "name") else "Product"} (ID: {product.id})',
                message=message,
                status='unread'
            )
        
        return Response({
            "success": "Product flagged and review created successfully",
            "product_id": product.id,
            "is_flag": product.is_flag,
            "is_active": product.is_active,
            "review_id": flagged_review.id,
            "message": flagged_review.message
        }, status=status.HTTP_200_OK)


class ProducersProductUnflagAPIView(APIView):
    permission_classes = [IsAuthenticated]
    
    @swagger_auto_schema(
        operation_description="Unflag product and set active",
    )
    def post(self, request, pk):
        product = get_object_or_404(ProducersProducts, pk=pk)
        
        if request.user.role != 'admin' and product.created_by != request.user:
            return Response(
                {"error": "You don't have permission to unflag this product"}, 
                status=status.HTTP_403_FORBIDDEN
            )
        
        product.is_flag = False
        product.is_active = True
        product.save(update_fields=['is_flag', 'is_active'])
        
        return Response({
            "success": "Product unflagged successfully",
            "product_id": product.id,
            "is_flag": product.is_flag,
            "is_active": product.is_active
        }, status=status.HTTP_200_OK)


class ProducersProductFlaggedListAPIView(APIView):
    permission_classes = [IsAuthenticated]
    
    @swagger_auto_schema(
        operation_description="Get paginated list of flagged products with flagged reviews",
        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('brand', openapi.IN_QUERY, description="Filter by brand name", type=openapi.TYPE_STRING),
            openapi.Parameter('sub-category', openapi.IN_QUERY, description="Filter by sub-category ID", type=openapi.TYPE_INTEGER),
            openapi.Parameter('category', openapi.IN_QUERY, description="Filter by main category ID", type=openapi.TYPE_INTEGER),
            openapi.Parameter('product', openapi.IN_QUERY, description="Filter by product type", type=openapi.TYPE_STRING),
            openapi.Parameter('max_price', openapi.IN_QUERY, description="Filter by maximum price", type=openapi.TYPE_NUMBER),
            openapi.Parameter('min_price', openapi.IN_QUERY, description="Filter by minimum price", type=openapi.TYPE_NUMBER),
            openapi.Parameter('include_reviews', openapi.IN_QUERY, description="Include flagged reviews", type=openapi.TYPE_BOOLEAN),
        ]
    )
    def get(self, request):
        products = ProducersProducts.objects.filter(is_flag=True).select_related(
            'sub_category', 'created_by'
        ).prefetch_related(
            'product_color', 'product_image', 'product_size', 'product_variant'
        ).order_by('-created_at')
        
        user = request.user
        if user.role != 'admin':
            products = products.filter(created_by=user)
        
        brand = request.query_params.get('brand')
        max_price = request.query_params.get('max_price')
        min_price = request.query_params.get('min_price')
        sub_category = request.query_params.get('sub-category')
        main_category = request.query_params.get('category')
        product_type = request.query_params.get('product')
        include_reviews = request.query_params.get('include_reviews', 'false').lower() == 'true'
        
        if main_category:
            products = products.select_related('sub_category__category').filter(
                sub_category__category__id=main_category
            )
        if sub_category:
            products = products.filter(sub_category__id__iexact=sub_category)
        if brand:
            products = products.filter(brand__icontains=brand)
        if max_price:
            products = products.filter(price__lte=max_price)
        if min_price:
            products = products.filter(price__gte=min_price)
        if product_type:
            products = products.filter(products_type__iexact=product_type)
        
        paginator = CustomPageNumberPagination()
        result_page = paginator.paginate_queryset(products, request)
        serializer = ProducersProductsSerializer(result_page, many=True, context={'request': request})
        
        response_data = paginator.get_paginated_response(serializer.data)
        
        if include_reviews:
            for product_data in response_data.data['results']:
                product_id = product_data['id']
                flagged_reviews = ProductsReview.objects.filter(
                    product_id=product_id,
                    is_flagged_review=True,
                    is_active=True
                ).select_related('created_by')
                
                reviews_serializer = ProductsReviewSerializer(flagged_reviews, many=True, context={'request': request})
                product_data['flagged_reviews'] = reviews_serializer.data
                product_data['flagged_reviews_count'] = flagged_reviews.count()
        
        return response_data