from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.pagination import PageNumberPagination
from images.models import Image
from .serializers import ImageSerializer, ImageCreateSerializer


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def create_image(request):
    """
    Créer une image indépendante (non attachée à un post)
    """
    serializer = ImageCreateSerializer(data=request.data)
    if serializer.is_valid():
        image = Image.objects.create(
            created_by=request.user,
            **serializer.validated_data
        )
        return Response(ImageSerializer(image).data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def add_images_to_post(request, post_id):
    """
    Ajouter plusieurs images à un post existant
    """
    try:
        from posts.models import Post
        post = Post.objects.get(id=post_id, is_active=True)

        # Vérifier que l'utilisateur est le créateur du post
        if post.created_by != request.user:
            return Response({'error': 'Permission denied'}, status=status.HTTP_403_FORBIDDEN)

        # Traiter les images uploadées
        images_data = request.FILES.getlist('images')
        created_images = []

        # Calculer l'ordre de départ
        from posts.models import PostImage
        last_order = PostImage.objects.filter(post=post).order_by('-order').first()
        current_order = (last_order.order + 1) if last_order else 0

        for image_file in images_data:
            image = Image.objects.create(
                image=image_file,
                created_by=request.user
            )
            PostImage.objects.create(post=post, image=image, order=current_order)
            current_order += 1
            created_images.append(image)

        # Retourner les images créées
        serializer = ImageSerializer(created_images, many=True)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

    except Post.DoesNotExist:
        return Response({'error': 'Post not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['DELETE'])
@permission_classes([IsAuthenticated])
def remove_image_from_post(request, image_id):
    """
    Retirer une image spécifique d'un post
    """
    try:
        image = Image.objects.get(id=image_id)

        # Vérifier que l'utilisateur est le créateur de l'image
        if image.created_by != request.user:
            return Response({'error': 'Permission denied'}, status=status.HTTP_403_FORBIDDEN)

        # Retirer l'image de tous les posts où elle est utilisée
        from posts.models import Post
        posts_using_image = Post.objects.filter(images=image)
        for post in posts_using_image:
            if post.created_by == request.user:
                post.images.remove(image)

        # Si l'image n'est utilisée par aucun post, la supprimer
        if not posts_using_image.exists():
            image.delete()

        return Response({'message': 'Image removed successfully'}, status=status.HTTP_200_OK)

    except Image.DoesNotExist:
        return Response({'error': 'Image not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def list_images(request):
    """
    Lister toutes les images de l'utilisateur connecté
    """
    images = Image.objects.filter(created_by=request.user)

    # Pagination
    paginator = PageNumberPagination()
    paginator.page_size = 20
    result_page = paginator.paginate_queryset(images, request)

    serializer = ImageSerializer(result_page, many=True)
    return paginator.get_paginated_response(serializer.data)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def image_detail(request, image_id):
    """
    Voir les détails d'une image
    """
    try:
        image = Image.objects.get(id=image_id)
        serializer = ImageSerializer(image)
        return Response(serializer.data)
    except Image.DoesNotExist:
        return Response({'error': 'Image not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['DELETE'])
@permission_classes([IsAuthenticated])
def delete_image(request, image_id):
    """
    Supprimer complètement une image
    """
    try:
        image = Image.objects.get(id=image_id)

        # Vérifier que l'utilisateur est le créateur de l'image
        if image.created_by != request.user:
            return Response({'error': 'Permission denied'}, status=status.HTTP_403_FORBIDDEN)

        image.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
    except Image.DoesNotExist:
        return Response({'error': 'Image not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def post_images(request, post_id):
    """
    Lister les images d'un post spécifique
    """
    try:
        from posts.models import Post
        post = Post.objects.get(id=post_id, is_active=True)
        images = post.images.all()

        # Pagination
        paginator = PageNumberPagination()
        paginator.page_size = 20
        result_page = paginator.paginate_queryset(images, request)

        serializer = ImageSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)
    except Post.DoesNotExist:
        return Response({'error': 'Post not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def user_images(request, user_id):
    """
    Lister les images uploadées par un utilisateur spécifique
    """
    images = Image.objects.filter(created_by_id=user_id)

    # Pagination
    paginator = PageNumberPagination()
    paginator.page_size = 20
    result_page = paginator.paginate_queryset(images, request)

    serializer = ImageSerializer(result_page, many=True)
    return paginator.get_paginated_response(serializer.data)