# views.py - Complete form handling lifecycle
from django.shortcuts import render, redirect
from django.contrib import messages
from .forms import ContactForm

def contact_view(request):
    """Complete form handling example"""
    
    if request.method == 'POST':
        # 1. Form instantiation with POST data
        form = ContactForm(request.POST, request.FILES)
        
        # 2. Form validation
        if form.is_valid():
            # 3. Access cleaned data
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            
            # 4. Process the data
            send_email(name, email, message)
            
            # 5. Success response
            messages.success(request, 'Message sent successfully!')
            return redirect('contact_success')
        else:
            # 6. Handle validation errors
            messages.error(request, 'Please correct the errors below.')
    else:
        # 7. Initial form display (GET request)
        form = ContactForm()
    
    # 8. Render form (both GET and invalid POST)
    return render(request, 'contact.html', {'form': form})

# forms.py - Understanding form states
from django import forms

class UserProfileForm(forms.Form):
    first_name = forms.CharField(max_length=30)
    last_name = forms.CharField(max_length=30)
    email = forms.EmailField()
    bio = forms.CharField(widget=forms.Textarea, required=False)
    
    def __init__(self, *args, **kwargs):
        # Extract custom parameters
        self.user = kwargs.pop('user', None)
        super().__init__(*args, **kwargs)
        
        # Customize form based on user
        if self.user and self.user.is_premium:
            self.fields['bio'].help_text = 'Premium users can write longer bios'
            self.fields['bio'].widget.attrs['maxlength'] = 1000
        else:
            self.fields['bio'].widget.attrs['maxlength'] = 200

# views.py - Form state handling
def profile_edit_view(request):
    user = request.user
    
    if request.method == 'POST':
        form = UserProfileForm(request.POST, user=user)
        if form.is_valid():
            # Update user profile
            user.first_name = form.cleaned_data['first_name']
            user.last_name = form.cleaned_data['last_name']
            user.email = form.cleaned_data['email']
            user.save()
            
            # Update profile
            profile, created = UserProfile.objects.get_or_create(user=user)
            profile.bio = form.cleaned_data['bio']
            profile.save()
            
            return redirect('profile_view')
    else:
        # Pre-populate form with existing data
        initial_data = {
            'first_name': user.first_name,
            'last_name': user.last_name,
            'email': user.email,
            'bio': getattr(user.profile, 'bio', '') if hasattr(user, 'profile') else ''
        }
        form = UserProfileForm(initial=initial_data, user=user)
    
    return render(request, 'profile_edit.html', {'form': form})

# forms.py - Data type conversion examples
from django import forms
from datetime import datetime, date
from decimal import Decimal

class DataConversionForm(forms.Form):
    # String fields
    title = forms.CharField(max_length=100)
    description = forms.CharField(widget=forms.Textarea)
    
    # Numeric fields
    age = forms.IntegerField()
    price = forms.DecimalField(max_digits=10, decimal_places=2)
    rating = forms.FloatField()
    
    # Date/time fields
    birth_date = forms.DateField()
    appointment = forms.DateTimeField()
    
    # Boolean fields
    is_active = forms.BooleanField(required=False)
    
    # Choice fields
    CATEGORY_CHOICES = [
        ('tech', 'Technology'),
        ('health', 'Health'),
        ('education', 'Education'),
    ]
    category = forms.ChoiceField(choices=CATEGORY_CHOICES)
    
    # File fields
    avatar = forms.ImageField(required=False)
    
    def clean_age(self):
        """Custom field validation with type conversion"""
        age = self.cleaned_data['age']
        
        if age < 0:
            raise forms.ValidationError('Age cannot be negative.')
        
        if age > 150:
            raise forms.ValidationError('Please enter a realistic age.')
        
        return age
    
    def clean_price(self):
        """Decimal field validation"""
        price = self.cleaned_data['price']
        
        if price < Decimal('0.01'):
            raise forms.ValidationError('Price must be at least $0.01.')
        
        if price > Decimal('999999.99'):
            raise forms.ValidationError('Price is too high.')
        
        return price
    
    def clean_birth_date(self):
        """Date field validation"""
        birth_date = self.cleaned_data['birth_date']
        
        if birth_date > date.today():
            raise forms.ValidationError('Birth date cannot be in the future.')
        
        # Calculate age
        today = date.today()
        age = today.year - birth_date.year - ((today.month, today.day) < (birth_date.month, birth_date.day))
        
        if age < 13:
            raise forms.ValidationError('You must be at least 13 years old.')
        
        return birth_date

# views.py - Accessing converted data
def process_form_view(request):
    if request.method == 'POST':
        form = DataConversionForm(request.POST, request.FILES)
        if form.is_valid():
            # All data is properly converted to Python types
            title = form.cleaned_data['title']  # str
            age = form.cleaned_data['age']  # int
            price = form.cleaned_data['price']  # Decimal
            birth_date = form.cleaned_data['birth_date']  # date object
            is_active = form.cleaned_data['is_active']  # bool
            
            # Process the typed data
            process_user_data(title, age, price, birth_date, is_active)
            
            return redirect('success')
    else:
        form = DataConversionForm()
    
    return render(request, 'form.html', {'form': form})

