from django import forms
from django.core.exceptions import ValidationError
from django.forms import ModelForm, ModelMultipleChoiceField, inlineformset_factory
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from ckeditor.widgets import CKEditorWidget

from io import BytesIO
from PIL import Image
from django.core.files.uploadedfile import InMemoryUploadedFile

from django import forms
from django.utils.translation import gettext_lazy as _
from django.core.exceptions import ValidationError
from .models import Issue, IssueItem, Blog
from django.utils import timezone
from django.db.models import Q

from django import forms
from django.core.exceptions import ValidationError
from django.utils import timezone
from django.utils.translation import gettext_lazy as _

from django import forms
import os
from django.utils import timezone
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _


from .models import (
    Author,
    Blog,
    BlogCategory,
    Contact,
    Option,
    Poll,
    Subscriber,
    TeamMember,
    Topics,
    Task
)


class BlogForm(forms.ModelForm):
    title = forms.CharField(
        max_length=200,
        widget=forms.TextInput(attrs={
            'class': 'w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500',
            'placeholder': 'Enter blog post title',
        }),
        required=True,
        help_text="The title of your blog post (max 200 characters)"
    )

    content = forms.CharField(
        widget=CKEditorWidget(attrs={
            'class': 'w-full',
            'rows': 10,
        }),
        required=True,
        help_text="The main content of your blog post"
    )

    category = forms.ModelChoiceField(
        queryset=BlogCategory.objects.all(),
        widget=forms.Select(attrs={
            'class': 'w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500',
        }),
        required=True,
        help_text="Select a category for this post"
    )

    topic = forms.ModelChoiceField(
        queryset=Topics.objects.all(),
        widget=forms.Select(attrs={
            'class': 'w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500',
        }),
        required=True,
        help_text="Select a topic for this post"
    )

    authors = ModelMultipleChoiceField(
        queryset=Author.objects.all(),
        widget=forms.SelectMultiple(attrs={
            'class': 'hidden',
        }),
        required=True,
        help_text="Select one or more authors"
    )

    related_topics = ModelMultipleChoiceField(
        queryset=Topics.objects.all(),
        widget=forms.SelectMultiple(attrs={
            'class': 'hidden',
        }),
        required=False,
        help_text="Select related topics (optional)"
    )

    status = forms.ChoiceField(
        choices=Blog.Status,
        widget=forms.Select(attrs={
            'class': 'w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500',
        }),
        required=True,
        help_text="Set the status of this post"
    )

    published_time = forms.DateTimeField(
        widget=forms.DateTimeInput(attrs={
            'class': 'w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-indigo-500 focus:border-indigo-500',
            'type': 'datetime-local',
        }, format='%Y-%m-%dT%H:%M'),
        required=False,
        help_text="Set the publication date and time (leave blank for drafts)"
    )

    meta_image = forms.ImageField(
        widget=forms.FileInput(attrs={
            'class': 'relative cursor-pointer rounded-md font-medium hover:cursor-pointer text-blue-600 focus-within:outline-none',
        }),
        required=False,
        help_text="Upload an image for this blog post (optional)"
    )

    feature_this = forms.BooleanField(
        widget=forms.CheckboxInput(attrs={
            'class': 'h-4 w-4 text-indigo-600 focus:ring-indigo-500 border-gray-300 rounded',
        }),
        required=False,
        initial=False,
        help_text="Feature this blog post on the homepage"
    )

    class Meta:
        model = Blog
        fields = [
            'title', 'content', 'category', 'topic',
            'authors', 'related_topics', 'status', 'published_time', 'feature_this', 'meta_image',
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Set initial values for datetime field
        if self.instance.pk and self.instance.published_time:
            self.initial['published_time'] = self.instance.published_time.strftime('%Y-%m-%dT%H:%M')
        
        # Initialize related_topics queryset excluding the main topic if it exists
        if self.instance.pk and self.instance.topic:
            self.fields['related_topics'].queryset = Topics.objects.exclude(id=self.instance.topic.id)
        elif 'topic' in self.initial:
            self.fields['related_topics'].queryset = Topics.objects.exclude(id=self.initial['topic'])
        
        # Set initial values for related_topics if editing existing blog
        if self.instance.pk:
            self.initial['related_topics'] = [t.pk for t in self.instance.related_topics.all()]
        
        # Add error classes to fields with errors
        for field_name, field in self.fields.items():
            if field_name in self.errors:
                field.widget.attrs['class'] += ' border-red-500'

    def clean_published_time(self):
        status = self.cleaned_data.get('status')
        published_time = self.cleaned_data.get('published_time')

        if status == 'published' and not published_time:
            published_time = timezone.now()
        
        if published_time and published_time > timezone.now() + timezone.timedelta(days=30):
            raise ValidationError("Publication time cannot be more than 30 days in the future.")
        
        return published_time

    def clean(self):
        cleaned_data = super().clean()
        status = cleaned_data.get('status')
        published_time = cleaned_data.get('published_time')

        # Ensure published posts have a published time
        if status == 'published' and not published_time:
            self.cleaned_data['published_time'] = timezone.now()

        # Validate that at least one author is selected
        authors = cleaned_data.get('authors')
        if not authors:
            raise ValidationError({'authors': "At least one author must be selected."})

        return cleaned_data
    
    def clean_feature_this(self):
        feature = self.cleaned_data.get('feature_this')
        if feature:
            # Exclude current instance in case of editing
            qs = Blog.objects.filter(feature_this=True)
            if self.instance.pk:
                qs = qs.exclude(pk=self.instance.pk)
            if qs.count() >= 4:
                raise forms.ValidationError("Only four blog posts can be featured at a time.")
        return feature

    def clean_delete(self):
        if self.instance.pk:
            # Check if the blog can be safely deleted
            # Example: Check for dependencies or references
            if self.instance.is_protected or getattr(self.instance, 'special_flag', False):
                raise ValidationError("This blog post cannot be deleted because it is referenced elsewhere.")
        return True

    def save(self, commit=True):
        instance = super().save(commit=False)
        
        # Set published_time if status is published but time wasn't provided
        if instance.status == 'published' and not instance.published_time:
            instance.published_time = timezone.now()
        
        # First save the instance to get an ID
        instance.save()
        
        # Save many-to-many relationships using save_m2m()
        self.save_m2m()
        
        # If explicit handling is needed for certain m2m fields
        if 'related_topics' in self.cleaned_data:
            instance.related_topics.set(self.cleaned_data['related_topics'])
        
        if 'authors' in self.cleaned_data:
            instance.authors.set(self.cleaned_data['authors'])
        
        return instance


from django import forms
from django.core.exceptions import ValidationError
from .models import Author, Blog

class AuthorForm(forms.ModelForm):
    class Meta:
        model = Author
        fields = ['status', 'name', 'image', 'description', 'affilation', 'phone', 'email']
        widgets = {
            'status': forms.Select(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all appearance-none bg-white',
            }),
            'name': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all',
                'placeholder': 'Dr. Jane Smith',
            }),
            'image': forms.ClearableFileInput(attrs={
                'class': 'hidden',
                'accept': 'image/*',
                'id': 'id_image',
            }),
            'description': forms.Textarea(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all min-h-[120px]',
                'placeholder': 'Brief bio about the author...',
                'rows': 4,
            }),
            'affilation': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all',
                'placeholder': 'University of Example',
            }),
            'phone': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all',
                'placeholder': '+1 (555) 123-4567',
            }),
            'email': forms.EmailInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border border-gray-300 focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all',
                'placeholder': 'author@example.com',
            }),
        }

    def clean(self):
        cleaned_data = super().clean()
        # Add any cross-field validation here if needed
        return cleaned_data

    def clean_delete(self):
        if self.instance.pk:
            if Blog.objects.filter(authors=self.instance).exists():
                raise ValidationError(
                    "This author cannot be deleted because they are assigned to one or more blog posts."
                )
        return True
    

