from rest_framework import serializers
from .models import ContactForm
import re


class ContactFormSerializer(serializers.ModelSerializer):
    """Serializer for ContactForm model with validation"""
    
    class Meta:
        model = ContactForm
        fields = [
            'id',
            'name',
            'email', 
            'phone',
            'subject',
            'message',
            'status',
            'created_at',
            'updated_at'
        ]
        read_only_fields = ['id', 'status', 'created_at', 'updated_at']
    
    def validate_name(self, value):
        """Validate name field"""
        if not value or len(value.strip()) < 2:
            raise serializers.ValidationError("Name must be at least 2 characters long.")
        
        if len(value) > 255:
            raise serializers.ValidationError("Name cannot exceed 255 characters.")
        
        # Check if name contains only letters, spaces, hyphens, and apostrophes
        if not re.match(r"^[a-zA-Z\s\-'\.]+$", value):
            raise serializers.ValidationError("Name can only contain letters, spaces, hyphens, and apostrophes.")
        
        return value.strip().title()  # Clean and title case
    
    def validate_email(self, value):
        """Validate email field"""
        if not value:
            raise serializers.ValidationError("Email address is required.")
        
        # Additional email validation beyond Django's default
        email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        if not re.match(email_pattern, value):
            raise serializers.ValidationError("Please enter a valid email address.")
        
        return value.lower().strip()
    
    def validate_phone(self, value):
        """Validate phone field (optional)"""
        if value:
            # Remove all non-digit characters for validation
            digits_only = re.sub(r'\D', '', value)
            
            if len(digits_only) < 10:
                raise serializers.ValidationError("Phone number must be at least 10 digits long.")
            
            if len(digits_only) > 15:
                raise serializers.ValidationError("Phone number cannot exceed 15 digits.")
            
            # Check for valid Indian mobile number pattern (optional)
            indian_pattern = r'^(\+91|91|0)?[6-9]\d{9}$'
            if re.match(indian_pattern, digits_only):
                return value.strip()
            
            # Allow international format
            international_pattern = r'^\+?[1-9]\d{9,14}$'
            if re.match(international_pattern, digits_only):
                return value.strip()
            
            raise serializers.ValidationError("Please enter a valid phone number.")
        
        return value
    
    def validate_subject(self, value):
        """Validate subject field"""
        if not value:
            raise serializers.ValidationError("Subject is required.")
        
        valid_subjects = [choice[0] for choice in ContactForm.SUBJECT_CHOICES]
        if value not in valid_subjects:
            raise serializers.ValidationError(f"Subject must be one of: {', '.join(valid_subjects)}")
        
        return value
    
    def validate_message(self, value):
        """Validate message field"""
        if not value or len(value.strip()) < 10:
            raise serializers.ValidationError("Message must be at least 10 characters long.")
        
        if len(value) > 5000:
            raise serializers.ValidationError("Message cannot exceed 5000 characters.")
        
        return value.strip()
    
    def create(self, validated_data):
        """Create a new contact form submission"""
        return ContactForm.objects.create(**validated_data)


class ContactFormListSerializer(serializers.ModelSerializer):
    """Simplified serializer for listing contact forms (admin use)"""
    
    subject_display = serializers.CharField(source='get_subject_display', read_only=True)
    status_display = serializers.CharField(source='get_status_display', read_only=True)
    is_recent = serializers.BooleanField(read_only=True)
    
    class Meta:
        model = ContactForm
        fields = [
            'id',
            'name',
            'email',
            'subject',
            'subject_display',
            'status',
            'status_display',
            'is_recent',
            'created_at',
            'updated_at'
        ]


class ContactFormDetailSerializer(serializers.ModelSerializer):
    """Detailed serializer for individual contact form (admin use)"""
    
    subject_display = serializers.CharField(source='get_subject_display', read_only=True)
    status_display = serializers.CharField(source='get_status_display', read_only=True)
    is_recent = serializers.BooleanField(read_only=True)
    status_color = serializers.CharField(source='get_status_color', read_only=True)
    
    class Meta:
        model = ContactForm
        fields = [
            'id',
            'name',
            'email',
            'phone',
            'subject',
            'subject_display',
            'message',
            'status',
            'status_display',
            'status_color',
            'admin_notes',
            'responded_at',
            'responded_by',
            'is_recent',
            'created_at',
            'updated_at'
        ]


class ContactFormStatusUpdateSerializer(serializers.ModelSerializer):
    """Serializer for updating contact form status (admin use)"""
    
    class Meta:
        model = ContactForm
        fields = ['status', 'admin_notes', 'responded_by']
    
    def validate_status(self, value):
        """Validate status field"""
        valid_statuses = [choice[0] for choice in ContactForm.STATUS_CHOICES]
        if value not in valid_statuses:
            raise serializers.ValidationError(f"Status must be one of: {', '.join(valid_statuses)}")
        
        return value