from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.utils import timezone
from datetime import timedelta
from .models import EmployeeProfile, Company, CostCenter, VacationRequest
from django.db.models import Q

class LoginForm(forms.Form):
    username = forms.CharField(
        widget=forms.TextInput(attrs={'class': 'form-control', 'placeholder': 'Nome de usuário'}),
        label="Nome de usuário"
    )
    password = forms.CharField(
        widget=forms.PasswordInput(attrs={'class': 'form-control', 'placeholder': 'Senha'}),
        label="Senha"
    )

class EmployeeForm(forms.ModelForm):
    first_name = forms.CharField(max_length=30, required=True, label="Nome")
    last_name = forms.CharField(max_length=30, required=True, label="Sobrenome")
    email = forms.EmailField(required=True, label="E-mail")
    username = forms.CharField(required=True, label="Usuário")

    password1 = forms.CharField(
        label="Senha",
        widget=forms.PasswordInput,
        required=False
    )
    password2 = forms.CharField(
        label="Confirmação de senha",
        widget=forms.PasswordInput,
        required=False
    )

    company = forms.ModelChoiceField(
        queryset=Company.objects.filter(is_active=True),
        required=True,
        label="Empresa"
    )

    cost_centers = forms.ModelMultipleChoiceField(
        queryset=CostCenter.objects.none(),
        required=True,
        label="Centros de Custo",
        widget=forms.CheckboxSelectMultiple()
    )

    employee_id = forms.CharField(max_length=50, required=True, label="Matrícula")
    hire_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date'}),
        required=True,
        label="Data de Admissão"
    )

    role = forms.ChoiceField(
        choices=EmployeeProfile.USER_ROLE_CHOICES,
        required=True,
        label="Papel"
    )

    is_tutor = forms.BooleanField(
        required=False,
        label="Este colaborador pode ser tutor"
    )

    tutor = forms.ModelChoiceField(
        queryset=EmployeeProfile.objects.filter(is_tutor=True, is_active=True),
        required=False,
        label="Tutor (para estagiário)"
    )

    class Meta:
        model = User
        fields = ['username', 'first_name', 'last_name', 'email']

    def __init__(self, *args, **kwargs):
        instance = kwargs.get('instance', None)
        super().__init__(*args, **kwargs)

        for field in self.fields.values():
            if isinstance(field.widget, forms.widgets.Input):
                field.widget.attrs.update({'class': 'form-control'})

        self.fields['is_tutor'].widget.attrs.update({'class': 'form-check-input'})

        if instance and hasattr(instance, 'employeeprofile'):
            profile = instance.employeeprofile
            assigned_ids = list(profile.cost_centers.values_list('id', flat=True))
            self.fields['cost_centers'].queryset = CostCenter.objects.filter(
                Q(is_active=True) & Q(id__in=assigned_ids)
            ).distinct()
            self.fields['is_tutor'].initial = profile.is_tutor
        else:
            self.fields['cost_centers'].queryset = CostCenter.objects.filter(is_active=True).distinct()

        if instance and instance.pk:
            self.fields['password1'].widget = forms.HiddenInput()
            self.fields['password2'].widget = forms.HiddenInput()
            self.fields['password1'].required = False
            self.fields['password2'].required = False

    def save(self, commit=True):
        user = super().save(commit=False)

        if not self.instance.pk and self.cleaned_data.get('password1'):
            user.set_password(self.cleaned_data['password1'])

        if commit:
            user.save()
            self.save_m2m()

        self.profile_data = {
            'company': self.cleaned_data['company'],
            'employee_id': self.cleaned_data['employee_id'],
            'hire_date': self.cleaned_data['hire_date'],
            'role': self.cleaned_data['role'],
            'is_tutor': self.cleaned_data.get('is_tutor', False),
            'cost_centers': self.cleaned_data['cost_centers'],
            'tutor': self.cleaned_data.get('tutor') if self.cleaned_data['role'] == 'intern' else None,
        }

        return user

    def clean(self):
        cleaned_data = super().clean()
        if not self.instance or not self.instance.pk:
            password1 = cleaned_data.get("password1")
            password2 = cleaned_data.get("password2")
            if not password1 or not password2:
                raise forms.ValidationError("Senha e confirmação são obrigatórias para novo colaborador.")
            if password1 != password2:
                raise forms.ValidationError("As senhas não coincidem.")
        return cleaned_data