class TopicsForm(forms.ModelForm):
    class Meta:
        model = Topics
        fields = ['title']

    title = forms.CharField(
        max_length=555,
        widget=forms.TextInput(attrs={
            'class': 'block w-full px-4 py-3 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-2 focus:ring-gray-400',
            'placeholder': 'Enter topic title',
        }),
        label="Topic Title"
    )


    def clean_delete(self):
        if self.instance.pk:
            # Check if any blogs use this topic
            if Blog.objects.filter(topic=self.instance).exists() or Blog.objects.filter(related_topics=self.instance).exists():
                raise ValidationError("This topic cannot be deleted because it is used in one or more blog posts.")
        return True


class BlogCategoryForm(forms.ModelForm):
    class Meta:
        model = BlogCategory
        fields = ['title']  # Only include the 'title' field

    # Optionally, you can add some custom widgets or styling here
    title = forms.CharField(
        widget=forms.TextInput(attrs={
            'class': 'block w-full px-4 py-3 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-2 focus:ring-gray-400',
            'placeholder': 'Enter Category Title'
        })
    )

    def clean_delete(self):
        if self.instance.pk:
            # Check if any blogs use this category
            if Blog.objects.filter(category=self.instance).exists():
                raise ValidationError("This category cannot be deleted because it is used in one or more blog posts.")
        return True


