from django.utils import timezone
from django.db.models import Count, Q, Avg
from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.permissions import AllowAny, IsAuthenticated

from accounts.models import VendorProfile
from .models import VendorAIConfig, VendorFAQ, AIChat, AIChatMessage
from .serializers import (
    VendorAIConfigSerializer, VendorFAQSerializer,
    AIChatSerializer, AIChatListSerializer, AIChatMessageSerializer
)
from .ai_service import generate_response


# ============== PERMISSION HELPERS ==============

def is_upgraded_vendor(request):
    """Check if request user is an upgraded vendor."""
    if not request.user.is_authenticated:
        return False
    if request.user.user_type != 'vendor':
        return False
    try:
        return request.user.vendor_profile.is_upgraded
    except Exception:
        return False


def get_vendor_config(request):
    """Get or create AI config for the current vendor."""
    vendor_profile = request.user.vendor_profile
    config, _ = VendorAIConfig.objects.get_or_create(vendor=vendor_profile)
    return config


# ============== VENDOR ENDPOINTS ==============

class VendorAIConfigView(APIView):
    """GET/PUT vendor AI configuration."""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required to access AI assistant'
            }, status=status.HTTP_403_FORBIDDEN)

        config = get_vendor_config(request)
        serializer = VendorAIConfigSerializer(config)
        return Response({
            'success': True,
            'data': serializer.data
        }, status=status.HTTP_200_OK)

    def put(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required to access AI assistant'
            }, status=status.HTTP_403_FORBIDDEN)

        config = get_vendor_config(request)
        serializer = VendorAIConfigSerializer(config, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response({
                'success': True,
                'message': 'AI configuration updated',
                'data': serializer.data
            }, status=status.HTTP_200_OK)
        return Response({
            'success': False,
            'message': serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)


class VendorFAQListCreateView(APIView):
    """GET list / POST create FAQs for vendor's AI config."""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        config = get_vendor_config(request)
        faqs = config.faqs.all()
        serializer = VendorFAQSerializer(faqs, many=True)
        return Response({
            'success': True,
            'data': serializer.data
        }, status=status.HTTP_200_OK)

    def post(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        config = get_vendor_config(request)
        serializer = VendorFAQSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save(ai_config=config)
            return Response({
                'success': True,
                'message': 'FAQ created',
                'data': serializer.data
            }, status=status.HTTP_201_CREATED)
        return Response({
            'success': False,
            'message': serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)


class VendorFAQDetailView(APIView):
    """PUT/DELETE a specific FAQ."""
    permission_classes = [IsAuthenticated]

    def put(self, request, faq_id):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        try:
            config = get_vendor_config(request)
            faq = config.faqs.get(id=faq_id)
        except VendorFAQ.DoesNotExist:
            return Response({
                'success': False,
                'message': 'FAQ not found'
            }, status=status.HTTP_404_NOT_FOUND)

        serializer = VendorFAQSerializer(faq, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response({
                'success': True,
                'message': 'FAQ updated',
                'data': serializer.data
            }, status=status.HTTP_200_OK)
        return Response({
            'success': False,
            'message': serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, faq_id):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        try:
            config = get_vendor_config(request)
            faq = config.faqs.get(id=faq_id)
        except VendorFAQ.DoesNotExist:
            return Response({
                'success': False,
                'message': 'FAQ not found'
            }, status=status.HTTP_404_NOT_FOUND)

        faq.delete()
        return Response({
            'success': True,
            'message': 'FAQ deleted'
        }, status=status.HTTP_200_OK)


class VendorAIChatListView(APIView):
    """GET paginated list of AI chats for vendor."""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        vendor_profile = request.user.vendor_profile
        page = int(request.query_params.get('page', 1))
        limit = int(request.query_params.get('limit', 20))

        chats = AIChat.objects.filter(vendor=vendor_profile)
        total = chats.count()
        chats = chats[(page - 1) * limit:page * limit]

        serializer = AIChatListSerializer(chats, many=True)
        return Response({
            'success': True,
            'data': serializer.data,
            'pagination': {
                'total': total,
                'page': page,
                'limit': limit,
                'pages': (total + limit - 1) // limit if total > 0 else 0
            }
        }, status=status.HTTP_200_OK)


class VendorAIAnalyticsView(APIView):
    """GET aggregated AI chat analytics for vendor."""
    permission_classes = [IsAuthenticated]

    def get(self, request):
        if not is_upgraded_vendor(request):
            return Response({
                'success': False,
                'message': 'Upgrade required'
            }, status=status.HTTP_403_FORBIDDEN)

        vendor_profile = request.user.vendor_profile
        period = request.query_params.get('period', '30')
        try:
            days = int(period)
        except ValueError:
            days = 30

        since = timezone.now() - timezone.timedelta(days=days)
        chats = AIChat.objects.filter(vendor=vendor_profile, started_at__gte=since)

        total_chats = chats.count()
        total_messages = AIChatMessage.objects.filter(
            chat__vendor=vendor_profile, chat__started_at__gte=since
        ).exclude(role='system').count()
        handoff_count = chats.filter(was_handed_off=True).count()
        handoff_rate = round((handoff_count / total_chats * 100), 1) if total_chats > 0 else 0

        helpful_messages = AIChatMessage.objects.filter(
            chat__vendor=vendor_profile,
            chat__started_at__gte=since,
            role='assistant',
            was_helpful__isnull=False
        )
        total_rated = helpful_messages.count()
        helpful_count = helpful_messages.filter(was_helpful=True).count()
        helpful_rate = round((helpful_count / total_rated * 100), 1) if total_rated > 0 else 0

        return Response({
            'success': True,
            'data': {
                'total_chats': total_chats,
                'total_messages': total_messages,
                'handoff_count': handoff_count,
                'handoff_rate': handoff_rate,
                'helpful_rate': helpful_rate,
                'total_rated': total_rated,
                'period_days': days
            }
        }, status=status.HTTP_200_OK)


# ============== CUSTOMER ENDPOINTS ==============

class CustomerAIChatStartView(APIView):
    """POST - Start a new AI chat session with a vendor."""
    permission_classes = [AllowAny]

    def post(self, request, vendor_slug):
        try:
            vendor_profile = VendorProfile.objects.select_related('user').get(slug=vendor_slug)
        except VendorProfile.DoesNotExist:
            return Response({
                'success': False,
                'message': 'Vendor not found'
            }, status=status.HTTP_404_NOT_FOUND)

        if not vendor_profile.is_upgraded:
            return Response({
                'success': False,
                'message': 'AI chat not available for this vendor'
            }, status=status.HTTP_404_NOT_FOUND)

        try:
            ai_config = vendor_profile.ai_config
            if not ai_config.is_active:
                return Response({
                    'success': False,
                    'message': 'AI chat is currently disabled for this vendor'
                }, status=status.HTTP_404_NOT_FOUND)
        except VendorAIConfig.DoesNotExist:
            return Response({
                'success': False,
                'message': 'AI chat not configured for this vendor'
            }, status=status.HTTP_404_NOT_FOUND)

        user = request.user if request.user.is_authenticated else None
        chat = AIChat.objects.create(vendor=vendor_profile, user=user)

        # Create welcome message
        welcome = f"Hi! Welcome to {vendor_profile.shop_name}. How can I help you today?"
        AIChatMessage.objects.create(chat=chat, role='assistant', content=welcome)

        return Response({
            'success': True,
            'data': {
                'session_id': str(chat.session_id),
                'welcome_message': welcome,
                'suggested_questions': ai_config.suggested_questions or [],
                'vendor_name': vendor_profile.shop_name
            }
        }, status=status.HTTP_201_CREATED)


class CustomerAIChatMessageView(APIView):
    """POST - Send a message and get AI response."""
    permission_classes = [AllowAny]

    def post(self, request, vendor_slug):
        session_id = request.data.get('session_id')
        message = request.data.get('message', '').strip()

        if not session_id or not message:
            return Response({
                'success': False,
                'message': 'session_id and message are required'
            }, status=status.HTTP_400_BAD_REQUEST)

        try:
            chat = AIChat.objects.get(
                session_id=session_id,
                vendor__slug=vendor_slug,
                is_active=True
            )
        except AIChat.DoesNotExist:
            return Response({
                'success': False,
                'message': 'Chat session not found'
            }, status=status.HTTP_404_NOT_FOUND)

        # Save customer message
        AIChatMessage.objects.create(chat=chat, role='customer', content=message)

        # Generate response from vendor data
        ai_response, suggests_handoff = generate_response(chat, message)

        # Save assistant message
        assistant_msg = AIChatMessage.objects.create(
            chat=chat, role='assistant', content=ai_response
        )

        return Response({
            'success': True,
            'data': {
                'message_id': assistant_msg.id,
                'response': ai_response,
                'suggests_handoff': suggests_handoff
            }
        }, status=status.HTTP_200_OK)


class CustomerAIChatHistoryView(APIView):
    """GET - Retrieve message history for a chat session."""
    permission_classes = [AllowAny]

    def get(self, request, vendor_slug, session_id):
        try:
            chat = AIChat.objects.get(
                session_id=session_id,
                vendor__slug=vendor_slug
            )
        except AIChat.DoesNotExist:
            return Response({
                'success': False,
                'message': 'Chat session not found'
            }, status=status.HTTP_404_NOT_FOUND)

        messages = chat.messages.exclude(role='system')
        serializer = AIChatMessageSerializer(messages, many=True)
        return Response({
            'success': True,
            'data': serializer.data
        }, status=status.HTTP_200_OK)


class CustomerAIChatHandoffView(APIView):
    """POST - Mark a chat as handed off to vendor, return contact info."""
    permission_classes = [AllowAny]

    def post(self, request, vendor_slug, session_id):
        try:
            chat = AIChat.objects.select_related('vendor__user').get(
                session_id=session_id,
                vendor__slug=vendor_slug,
                is_active=True
            )
        except AIChat.DoesNotExist:
            return Response({
                'success': False,
                'message': 'Chat session not found'
            }, status=status.HTTP_404_NOT_FOUND)

        chat.was_handed_off = True
        chat.ended_at = timezone.now()
        chat.save()

        vendor = chat.vendor
        return Response({
            'success': True,
            'message': 'Chat handed off to vendor',
            'data': {
                'whatsapp_number': vendor.whatsapp_number,
                'shop_name': vendor.shop_name,
                'phone_number': vendor.user.phone_number
            }
        }, status=status.HTTP_200_OK)


class AIChatFeedbackView(APIView):
    """POST - Submit thumbs up/down feedback on an AI message."""
    permission_classes = [AllowAny]

    def post(self, request, message_id):
        was_helpful = request.data.get('was_helpful')
        if was_helpful is None:
            return Response({
                'success': False,
                'message': 'was_helpful field is required (true/false)'
            }, status=status.HTTP_400_BAD_REQUEST)

        try:
            message = AIChatMessage.objects.get(id=message_id, role='assistant')
        except AIChatMessage.DoesNotExist:
            return Response({
                'success': False,
                'message': 'Message not found'
            }, status=status.HTTP_404_NOT_FOUND)

        message.was_helpful = bool(was_helpful)
        message.save()

        return Response({
            'success': True,
            'message': 'Feedback recorded'
        }, status=status.HTTP_200_OK)