class VacationRequestForm(forms.ModelForm):
    start_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date', 'min': (timezone.now() + timedelta(days=30)).date().isoformat()}),
        label="Data de Início"
    )
    end_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date'}),
        label="Data de Retorno"
    )
    selling_days = forms.IntegerField(
        min_value=0,
        required=False,
        initial=0,
        label="Dias a vender (abono pecuniário)",
        help_text="Você pode vender até 1/3 dos dias de férias conforme a CLT."
    )

    class Meta:
        model = VacationRequest
        fields = ('start_date', 'end_date', 'selling_days')

    def __init__(self, employee=None, *args, **kwargs):
        self.employee = employee
        super().__init__(*args, **kwargs)
        for field_name, field in self.fields.items():
            field.widget.attrs.update({'class': 'form-control'})

    def clean(self):
        cleaned_data = super().clean()
        start_date = cleaned_data.get('start_date')
        end_date = cleaned_data.get('end_date')
        selling_days = cleaned_data.get('selling_days', 0)

        if not start_date or not end_date:
            return cleaned_data

        if start_date < timezone.now().date() + timedelta(days=30):
            self.add_error('start_date', "A data de início deve ser no mínimo 30 dias após a solicitação, conforme CLT.")

        if end_date <= start_date:
            self.add_error('end_date', "A data final deve ser posterior à data inicial.")

        total_days = (end_date - start_date).days + 1

        if total_days < 5:
            self.add_error('end_date', "Conforme a CLT, períodos de férias devem ter no mínimo 5 dias.")

        if selling_days:
            max_selling_days = min(10, total_days // 3)
            if selling_days > max_selling_days:
                self.add_error('selling_days',
                               f"Conforme a CLT, você pode vender no máximo {max_selling_days} dias (1/3 das férias).")

        if self.employee:
            from vacations.utils import calculate_vacation_balance
            balance = calculate_vacation_balance(self.employee)
            if total_days + (selling_days or 0) > balance:
                self.add_error('end_date',
                               f"Saldo insuficiente de férias. Você possui {balance} dias disponíveis.")

        return cleaned_data

class ApprovalForm(forms.Form):
    action = forms.ChoiceField(
        choices=[('approve', 'Aprovar'), ('reject', 'Rejeitar')],
        widget=forms.RadioSelect(attrs={'class': 'form-check-input'}),
        label="Ação"
    )
    rejection_reason = forms.CharField(
        widget=forms.Textarea(attrs={'class': 'form-control', 'rows': 3}),
        required=False,
        label="Motivo da rejeição"
    )

    def clean(self):
        cleaned_data = super().clean()
        action = cleaned_data.get('action')
        rejection_reason = cleaned_data.get('rejection_reason')

        if action == 'reject' and not rejection_reason:
            self.add_error('rejection_reason', "É necessário informar o motivo da rejeição.")

        return cleaned_data

class ReportForm(forms.Form):
    REPORT_CHOICES = [
        ('vacation_balance', 'Saldo de Férias'),
        ('vacation_schedule', 'Programação de Férias'),
        ('pending_requests', 'Solicitações Pendentes'),
    ]

    report_type = forms.ChoiceField(
        choices=REPORT_CHOICES, 
        widget=forms.Select(attrs={'class': 'form-control'}),
        label="Tipo de Relatório"
    )
    company = forms.ModelChoiceField(
        queryset=Company.objects.filter(is_active=True),
        widget=forms.Select(attrs={'class': 'form-control'}),
        required=False,
        label="Empresa"
    )
    cost_center = forms.ModelChoiceField(
        queryset=CostCenter.objects.filter(is_active=True),
        widget=forms.Select(attrs={'class': 'form-control'}),
        required=False,
        label="Centro de Custo"
    )
    start_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date', 'class': 'form-control'}),
        required=False,
        label="Data Inicial"
    )
    end_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date', 'class': 'form-control'}),
        required=False,
        label="Data Final"
    )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        for field in self.fields.values():
            field.widget.attrs.update({'class': 'form-control'})

        if 'company' in self.data:
            try:
                company_id = self.data.get('company')
                self.fields['cost_center'].queryset = CostCenter.objects.filter(
                    company_id=company_id,
                    is_active=True
                )
            except (ValueError, TypeError):
                self.fields['cost_center'].queryset = CostCenter.objects.none()