# forms.py - Comprehensive validation example
from django import forms
from django.core.exceptions import ValidationError
from django.contrib.auth.models import User

class AdvancedRegistrationForm(forms.Form):
    username = forms.CharField(max_length=30)
    email = forms.EmailField()
    password1 = forms.CharField(widget=forms.PasswordInput)
    password2 = forms.CharField(widget=forms.PasswordInput, label='Confirm Password')
    age = forms.IntegerField()
    terms = forms.BooleanField()
    
    def clean_username(self):
        """Field-level validation for username"""
        username = self.cleaned_data['username']
        
        # Check length
        if len(username) < 3:
            raise ValidationError('Username must be at least 3 characters long.')
        
        # Check characters
        if not username.isalnum():
            raise ValidationError('Username must contain only letters and numbers.')
        
        # Check availability
        if User.objects.filter(username=username).exists():
            raise ValidationError('This username is already taken.')
        
        return username
    
    def clean_email(self):
        """Field-level validation for email"""
        email = self.cleaned_data['email']
        
        # Check if email is already registered
        if User.objects.filter(email=email).exists():
            raise ValidationError('This email address is already registered.')
        
        # Check email domain
        allowed_domains = ['gmail.com', 'yahoo.com', 'company.com']
        domain = email.split('@')[1]
        if domain not in allowed_domains:
            raise ValidationError(f'Email domain {domain} is not allowed.')
        
        return email
    
    def clean_password1(self):
        """Field-level validation for password"""
        password = self.cleaned_data['password1']
        
        # Length check
        if len(password) < 8:
            raise ValidationError('Password must be at least 8 characters long.')
        
        # Complexity check
        if password.isdigit():
            raise ValidationError('Password cannot be entirely numeric.')
        
        if password.lower() in ['password', '12345678', 'qwerty']:
            raise ValidationError('Password is too common.')
        
        return password
    
    def clean_age(self):
        """Field-level validation for age"""
        age = self.cleaned_data['age']
        
        if age < 13:
            raise ValidationError('You must be at least 13 years old to register.')
        
        if age > 120:
            raise ValidationError('Please enter a valid age.')
        
        return age
    
    def clean(self):
        """Form-level validation"""
        cleaned_data = super().clean()
        password1 = cleaned_data.get('password1')
        password2 = cleaned_data.get('password2')
        username = cleaned_data.get('username')
        
        # Password confirmation
        if password1 and password2:
            if password1 != password2:
                raise ValidationError('Passwords do not match.')
        
        # Username-password similarity check
        if username and password1:
            if username.lower() in password1.lower():
                raise ValidationError('Password cannot contain the username.')
        
        return cleaned_data

# forms.py - Custom form rendering
from django import forms

class CustomStyledForm(forms.Form):
    name = forms.CharField(
        max_length=100,
        widget=forms.TextInput(attrs={
            'class': 'form-control',
            'placeholder': 'Enter your name',
            'data-validation': 'required'
        })
    )
    
    email = forms.EmailField(
        widget=forms.EmailInput(attrs={
            'class': 'form-control',
            'placeholder': 'Enter your email'
        })
    )
    
    message = forms.CharField(
        widget=forms.Textarea(attrs={
            'class': 'form-control',
            'rows': 5,
            'placeholder': 'Enter your message'
        })
    )
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Add CSS classes to all fields
        for field_name, field in self.fields.items():
            field.widget.attrs.update({'class': 'form-control'})
            
            # Add required attribute for required fields
            if field.required:
                field.widget.attrs.update({'required': True})

# Custom widget example
class DatePickerWidget(forms.DateInput):
    """Custom date picker widget"""
    
    def __init__(self, attrs=None):
        default_attrs = {
            'class': 'form-control datepicker',
            'data-provide': 'datepicker',
            'data-date-format': 'yyyy-mm-dd'
        }
        if attrs:
            default_attrs.update(attrs)
        super().__init__(attrs=default_attrs, format='%Y-%m-%d')

class EventForm(forms.Form):
    title = forms.CharField(max_length=200)
    date = forms.DateField(widget=DatePickerWidget())
    description = forms.CharField(widget=forms.Textarea)

<!-- templates/forms/custom_form.html -->
<form method="post" class="needs-validation" novalidate>
    {% csrf_token %}
    
    <!-- Manual field rendering -->
    <div class="mb-3">
        <label for="{{ form.name.id_for_label }}" class="form-label">
            {{ form.name.label }}
            {% if form.name.field.required %}
                <span class="text-danger">*</span>
            {% endif %}
        </label>
        {{ form.name }}
        {% if form.name.help_text %}
            <div class="form-text">{{ form.name.help_text }}</div>
        {% endif %}
        {% if form.name.errors %}
            <div class="invalid-feedback d-block">
                {{ form.name.errors.0 }}
            </div>
        {% endif %}
    </div>
    
    <!-- Loop through all fields -->
    {% for field in form %}
        <div class="mb-3">
            <label for="{{ field.id_for_label }}" class="form-label">
                {{ field.label }}
                {% if field.field.required %}
                    <span class="text-danger">*</span>
                {% endif %}
            </label>
            
            {{ field }}
            
            {% if field.help_text %}
                <div class="form-text">{{ field.help_text }}</div>
            {% endif %}
            
            {% if field.errors %}
                <div class="invalid-feedback d-block">
                    {% for error in field.errors %}
                        {{ error }}
                    {% endfor %}
                </div>
            {% endif %}
        </div>
    {% endfor %}
    
    <!-- Non-field errors -->
    {% if form.non_field_errors %}
        <div class="alert alert-danger">
            {% for error in form.non_field_errors %}
                {{ error }}
            {% endfor %}
        </div>
    {% endif %}
    
    <button type="submit" class="btn btn-primary">Submit</button>
