# -*- coding: utf-8 -*-
"""
Adtlas Authentication Forms

Enhanced authentication forms for the Adtlas DAI Management System.
Includes login, registration, password reset, and profile management forms.

Features:
    - Enhanced login form with remember me functionality
    - User registration with profile creation
    - Password reset with secure token system
    - Profile management forms
    - Form validation and security measures

Author: Adtlas Development Team
Version: 2.0.0
Last Updated: 2025-07-09
"""

from django import forms
from django.contrib.auth import authenticate
from django.contrib.auth.forms import UserCreationForm, PasswordResetForm
from django.contrib.auth.password_validation import validate_password
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
from django.utils import timezone
from datetime import timedelta
import re

from apps.accounts.models import User, Profile, PasswordResetToken


class LoginForm(forms.Form):
    """
    Enhanced login form with remember me functionality and security features.
    """
    
    email = forms.EmailField(
        max_length=254,
        widget=forms.EmailInput(attrs={
            'class': 'input100',
            'placeholder': 'Email Address',
            'required': True,
            'autofocus': True,
        }),
        label=_('Email Address'),
        help_text=_('Enter your registered email address')
    )
    
    password = forms.CharField(
        widget=forms.PasswordInput(attrs={
            'class': 'input100',
            'placeholder': 'Password',
            'required': True,
        }),
        label=_('Password'),
        help_text=_('Enter your password')
    )
    
    remember_me = forms.BooleanField(
        required=False,
        initial=False,
        widget=forms.CheckboxInput(attrs={
            'class': 'form-check-input',
            'id': 'remember-me'
        }),
        label=_('Remember me'),
        help_text=_('Keep me logged in for 30 days')
    )
    
    def __init__(self, request=None, *args, **kwargs):
        """
        Initialize the form with request context for authentication.
        """
        self.request = request
        self.user_cache = None
        super().__init__(*args, **kwargs)
    
    def clean(self):
        """
        Validate login credentials and check account status.
        """
        cleaned_data = super().clean()
        email = cleaned_data.get('email')
        password = cleaned_data.get('password')
        
        if email and password:
            # Normalize email
            email = email.lower().strip()
            
            try:
                user = User.objects.get(email=email)
                
                # Check if account is locked
                if user.is_account_locked():
                    raise ValidationError(
                        _('Account is temporarily locked due to multiple failed login attempts. '
                          'Please try again later or contact support.'),
                        code='account_locked'
                    )
                
                # Check if account is active
                if not user.is_active:
                    raise ValidationError(
                        _('Your account has been deactivated. Please contact support.'),
                        code='account_inactive'
                    )
                
                # Check if email is verified
                if not user.is_verified:
                    raise ValidationError(
                        _('Please verify your email address before logging in. '
                          'Check your inbox for the verification link.'),
                        code='email_not_verified'
                    )
                
                # Authenticate user
                self.user_cache = authenticate(
                    self.request,
                    username=email,
                    password=password
                )
                
                if self.user_cache is None:
                    # Increment failed login attempts
                    user.failed_login_attempts += 1
                    
                    # Lock account after 5 failed attempts
                    if user.failed_login_attempts >= 5:
                        user.account_locked_until = timezone.now() + timedelta(minutes=30)
                    
                    user.save(update_fields=['failed_login_attempts', 'account_locked_until'])
                    
                    raise ValidationError(
                        _('Invalid email or password. Please try again.'),
                        code='invalid_credentials'
                    )
                else:
                    # Reset failed login attempts on successful login
                    if user.failed_login_attempts > 0:
                        user.failed_login_attempts = 0
                        user.account_locked_until = None
                        user.save(update_fields=['failed_login_attempts', 'account_locked_until'])
                
            except User.DoesNotExist:
                # Don't reveal whether email exists
                raise ValidationError(
                    _('Invalid email or password. Please try again.'),
                    code='invalid_credentials'
                )
        
        return cleaned_data
    
    def get_user(self):
        """
        Return the authenticated user.
        """
        return self.user_cache