class ContactForm(forms.ModelForm):
    class Meta:
        model = Contact
        fields = ['name', 'mail', 'phone', 'message'] 

    name = forms.CharField(
        max_length=100,
        widget=forms.TextInput(attrs={
            'id': 'name',
            'name': 'name',
            'class': 'w-full p-4 border border-black rounded-lg focus:outline-none focus:ring-2 focus:ring-red-950 bg-white shadow-sm transition duration-200',
            'placeholder': 'Your full name',
            'required': True,
        })
    )
    
    mail = forms.EmailField(  # Changed from 'mail' to 'email'
        widget=forms.EmailInput(attrs={
            'id': 'mail',
            'name': 'mail',
            'class': 'w-full p-4 border border-black rounded-lg focus:outline-none focus:ring-2 focus:ring-red-950 bg-white shadow-sm transition duration-200',
            'placeholder': 'your.email@example.com',
            'required': True,
        })
    )
    
    phone = forms.CharField(
        max_length=20,
        widget=forms.TextInput(attrs={
            'id': 'phone',
            'name': 'phone',
            'class': 'w-full p-4 border border-black rounded-lg focus:outline-none focus:ring-2 focus:ring-red-950 bg-white shadow-sm transition duration-200',
            'placeholder': '+977 9812345678',
            'required': True,
        })
    )
    
    message = forms.CharField(
        widget=forms.Textarea(attrs={
            'id': 'message',
            'name': 'message',
            'rows': 5,
            'class': 'w-full p-4 border border-black rounded-lg focus:outline-none focus:ring-2 focus:ring-red-950 bg-white shadow-sm transition duration-200 resize-none',
            'placeholder': 'How can we help you?',
            'required': True,
        })
    )



    def save(self, commit=True):
        # Get the unsaved instance with all cleaned data
        contact_instance = super().save(commit=False)
        
        # Only add manual processing if needed
        # Example: if you need to modify data before saving
        # contact_instance.some_field = transform(self.cleaned_data['some_field'])
        
        if commit:
            try:
                contact_instance.full_clean()  # Runs model validation
                contact_instance.save()
            except ValidationError as e:
                # Convert model validation errors to form errors
                raise forms.ValidationError(e.message_dict) from e
                
        return contact_instance
    def clean_delete(self):
        # For ContactForm (not a ModelForm), we need to accept a contact_id
        contact_id = getattr(self, 'contact_id', None)
        if contact_id:
            try:
                contact = Contact.objects.get(id=contact_id)
                # Add any validation logic here if needed before deletion
                return True
            except Contact.DoesNotExist:
                raise ValidationError("Contact does not exist.")
        return False


class PollForm(forms.ModelForm):
    class Meta:
        model = Poll
        fields = ['question']

    def clean_delete(self):
        if self.instance.pk:
            # Additional validation if needed
            # For example, check if the poll has been active for more than X days
            if self.instance.is_protected or getattr(self.instance, 'special_status', False):
                raise ValidationError("This poll cannot be deleted because it has a protected status.")
        return True


class OptionForm(forms.ModelForm):
    class Meta:
        model = Option
        fields = ['option_text']

    def clean_delete(self):
        if self.instance.pk:
            # Check if this option has votes
            if hasattr(self.instance, 'votes') and self.instance.votes.count() > 0:
                raise ValidationError("This option cannot be deleted because it has votes.")
        return True


# Create a formset for options
OptionFormSet = inlineformset_factory(
    Poll, Option, form=OptionForm, extra=1, can_delete=True
)


