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 django.db.models import Q
from django.contrib.auth import get_user_model

User = get_user_model()

from posts.models import Post
from posts.serializers import PostSerializer
from categories.models import Category
from categories.serializers import CategorySerializer
from users.serializers import UserSerializer

from .models import SearchHistory
from .serializers import SearchHistorySerializer

@api_view(['GET'])
@permission_classes([IsAuthenticated])
def global_search(request):
    """
    Global search endpoint that searches across posts, categories, and users.
    """
    query = request.query_params.get('q', '').strip()
    search_type = request.query_params.get('type', 'all')
    limit = int(request.query_params.get('limit', 10))
    save_history = request.query_params.get('save', 'false').lower() == 'true'

    if not query:
        return Response({
            'posts': [],
            'categories': [],
            'users': []
        })

    # Save to history if requested (usually from explicit search action)
    if save_history and len(query) >= 2:
        # Avoid duplicate recent searches
        last_search = SearchHistory.objects.filter(user=request.user).first()
        if not last_search or last_search.query != query:
            SearchHistory.objects.create(user=request.user, query=query)
            # Keep only last 20 searches
            history_ids = SearchHistory.objects.filter(user=request.user).values_list('id', flat=True)[20:]
            if history_ids:
                SearchHistory.objects.filter(id__in=history_ids).delete()

    results = {}

    # Get blocked users to exclude
    from users.models import BlockedUser
    blocked_ids = BlockedUser.objects.filter(blocker=request.user).values_list('blocked_id', flat=True)
    blocked_by_ids = BlockedUser.objects.filter(blocked=request.user).values_list('blocker_id', flat=True)

    # Search Posts
    if search_type in ['all', 'posts']:
        from posts.views import get_visible_posts

        posts = get_visible_posts(request.user).filter(
            Q(content__icontains=query) |
            Q(created_by__username__icontains=query) |
            Q(created_by__first_name__icontains=query) |
            Q(created_by__last_name__icontains=query) |
            Q(category__title__icontains=query)
        ).select_related('created_by', 'category').distinct()[:limit]

        results['posts'] = PostSerializer(posts, many=True, context={'request': request}).data

    # Search Categories
    if search_type in ['all', 'categories']:
        categories = Category.objects.filter(
            Q(title__icontains=query) |
            Q(description__icontains=query)
        )[:limit]

        results['categories'] = CategorySerializer(categories, many=True).data

    # Search Users
    if search_type in ['all', 'users']:
        from django.db.models import Value
        from django.db.models.functions import Concat

        users = User.objects.annotate(
            full_name=Concat('first_name', Value(' '), 'last_name')
        ).filter(
            Q(username__icontains=query) |
            Q(first_name__icontains=query) |
            Q(last_name__icontains=query) |
            Q(email__icontains=query) |
            Q(full_name__icontains=query)
        ).exclude(
            id=request.user.id
        ).exclude(
            id__in=blocked_ids
        ).exclude(
            id__in=blocked_by_ids
        )[:limit]

        results['users'] = UserSerializer(users, many=True).data

    return Response(results)


@api_view(['GET'])
@permission_classes([IsAuthenticated])
def list_search_history(request):
    """List recent searches for the current user"""
    history = SearchHistory.objects.filter(user=request.user)[:10]
    serializer = SearchHistorySerializer(history, many=True)
    return Response(serializer.data)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def add_to_history(request):
    """Explicitly add a query to search history"""
    query = request.data.get('query', '').strip()
    if not query:
        return Response({'error': 'Query is required'}, status=status.HTTP_400_BAD_REQUEST)

    # Avoid duplicate recent searches
    last_search = SearchHistory.objects.filter(user=request.user).first()
    if not last_search or last_search.query != query:
        SearchHistory.objects.create(user=request.user, query=query)
        # Keep only last 20
        history_ids = SearchHistory.objects.filter(user=request.user).values_list('id', flat=True)[20:]
        if history_ids:
            SearchHistory.objects.filter(id__in=history_ids).delete()

    return Response({'message': 'Added to history'}, status=status.HTTP_201_CREATED)


@api_view(['DELETE'])
@permission_classes([IsAuthenticated])
def delete_history_item(request, history_id):
    """Delete a specific search history item"""
    try:
        item = SearchHistory.objects.get(id=history_id, user=request.user)
        item.delete()
        return Response({'message': 'Deleted successfully'}, status=status.HTTP_200_OK)
    except SearchHistory.DoesNotExist:
        return Response({'error': 'Not found'}, status=status.HTTP_404_NOT_FOUND)


@api_view(['DELETE'])
@permission_classes([IsAuthenticated])
def clear_search_history(request):
    """Clear all search history for the current user"""
    SearchHistory.objects.filter(user=request.user).delete()
    return Response({'message': 'History cleared successfully'}, status=status.HTTP_200_OK)