class ManualVacationForm(forms.ModelForm):
    class Meta:
        model = VacationRequest
        fields = ['employee', 'start_date', 'end_date', 'selling_days', 'correction_note']
        widgets = {
            'start_date': forms.DateInput(attrs={'type': 'date'}),
            'end_date': forms.DateInput(attrs={'type': 'date'}),
        }
        labels = {
            'employee': 'Colaborador',
            'start_date': 'Data de Início',
            'end_date': 'Data de Término',
            'selling_days': 'Dias Vendidos (opcional)',
        }

    def save(self, commit=True):
        vacation = super().save(commit=False)
        vacation.status = 'approved'
        vacation.is_manual = True
        if commit:
            vacation.save()
        return vacation

class InternProfileExtraForm(forms.ModelForm):
    class Meta:
        model = EmployeeProfile
        fields = [
            'cpf',
            'carga_horaria',
            'horario_trabalho_inicio',
            'horario_trabalho_fim',
            'turma',
            'funcao',
            'logo_file',
        ]
        widgets = {
            'carga_horaria': forms.TextInput(attrs={'placeholder': 'ex: 40 horas semanais'}),
            'horario_trabalho_inicio': forms.TimeInput(attrs={'type': 'time'}),
            'horario_trabalho_fim': forms.TimeInput(attrs={'type': 'time'}),
            'cpf': forms.TextInput(attrs={'placeholder': '000.000.000-00'}),
            'turma': forms.TextInput(attrs={'placeholder': 'Identificação da turma'}),
            'funcao': forms.TextInput(attrs={'placeholder': 'Função exercida'}),
        }



from django import forms

# --- NOVO FORMULÁRIO DE SOLICITAÇÃO DE FÉRIAS POR OPÇÃO ---
VACATION_OPTIONS = [
    ('Gozo 5 dias', 'Gozo de 5 dias'),
    ('Gozo 6 dias', 'Gozo de 6 dias'),
    ('Gozo 7 dias', 'Gozo de 7 dias'),
    ('Gozo 12 dias', 'Gozo de 12 dias'),
    ('Gozo 14 dias', 'Gozo de 14 dias'),
    ('Gozo 15 + venda 5', 'Gozo de 15 dias + 5 vendidos'),
    ('Gozo 18 dias', 'Gozo de 18 dias'),
    ('Gozo 20 + venda 10', 'Gozo de 20 dias + 10 vendidos (máximo permitido)'),
    ('Gozo 30 dias', 'Gozo de 30 dias (sem venda)'),
    ('Gozo 15 dias', 'Gozo de 15 dias'),
]

VACATION_RULES = {
    'Gozo 5 dias': {'periods': [5], 'sold_days': 0},
    'Gozo 6 dias': {'periods': [6], 'sold_days': 0},
    'Gozo 7 dias': {'periods': [7], 'sold_days': 0},
    'Gozo 12 dias': {'periods': [12], 'sold_days': 0},
    'Gozo 14 dias': {'periods': [14], 'sold_days': 0},
    'Gozo 15 dias': {'periods': [15], 'sold_days': 0},
    'Gozo 15 + venda 5': {'periods': [15], 'sold_days': 5},
    'Gozo 18 dias': {'periods': [18], 'sold_days': 0},
    'Gozo 20 + venda 10': {'periods': [20], 'sold_days': 10},
    'Gozo 30 dias': {'periods': [30], 'sold_days': 0},
}

class VacationChoiceForm(forms.Form):
    start_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date', 'class': 'form-control'}),
        label="Data de início das férias"
    )
    vacation_option = forms.ChoiceField(
        choices=VACATION_OPTIONS,
        widget=forms.Select(attrs={'class': 'form-select'}),
        label="Tipo de férias"
    )


class VacationChoiceForm(forms.Form):
    start_date = forms.DateField(
        widget=forms.DateInput(attrs={'type': 'date', 'class': 'form-control'}),
        label="Data de início das férias"
    )
    vacation_option = forms.ChoiceField(
        choices=VACATION_OPTIONS,
        widget=forms.Select(attrs={'class': 'form-select'}),
        label="Tipo de férias"
    )


from django import forms
from .models import LogoInstitucional

class LogoUploadForm(forms.ModelForm):
    class Meta:
        model = LogoInstitucional
        fields = ['imagem']


from django import forms

class CancelVacationForm(forms.Form):
    reason = forms.CharField(
        label="Motivo do cancelamento",
        widget=forms.Textarea(attrs={'class': 'form-control', 'rows': 4}),
        max_length=500
    )