class SubscriberForm(forms.ModelForm):
    class Meta:
        model = Subscriber
        fields = ['name', 'email']
        widgets = {
            'name': forms.TextInput(
                attrs={
                    'id': 'name',
                    'placeholder': 'Enter your name',
                    'class': 'block w-full max-w-xs p-2 text-center rounded-md '
                             'border-gray-300 shadow-sm focus:ring-indigo-500 '
                             'focus:border-indigo-500 sm:text-sm',
                    'required': True,
                }
            ),
            'email': forms.EmailInput(
                attrs={
                    'id': 'email',
                    'placeholder': 'Enter your email',
                    'class': 'block w-full max-w-xs p-2 text-center rounded-md '
                             'border-gray-300 shadow-sm focus:ring-indigo-500 '
                             'focus:border-indigo-500 sm:text-sm',
                    'required': True,
                }
            ),
        }

    def clean_delete(self):
        if self.instance.pk:
            # Add any validation logic here if needed
            # For example, check if the subscriber has special status
            if getattr(self.instance, 'is_vip', False):
                raise ValidationError("This subscriber cannot be deleted because they have VIP status.")
        return True


class TeamMemberForm(forms.ModelForm):
    class Meta:
        model = TeamMember
        fields = [
            'name', 
            'role', 
            'image', 
            'facebook_link', 
            'insta_link', 
            'twitter_link', 
            'email'
        ]
        widgets = {
            'name': forms.TextInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Enter name'
            }),
            'role': forms.TextInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Enter role'
            }),
            'image': forms.FileInput(attrs={
                'class': 'block w-full text-sm text-gray-500 file:mr-4 file:py-2 file:px-4 file:rounded-md file:border-0 file:text-sm file:font-semibold file:bg-blue-50 file:text-blue-700 hover:file:bg-blue-100'
            }),
            'facebook_link': forms.URLInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Facebook URL'
            }),
            'insta_link': forms.URLInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Instagram URL'
            }),
            'twitter_link': forms.URLInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Twitter URL'
            }),
            'email': forms.EmailInput(attrs={
                'class': 'form-input mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring focus:ring-blue-200 focus:ring-opacity-50',
                'placeholder': 'Email address'
            }),
        }

    def clean(self):
        cleaned_data = super().clean()
        # If you want to add any form-wide validation
        return cleaned_data

    def validate_deletion(self):
        """Method to be called from the view when deleting"""
        if self.instance.pk:
            if getattr(self.instance, 'is_founder', False) or getattr(self.instance, 'is_key_member', False):
                raise ValidationError("This team member cannot be deleted as they are marked as a key member or founder.")
        return True


class AuthorLookupForm(forms.Form):
    phone = forms.CharField(
        label="Registered Phone Number",
        widget=forms.TextInput(attrs={
            'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
            'placeholder': 'Enter your registered phone number',
        })
    )

    def clean_delete(self):
        # This is a lookup form, typically not used for deletion
        # But we can still implement the method for consistency
        # It could be used to remove an author lookup request from a temporary storage
        return True


class BlogSubmitForm(forms.ModelForm):
    class Meta:
        model = Blog
        fields = ['title', 'content']
        widgets = {
            'title': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'placeholder': 'Enter your article title'
            }),
            'content': CKEditorWidget(attrs={
                'class': 'prose max-w-none django-ckeditor-widget',
                'rows': 10
            }),
        }

    def clean_delete(self):
        if self.instance.pk:
            # Check if the blog post is in draft status (safe to delete)
            if self.instance.status != 'draft':
                raise ValidationError("Only draft blog posts can be deleted through this form.")
        return True