class UserRegistrationForm(UserCreationForm):
    """
    Enhanced user registration form with profile creation.
    """
    
    email = forms.EmailField(
        max_length=254,
        widget=forms.EmailInput(attrs={
            'class': 'input100',
            'placeholder': 'Email Address',
            'required': True,
        }),
        label=_('Email Address'),
        help_text=_('Enter a valid email address')
    )
    
    first_name = forms.CharField(
        max_length=150,
        widget=forms.TextInput(attrs={
            'class': 'input100',
            'placeholder': 'First Name',
            'required': True,
        }),
        label=_('First Name'),
        help_text=_('Enter your first name')
    )
    
    last_name = forms.CharField(
        max_length=150,
        widget=forms.TextInput(attrs={
            'class': 'input100',
            'placeholder': 'Last Name',
            'required': True,
        }),
        label=_('Last Name'),
        help_text=_('Enter your last name')
    )
    
    password1 = forms.CharField(
        widget=forms.PasswordInput(attrs={
            'class': 'input100',
            'placeholder': 'Password',
            'required': True,
        }),
        label=_('Password'),
        help_text=_('Enter a strong password')
    )
    
    password2 = forms.CharField(
        widget=forms.PasswordInput(attrs={
            'class': 'input100',
            'placeholder': 'Confirm Password',
            'required': True,
        }),
        label=_('Confirm Password'),
        help_text=_('Re-enter your password')
    )
    
    phone_number = forms.CharField(
        max_length=17,
        required=False,
        widget=forms.TextInput(attrs={
            'class': 'input100',
            'placeholder': 'Phone Number (Optional)',
        }),
        label=_('Phone Number'),
        help_text=_('Enter your phone number (optional)')
    )
    
    job_title = forms.CharField(
        max_length=100,
        required=False,
        widget=forms.TextInput(attrs={
            'class': 'input100',
            'placeholder': 'Job Title (Optional)',
        }),
        label=_('Job Title'),
        help_text=_('Enter your job title (optional)')
    )
    
    company = forms.CharField(
        max_length=100,
        required=False,
        widget=forms.TextInput(attrs={
            'class': 'input100',
            'placeholder': 'Company (Optional)',
        }),
        label=_('Company'),
        help_text=_('Enter your company name (optional)')
    )
    
    terms_accepted = forms.BooleanField(
        required=True,
        widget=forms.CheckboxInput(attrs={
            'class': 'form-check-input',
        }),
        label=_('I agree to the Terms of Service and Privacy Policy'),
        error_messages={
            'required': _('You must accept the terms and conditions to register.')
        }
    )
    
    class Meta:
        model = User
        fields = ('email', 'first_name', 'last_name', 'password1', 'password2')
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Remove username field since we use email
        if 'username' in self.fields:
            del self.fields['username']
    
    def clean_email(self):
        """
        Validate email uniqueness and format.
        """
        email = self.cleaned_data.get('email')
        if email:
            email = email.lower().strip()
            
            # Check if email already exists
            if User.objects.filter(email=email).exists():
                raise ValidationError(
                    _('An account with this email address already exists.'),
                    code='email_exists'
                )
            
            # Additional email validation
            if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
                raise ValidationError(
                    _('Please enter a valid email address.'),
                    code='invalid_email'
                )
        
        return email
    
    def clean_phone_number(self):
        """
        Validate phone number format if provided.
        """
        phone = self.cleaned_data.get('phone_number')
        if phone:
            # Remove all non-digit characters
            phone = re.sub(r'[^\d+]', '', phone)
            
            # Basic phone number validation
            if not re.match(r'^\+?1?\d{9,15}$', phone):
                raise ValidationError(
                    _('Please enter a valid phone number.'),
                    code='invalid_phone'
                )
        
        return phone
    
    def save(self, commit=True):
        """
        Save user and create associated profile.
        """
        user = super().save(commit=False)
        user.email = self.cleaned_data['email'].lower().strip()
        user.username = user.email  # Use email as username
        user.is_verified = False  # Will be verified via email
        
        if commit:
            user.save()
            
            # Create user profile
            Profile.objects.create(
                user=user,
                phone_number=self.cleaned_data.get('phone_number', ''),
                job_title=self.cleaned_data.get('job_title', ''),
                company=self.cleaned_data.get('company', ''),
            )
            
            # TODO: Send verification email
            
        return user


class PasswordResetRequestForm(forms.Form):
    """
    Form for requesting password reset.
    """
    
    email = forms.EmailField(
        max_length=254,
        widget=forms.EmailInput(attrs={
            'class': 'input100',
            'placeholder': 'Email Address',
            'required': True,
            'autofocus': True,
        }),
        label=_('Email Address'),
        help_text=_('Enter your registered email address')
    )
    
    def clean_email(self):
        """
        Validate email exists and is active.
        """
        email = self.cleaned_data.get('email')
        if email:
            email = email.lower().strip()
            
            try:
                user = User.objects.get(email=email, is_active=True)
                self.user = user
            except User.DoesNotExist:
                # Don't reveal whether email exists
                pass
        
        return email
    
    def save(self):
        """
        Create password reset token and send email.
        """
        if hasattr(self, 'user'):
            # Create reset token
            reset_token = PasswordResetToken.objects.create(
                user=self.user,
                expires_at=timezone.now() + timedelta(hours=1)  # 1 hour expiry
            )
            
            # TODO: Send password reset email
            
            return reset_token
        return None


