"""Forms for Notifications App

This module contains Django forms for notification management,
including forms for creating and editing notification channels.
"""

from django import forms
import json

# Models will be imported lazily to avoid circular import issues


class NotificationChannelForm(forms.ModelForm):
    """Form for creating and editing notification channels"""
    
    configuration = forms.CharField(
        widget=forms.Textarea(attrs={
            'rows': 4,
            'placeholder': 'Enter JSON configuration (e.g., {"bot_token": "your_token"})'
        }),
        help_text='Channel-specific configuration in JSON format',
        required=False
    )
    
    class Meta:
        model = None  # Will be set dynamically
        fields = ['name', 'channel_type', 'is_active', 'configuration', 'rate_limit', 'retry_attempts', 'timeout_seconds']
        widgets = {
            'name': forms.TextInput(attrs={
                'class': 'form-control',
                'placeholder': 'Enter channel name'
            }),
            'channel_type': forms.Select(attrs={
                'class': 'form-select'
            }),
            'is_active': forms.CheckboxInput(attrs={
                'class': 'form-check-input'
            }),
            'rate_limit': forms.NumberInput(attrs={
                'class': 'form-control',
                'min': 1,
                'max': 1000,
                'value': 30
            }),
            'retry_attempts': forms.NumberInput(attrs={
                'class': 'form-control',
                'min': 0,
                'max': 10,
                'value': 3
            }),
            'timeout_seconds': forms.NumberInput(attrs={
                'class': 'form-control',
                'min': 5,
                'max': 300,
                'value': 30
            }),
        }
    
    def __init__(self, *args, **kwargs):
        # Import model dynamically to avoid circular imports
        from .models import NotificationChannel
        self._meta.model = NotificationChannel
        super().__init__(*args, **kwargs)
        
        # Add Bootstrap classes to configuration field
        self.fields['configuration'].widget.attrs.update({
            'class': 'form-control font-monospace'
        })
        
        # Set initial configuration based on channel type if creating new
        if not self.instance.pk:
            self.fields['configuration'].initial = '{}'
    
    def clean_configuration(self):
        """Validate that configuration is valid JSON"""
        configuration = self.cleaned_data.get('configuration', '')
        if not configuration.strip():
            return {}
        
        try:
            parsed_config = json.loads(configuration)
            if not isinstance(parsed_config, dict):
                raise forms.ValidationError('Configuration must be a JSON object (dictionary)')
            return parsed_config
        except json.JSONDecodeError as e:
            raise forms.ValidationError(f'Invalid JSON format: {str(e)}')
    
    def clean(self):
        """Additional form validation"""
        cleaned_data = super().clean()
        channel_type = cleaned_data.get('channel_type')
        configuration = cleaned_data.get('configuration', {})
        
        # Validate required configuration fields based on channel type
        if channel_type == 'telegram':
            if not configuration.get('bot_token'):
                self.add_error('configuration', 'Telegram channels require a "bot_token" in configuration')
            if not configuration.get('chat_id'):
                self.add_error('configuration', 'Telegram channels require a "chat_id" in configuration')
        
        elif channel_type == 'email':
            if not configuration.get('smtp_host'):
                self.add_error('configuration', 'Email channels require "smtp_host" in configuration')
            if not configuration.get('username'):
                self.add_error('configuration', 'Email channels require "username" in configuration')
            if not configuration.get('to_email'):
                self.add_error('configuration', 'Email channels require "to_email" in configuration')
        
        elif channel_type == 'webhook':
            if not configuration.get('url'):
                self.add_error('configuration', 'Webhook channels require a "url" in configuration')
        
        elif channel_type == 'slack':
            if not configuration.get('webhook_url'):
                self.add_error('configuration', 'Slack channels require a "webhook_url" in configuration')
        
        elif channel_type == 'discord':
            if not configuration.get('webhook_url'):
                self.add_error('configuration', 'Discord channels require a "webhook_url" in configuration')
        
        elif channel_type == 'sms':
            if not configuration.get('api_key'):
                self.add_error('configuration', 'SMS channels require an "api_key" in configuration')
            if not configuration.get('phone_number'):
                self.add_error('configuration', 'SMS channels require a "phone_number" in configuration')
        
        return cleaned_data


class NotificationTemplateForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        # Import model dynamically to avoid circular imports
        from .models import NotificationTemplate
        self._meta.model = NotificationTemplate
        super().__init__(*args, **kwargs)
    
    class Meta:
        model = None  # Will be set dynamically
        fields = ['name', 'template_type', 'subject_template', 'message_template', 'is_active']
        widgets = {
            'name': forms.TextInput(attrs={'class': 'form-control'}),
            'template_type': forms.Select(attrs={'class': 'form-control'}),
            'subject_template': forms.TextInput(attrs={'class': 'form-control'}),
            'message_template': forms.Textarea(attrs={'class': 'form-control', 'rows': 5}),
            'is_active': forms.CheckboxInput(attrs={'class': 'form-check-input'}),
        }


class NotificationRuleForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        # Import model dynamically to avoid circular imports
        from .models import NotificationRule
        self._meta.model = NotificationRule
        super().__init__(*args, **kwargs)
    
    class Meta:
        model = None  # Will be set dynamically
        fields = '__all__'
        widgets = {
            'name': forms.TextInput(attrs={'class': 'form-control'}),
            'description': forms.Textarea(attrs={'class': 'form-control', 'rows': 3}),
            'is_active': forms.CheckboxInput(attrs={'class': 'form-check-input'}),
        }


class NotificationForm(forms.ModelForm):
    """Form for creating individual notifications"""
    
    def __init__(self, *args, **kwargs):
        # Import model dynamically to avoid circular imports
        from .models import Notification
        self._meta.model = Notification
        super().__init__(*args, **kwargs)
    
    class Meta:
        model = None  # Will be set dynamically
        fields = ['channel', 'message', 'priority']
        widgets = {
            'channel': forms.Select(attrs={'class': 'form-control'}),
            'message': forms.Textarea(attrs={'class': 'form-control', 'rows': 4, 'placeholder': 'Enter notification message...'}),
            'priority': forms.Select(attrs={'class': 'form-control'}),
        }