class AuthorSubmitForm(forms.ModelForm):
    class Meta:
        model = Author
        fields = ['name', 'email', 'phone', 'affilation', 'description', 'image']
        widgets = {
            'name': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'placeholder': 'Your full name'
            }),
            'email': forms.EmailInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'placeholder': 'Your email address'
            }),
            'phone': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'placeholder': 'Your phone number'
            }),
            'affilation': forms.TextInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'placeholder': 'Your organization or institution'
            }),
            'description': forms.Textarea(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 focus:ring-2 focus:ring-red-900 focus:border-red-300',
                'rows': 3,
                'placeholder': 'Brief bio or description'
            }),
            'image': forms.FileInput(attrs={
                'class': 'w-full px-4 py-3 rounded-lg border-2 file:mr-4 file:py-2 file:px-4 file:rounded-full file:border-0 file:text-sm file:font-semibold file:bg-red-50 file:text-red-900 hover:file:bg-red-100'
            }),
        }

    def clean_delete(self):
        if self.instance.pk:
            # Check if the author has any published blogs
            if Blog.objects.filter(authors=self.instance, status='published').exists():
                raise ValidationError("This author profile cannot be deleted because they have published blog posts.")
        return True
 

class IssueForm(forms.ModelForm):
    class Meta:
        model = Issue
        fields = [
            'name', 'issue_number', 'description',
            'publication_date', 'cover_image', 'status'
        ]
        widgets = {
            'publication_date': forms.DateInput(attrs={
                'type': 'date',
                'min': timezone.now().strftime('%Y-%m-%d')
            }),
            'description': forms.Textarea(attrs={'rows': 4}),
            'status': forms.Select(attrs={
                'onchange': 'togglePublicationDate()'
            }),
            'cover_image': forms.ClearableFileInput(attrs={
                'accept': 'image/*',
                'class': 'file-upload-input',
            }),
        }
        help_texts = {
            'publication_date': _('Required for published or scheduled issues'),
            'status': _('Changing status may affect publication date requirements'),
            'cover_image': _('Upload a high-quality cover image (JPEG/PNG)'),
        }

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Set initial minimum date for new issues
        if not self.instance.pk:
            self.fields['publication_date'].widget.attrs['min'] = timezone.now().strftime('%Y-%m-%d')
        
        # Add HTML5 validation attributes
        self.fields['name'].widget.attrs.update({
            'placeholder': _('e.g., Summer Edition 2023'),
            'minlength': '3',
            'maxlength': '100',
        })
        
        self.fields['issue_number'].widget.attrs.update({
            'min': '1',
            'step': '1',
        })
        
        # Customize file input
        self.fields['cover_image'].label = _('Cover Image')
        self.fields['cover_image'].help_text = _('Recommended size: 1200x1600 pixels')

    def clean(self):
        cleaned_data = super().clean()
        status = cleaned_data.get('status')
        publication_date = cleaned_data.get('publication_date')
        
        # Skip validation if we don't have status or if we're in draft
        if not status or status == Issue.Status.DRAFT:
            return cleaned_data
        
        # Validate publication date requirements
        if status in [Issue.Status.PUBLISHED, Issue.Status.SCHEDULED] and not publication_date:
            self.add_error(
                'publication_date',
                ValidationError(
                    _('%(status)s issues must have a publication date.'),
                    params={'status': status},
                    code='required'
                )
            )
        
        if publication_date:
            # Get today's date with time set to 00:00:00 for proper comparison
            today = timezone.now().date()
            
            # Ensure publication_date is a date object without time components
            pub_date = publication_date.date() if hasattr(publication_date, 'date') else publication_date
            
            if status == Issue.Status.SCHEDULED and pub_date < today:
                # Changed from <= to < to allow same-day scheduling
                self.add_error(
                    'publication_date',
                    ValidationError(
                        _('Scheduled issues must have a future publication date.'),
                        code='invalid_date'
                    )
                )
            
            if status == Issue.Status.PUBLISHED and pub_date > today:
                # This check remains the same - can't publish in the future
                self.add_error(
                    'publication_date',
                    ValidationError(
                        _('Published issues cannot have a future publication date.'),
                        code='invalid_date'
                    )
                )
        
        return cleaned_data

    def clean_issue_number(self):
        issue_number = self.cleaned_data.get('issue_number')
        if issue_number is not None:
            try:
                issue_number = int(issue_number)
                if issue_number < 1:
                    raise ValidationError(_("Issue number must be positive"))
                return issue_number
            except (ValueError, TypeError):
                raise ValidationError(_("Please enter a valid number"))
        return issue_number

    
    def clean_cover_image(self):
        cover_image = self.cleaned_data.get('cover_image')
        
        if not cover_image:
            return cover_image
            
        # Check file size (5MB limit)
        max_size = 5 * 1024 * 1024
        if cover_image.size > max_size:
            raise ValidationError(_('Image file too large (max 5MB)'))
        
        # Check file extension
        valid_extensions = ['.jpg', '.jpeg', '.png', '.webp']
        extension = os.path.splitext(cover_image.name)[1].lower()
        if extension not in valid_extensions:
            raise ValidationError(_('Unsupported file format. Please upload a JPEG, PNG, or WebP image.'))
        
        return cover_image
    