class PasswordResetConfirmForm(forms.Form):
    """
    Form for confirming password reset with new password.
    """
    
    new_password1 = forms.CharField(
        widget=forms.PasswordInput(attrs={
            'class': 'input100',
            'placeholder': 'New Password',
            'required': True,
        }),
        label=_('New Password'),
        help_text=_('Enter your new password')
    )
    
    new_password2 = forms.CharField(
        widget=forms.PasswordInput(attrs={
            'class': 'input100',
            'placeholder': 'Confirm New Password',
            'required': True,
        }),
        label=_('Confirm New Password'),
        help_text=_('Re-enter your new password')
    )
    
    def __init__(self, user=None, *args, **kwargs):
        self.user = user
        super().__init__(*args, **kwargs)
    
    def clean_new_password1(self):
        """
        Validate new password strength.
        """
        password = self.cleaned_data.get('new_password1')
        if password and self.user:
            try:
                validate_password(password, self.user)
            except ValidationError as e:
                raise ValidationError(e.messages)
        return password
    
    def clean(self):
        """
        Validate password confirmation.
        """
        cleaned_data = super().clean()
        password1 = cleaned_data.get('new_password1')
        password2 = cleaned_data.get('new_password2')
        
        if password1 and password2 and password1 != password2:
            raise ValidationError(
                _('The two password fields did not match.'),
                code='password_mismatch'
            )
        
        return cleaned_data
    
    def save(self):
        """
        Set new password for user.
        """
        if self.user:
            self.user.set_password(self.cleaned_data['new_password1'])
            self.user.password_changed_at = timezone.now()
            self.user.save()
            return self.user
        return None


class ProfileForm(forms.ModelForm):
    """
    Form for editing user profile information.
    """
    
    class Meta:
        model = Profile
        fields = [
            'phone_number', 'bio', 'job_title', 'company', 'website',
            'address_line1', 'address_line2', 'city', 'state', 'postal_code',
            'country', 'timezone', 'language', 'theme', 'notifications_enabled',
            'email_notifications', 'sms_notifications'
        ]
        widgets = {
            'phone_number': forms.TextInput(attrs={'class': 'form-control'}),
            'bio': forms.Textarea(attrs={'class': 'form-control', 'rows': 3}),
            'job_title': forms.TextInput(attrs={'class': 'form-control'}),
            'company': forms.TextInput(attrs={'class': 'form-control'}),
            'website': forms.URLInput(attrs={'class': 'form-control'}),
            'address_line1': forms.TextInput(attrs={'class': 'form-control'}),
            'address_line2': forms.TextInput(attrs={'class': 'form-control'}),
            'city': forms.TextInput(attrs={'class': 'form-control'}),
            'state': forms.TextInput(attrs={'class': 'form-control'}),
            'postal_code': forms.TextInput(attrs={'class': 'form-control'}),
            'country': forms.TextInput(attrs={'class': 'form-control'}),
            'timezone': forms.Select(attrs={'class': 'form-control'}),
            'language': forms.Select(attrs={'class': 'form-control'}),
            'theme': forms.Select(attrs={'class': 'form-control'}),
            'notifications_enabled': forms.CheckboxInput(attrs={'class': 'form-check-input'}),
            'email_notifications': forms.CheckboxInput(attrs={'class': 'form-check-input'}),
            'sms_notifications': forms.CheckboxInput(attrs={'class': 'form-check-input'}),
        }
    
    first_name = forms.CharField(
        max_length=150,
        widget=forms.TextInput(attrs={'class': 'form-control'}),
        label=_('First Name')
    )
    
    last_name = forms.CharField(
        max_length=150,
        widget=forms.TextInput(attrs={'class': 'form-control'}),
        label=_('Last Name')
    )
    
    def __init__(self, *args, **kwargs):
        self.user = kwargs.pop('user', None)
        super().__init__(*args, **kwargs)
        
        if self.user:
            self.fields['first_name'].initial = self.user.first_name
            self.fields['last_name'].initial = self.user.last_name
    
    def save(self, commit=True):
        """
        Save profile and update user information.
        """
        profile = super().save(commit=False)
        
        if self.user:
            # Update user basic info
            self.user.first_name = self.cleaned_data.get('first_name', '')
            self.user.last_name = self.cleaned_data.get('last_name', '')
            
            if commit:
                self.user.save()
                profile.save()
        
        return profile