</form>

# forms.py - Advanced error handling
from django import forms
from django.core.exceptions import ValidationError

class RobustForm(forms.Form):
    username = forms.CharField(max_length=30)
    email = forms.EmailField()
    password = forms.CharField(widget=forms.PasswordInput)
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Store original errors for comparison
        self._original_errors = {}
    
    def add_error(self, field, error):
        """Override to customize error handling"""
        super().add_error(field, error)
        
        # Log errors for debugging
        import logging
        logger = logging.getLogger(__name__)
        logger.warning(f'Form validation error in field {field}: {error}')
    
    def clean_username(self):
        username = self.cleaned_data['username']
        
        try:
            # Validate username
            if len(username) < 3:
                raise ValidationError('Username too short.')
            
            # Check availability
            from django.contrib.auth.models import User
            if User.objects.filter(username=username).exists():
                raise ValidationError('Username already exists.')
            
        except ValidationError as e:
            # Custom error handling
            self.add_error('username', e)
            raise
        
        return username
    
    def full_clean(self):
        """Override to add custom validation logic"""
        try:
            super().full_clean()
        except ValidationError:
            # Handle form-level validation errors
            pass
        
        # Add custom validation
        self._validate_business_rules()
    
    def _validate_business_rules(self):
        """Custom business rule validation"""
        if self.cleaned_data.get('username') and self.cleaned_data.get('email'):
            username = self.cleaned_data['username']
            email = self.cleaned_data['email']
            
            # Business rule: username cannot be part of email
            if username in email:
                self.add_error(None, 'Username cannot be part of email address.')

# views.py - Error handling in views
from django.shortcuts import render, redirect
from django.contrib import messages
from django.http import JsonResponse

def form_view(request):
    if request.method == 'POST':
        form = RobustForm(request.POST)
        
        if form.is_valid():
            # Process valid form
            process_form_data(form.cleaned_data)
            
            # Success response
            if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
                return JsonResponse({'success': True, 'message': 'Form submitted successfully!'})
            else:
                messages.success(request, 'Form submitted successfully!')
                return redirect('success_page')
        else:
            # Handle form errors
            if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
                # AJAX error response
                return JsonResponse({
                    'success': False,
                    'errors': form.errors,
                    'non_field_errors': form.non_field_errors()
                })
            else:
                # Regular form error handling
                messages.error(request, 'Please correct the errors below.')
    else:
        form = RobustForm()
    
    return render(request, 'form.html', {'form': form})

# views.py - Security-focused form handling
from django.views.decorators.csrf import csrf_protect
from django.views.decorators.cache import never_cache
from django.utils.decorators import method_decorator
from django.views.generic import FormView

@method_decorator([csrf_protect, never_cache], name='dispatch')
class SecureFormView(FormView):
    template_name = 'secure_form.html'
    form_class = ContactForm
    success_url = '/success/'
    
    def dispatch(self, request, *args, **kwargs):
        # Add security headers
        response = super().dispatch(request, *args, **kwargs)
        response['X-Content-Type-Options'] = 'nosniff'
        response['X-Frame-Options'] = 'DENY'
        response['X-XSS-Protection'] = '1; mode=block'
        return response
    
    def form_valid(self, form):
        # Additional security checks
        if self.request.user.is_authenticated:
            # Rate limiting for authenticated users
            if self.is_rate_limited():
                messages.error(self.request, 'Too many submissions. Please try again later.')
                return self.form_invalid(form)
        
        # Process form securely
        self.process_secure_form(form)
        
        return super().form_valid(form)
    
    def is_rate_limited(self):
        """Check if user has exceeded submission rate limit"""
        from django.core.cache import cache
        
        user_id = self.request.user.id
        cache_key = f'form_submissions_{user_id}'
        
        submissions = cache.get(cache_key, 0)
        if submissions >= 5:  # 5 submissions per hour
            return True
        
        cache.set(cache_key, submissions + 1, 3600)  # 1 hour
        return False
    
    def process_secure_form(self, form):
        """Process form data with security considerations"""
        # Sanitize input data
        cleaned_data = {}
        for field, value in form.cleaned_data.items():
            if isinstance(value, str):
                # Remove potentially dangerous content
                import bleach
                cleaned_data[field] = bleach.clean(value, strip=True)
            else:
                cleaned_data[field] = value
        
        # Process the sanitized data
        save_form_data(cleaned_data)