from rest_framework import generics, status
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework.permissions import AllowAny
from django.utils import timezone
from django.core.mail import send_mail
from django.conf import settings
from .models import ContactForm
from .serializers import (
    ContactFormSerializer, 
    ContactFormListSerializer,
    ContactFormDetailSerializer,
    ContactFormStatusUpdateSerializer
)
import logging

logger = logging.getLogger(__name__)


class ContactFormCreateView(generics.CreateAPIView):
    """
    POST API for creating new contact form submissions
    Endpoint: /api/contact/submit/
    """
    queryset = ContactForm.objects.all()
    serializer_class = ContactFormSerializer
    permission_classes = [AllowAny]  # Allow anyone to submit contact forms
    
    def create(self, request, *args, **kwargs):
        """Handle contact form submission"""
        serializer = self.get_serializer(data=request.data)
        
        if serializer.is_valid():
            # Save the contact form
            contact_form = serializer.save()
            
            # Optional: Send email notification to admin
            try:
                self.send_admin_notification(contact_form)
            except Exception as e:
                logger.error(f"Failed to send admin notification: {str(e)}")
            
            # Return success response
            return Response({
                'success': True,
                'message': 'Your message has been submitted successfully! We will get back to you soon.',
                'data': {
                    'id': contact_form.id,
                    'name': contact_form.name,
                    'subject': contact_form.get_subject_display(),
                    'submitted_at': contact_form.created_at.isoformat(),
                    'reference_number': f"REF{contact_form.id:06d}"
                }
            }, status=status.HTTP_201_CREATED)
        
        # Return validation errors
        return Response({
            'success': False,
            'message': 'Please correct the errors below.',
            'errors': serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)
    
    def send_admin_notification(self, contact_form):
        """Send email notification to admin about new contact form submission"""
        subject = f"New Contact Form Submission - {contact_form.get_subject_display()}"
        
        message = f"""
        New Contact Form Submission Received
        
        Name: {contact_form.name}
        Email: {contact_form.email}
        Phone: {contact_form.phone or 'Not provided'}
        Subject: {contact_form.get_subject_display()}
        
        Message:
        {contact_form.message}
        
        Submitted: {contact_form.created_at.strftime('%Y-%m-%d %H:%M:%S')}
        Reference: REF{contact_form.id:06d}
        
        Please log in to the admin panel to respond to this inquiry.
        """
        
        # Send email if configured
        admin_email = getattr(settings, 'ADMIN_EMAIL', None)
        if admin_email:
            send_mail(
                subject=subject,
                message=message,
                from_email=getattr(settings, 'DEFAULT_FROM_EMAIL', 'noreply@example.com'),
                recipient_list=[admin_email],
                fail_silently=True
            )


class ContactFormListView(generics.ListAPIView):
    """
    GET API for listing contact form submissions (admin use)
    Endpoint: /api/contact/list/
    """
    queryset = ContactForm.objects.all()
    serializer_class = ContactFormListSerializer
    # Note: Add authentication/permission for production use
    
    def get_queryset(self):
        """Filter contact forms based on query parameters"""
        queryset = ContactForm.objects.all()
        
        # Filter by status
        status_filter = self.request.query_params.get('status', None)
        if status_filter:
            queryset = queryset.filter(status=status_filter)
        
        # Filter by subject
        subject_filter = self.request.query_params.get('subject', None)
        if subject_filter:
            queryset = queryset.filter(subject=subject_filter)
        
        # Filter recent submissions (last 7 days)
        recent = self.request.query_params.get('recent', None)
        if recent == 'true':
            from datetime import timedelta
            week_ago = timezone.now() - timedelta(days=7)
            queryset = queryset.filter(created_at__gte=week_ago)
        
        return queryset


class ContactFormDetailView(generics.RetrieveAPIView):
    """
    GET API for individual contact form details (admin use)
    Endpoint: /api/contact/<id>/
    """
    queryset = ContactForm.objects.all()
    serializer_class = ContactFormDetailSerializer
    # Note: Add authentication/permission for production use


class ContactFormUpdateStatusView(generics.UpdateAPIView):
    """
    PATCH API for updating contact form status (admin use)
    Endpoint: /api/contact/<id>/update-status/
    """
    queryset = ContactForm.objects.all()
    serializer_class = ContactFormStatusUpdateSerializer
    # Note: Add authentication/permission for production use
    
    def patch(self, request, *args, **kwargs):
        """Update contact form status with timestamp"""
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=True)
        
        if serializer.is_valid():
            # If marking as resolved, update responded_at timestamp
            if serializer.validated_data.get('status') == 'resolved':
                serializer.validated_data['responded_at'] = timezone.now()
            
            serializer.save()
            
            return Response({
                'success': True,
                'message': 'Status updated successfully.',
                'data': ContactFormDetailSerializer(instance).data
            })
        
        return Response({
            'success': False,
            'message': 'Failed to update status.',
            'errors': serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)


@api_view(['GET'])
def contact_form_stats(request):
    """
    GET API for contact form statistics (admin use)
    Endpoint: /api/contact/stats/
    """
    from django.db.models import Count
    from datetime import timedelta
    
    # Total counts
    total_submissions = ContactForm.objects.count()
    
    # Status breakdown
    status_counts = ContactForm.objects.values('status').annotate(count=Count('status'))
    status_breakdown = {item['status']: item['count'] for item in status_counts}
    
    # Subject breakdown
    subject_counts = ContactForm.objects.values('subject').annotate(count=Count('subject'))
    subject_breakdown = {item['subject']: item['count'] for item in subject_counts}
    
    # Recent submissions (last 30 days)
    thirty_days_ago = timezone.now() - timedelta(days=30)
    recent_submissions = ContactForm.objects.filter(created_at__gte=thirty_days_ago).count()
    
    # Pending submissions
    pending_count = ContactForm.objects.filter(status='pending').count()
    
    return Response({
        'total_submissions': total_submissions,
        'recent_submissions_30_days': recent_submissions,
        'pending_submissions': pending_count,
        'status_breakdown': status_breakdown,
        'subject_breakdown': subject_breakdown,
        'last_updated': timezone.now().isoformat()
    })


@api_view(['POST'])
def test_contact_form(request):
    """
    POST API for testing contact form functionality
    Endpoint: /api/contact/test/
    """
    # Sample test data
    test_data = {
        'name': 'Test User',
        'email': 'test@example.com',
        'phone': '+91 9876543210',
        'subject': 'admission',
        'message': 'This is a test message to verify the contact form API is working properly.'
    }
    
    serializer = ContactFormSerializer(data=test_data)
    if serializer.is_valid():
        contact_form = serializer.save()
        return Response({
            'success': True,
            'message': 'Test contact form created successfully!',
            'test_id': contact_form.id,
            'data': ContactFormSerializer(contact_form).data
        }, status=status.HTTP_201_CREATED)
    
    return Response({
        'success': False,
        'message': 'Test failed',
        'errors': serializer.errors
    }, status=status.HTTP_400_BAD_REQUEST)