class IssueItemForm(forms.ModelForm):
    class Meta:
        model = IssueItem
        fields = ['blog', 'order', 'featured', 'notes']
        widgets = {
            'notes': forms.Textarea(attrs={'rows': 2}),
        }
    
    def __init__(self, *args, **kwargs):
        self.issue = kwargs.pop('issue', None)
        super().__init__(*args, **kwargs)
        
        # Exclude blogs already in this issue
        if self.issue:
            existing_blogs = self.issue.blogs.all()
            self.fields['blog'].queryset = Blog.objects.exclude(
                id__in=existing_blogs.values_list('id', flat=True)
            )

class IssueItemUpdateForm(forms.ModelForm):
    class Meta:
        model = IssueItem
        fields = ['order', 'featured', 'notes']
        widgets = {
            'notes': forms.Textarea(attrs={'rows': 2}),
        }
class AddBlogsToIssueForm(forms.Form):
    blogs = forms.ModelMultipleChoiceField(
        queryset=Blog.objects.filter(status=Blog.Status.PUBLISHED),
        widget=forms.CheckboxSelectMultiple,
        required=False
    )
    
    def __init__(self, *args, **kwargs):
        issue = kwargs.pop('issue', None)
        super().__init__(*args, **kwargs)
        
        # Get all blogs that aren't in any issue
        self.fields['blogs'].queryset = Blog.objects.filter(
            issues__isnull=True, status=Blog.Status.PUBLISHED
        ).order_by('-created_at')


class IssueStatusUpdateForm(forms.ModelForm):
    class Meta:
        model = Issue
        fields = ['status']
    
    def clean_status(self):
        status = self.cleaned_data.get('status')
        instance = self.instance
        
        if status == Issue.Status.PUBLISHED:
            if not instance.cover_image:
                raise ValidationError(_('Cannot publish an issue without a cover image.'))
            if not instance.blogs.exists():
                raise ValidationError(_('Cannot publish an issue without any blogs.'))
            if not instance.publication_date:
                raise ValidationError(_('Cannot publish an issue without a publication date.'))
        
        return status
    

from django import forms
from django.contrib.auth import get_user_model
from .models import Task

User = get_user_model()

class TaskForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
          # Customize the assigned_to field
        self.fields['assigned_to'] = forms.ModelChoiceField(
            queryset=User.objects.all().order_by('first_name'),
            label="Assigned To",
            required=False,
            widget=forms.Select(attrs={
                'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 px-3'
            })
        )
        
        # Add Tailwind classes to other fields
        for field_name, field in self.fields.items():
            if field_name != 'assigned_to':  # Skip assigned_to as we already handled it
                field.widget.attrs['class'] = 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm'
                if field.required:
                    field.widget.attrs['required'] = 'required'
        
        # Special handling for specific fields
        self.fields['title'].widget.attrs.update({
            'placeholder': 'Enter task title',
            'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 px-3'
        })
        
        self.fields['description'].widget.attrs.update({
            'rows': 4,
            'placeholder': 'Enter task description...',
            'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 px-3'
        })
        
        self.fields['due_date'].widget.attrs.update({
            'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 pl-3 pr-10',
            'placeholder': 'Select a date'
        })
        
        self.fields['priority'].widget.attrs.update({
            'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 px-3'
        })
        
        self.fields['status'].widget.attrs.update({
            'class': 'block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm py-2 px-3'
        })

    class Meta:
        model = Task
        fields = [
            'title', 
            'description', 
            'due_date', 
            'priority', 
            'status', 
            'assigned_to'
        ]
        widgets = {
            'due_date': forms.DateInput(attrs={'type': 'date'}),
            'description': forms.Textarea(),
        }

    def label_from_instance(self, obj):
        # Display full name if available, otherwise username
        return f"{obj.get_full_name() or obj.username} ({obj.email})" if obj else ""