'''from django import forms
from .models import UploadedFile'''

'''class UploadFileForm(forms.ModelForm):
    class Meta:
        model = UploadedFile
        fields = ['file']
'''
from django import forms
from .models import Rilievi
# from .models import RilieviElaborati
from .models import Azienda, UserProfile, Rilievi
from django.contrib.auth.models import User

from django.utils.safestring import mark_safe

class CustomSelectWidget(forms.Select):
    def __init__(self, attrs=None, choices=(), data_translate_choices=None):
        super().__init__(attrs, choices)
        self.data_translate_choices = data_translate_choices or {}
        self.css = attrs or {}

    def render(self, name, value, attrs=None, renderer=None):
        if attrs is None:
            attrs = {}

        # unisci gli attributi passati a quelli del widget
        final_attrs = self.build_attrs(self.attrs, attrs)
        css = self.css.get('class', '')
        idd = self.css.get('id', '')

        options_html = []
        for option_value, option_label in self.choices:
            data_tr = self.data_translate_choices.get(option_value)
            if data_tr is not None:
                options_html.append(
                    f'<option value="{option_value}">'
                    f'<span data-translate="{data_tr}">{option_label}</span>'
                    f'</option>'
                )
            else:
                options_html.append(
                    f'<option value="{option_value}">{option_label}</option>'
                )

        attr_string = ''
        for key, val in final_attrs.items():
            if isinstance(val, list):
                val = ' '.join(val)
            attr_string += f' {key}="{val}"'

        html = (
            f'<select class="{css}" id="{idd}" name="{name}"{attr_string}>'
            f'{"".join(options_html)}'
            f'</select>'
        )

        # QUI è la parte importante
        return mark_safe(html)
'''class RilieviForm(forms.ModelForm):
    class Meta:
        model = Rilievi
        fields = ['file']'''

from django import forms
from .models import Rilievi

class RilieviFormInput(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Add data-translate attribute to the label
        self.fields['nome_rilievo'].label = "Inserisci il nome del rilievo"
        self.fields['nome_rilievo'].widget.attrs['data-translate'] = "Inserisci il nome del rilievo"
        
        # Add data-translate attributes to survey_type options
        survey_type_field = self.fields['survey_type']
        survey_vector_field = self.fields['survey_vector']
        survey_vector_field.widget = CustomSelectWidget(
            attrs={
                'class' : 'form-select',
                'id' : 'survey-vector'
            },
            data_translate_choices={
            '' : 'Seleziona il vettore',
               'ARL' : 'Aereo',
                'HND':'Manuale',
                'VHCL':'Veicolo',
                'ALTR' :  'Altro',
            }
        )
        survey_type_field.widget = CustomSelectWidget(
            attrs={
                'class': 'form-select',
                'id': 'survey-type'
            },
            data_translate_choices={
                '': 'Seleziona il sensore',
                'GPR': 'Georadar',
                'MAG': 'Magnetometro', 
                'FOTO': 'Fotogrammetria',
                'ALTR': 'Altro',
            }
        )
        # Set attributes directly on the widget
        survey_type_field.widget.attrs.update({
            'class': 'form-select',
            'id': 'survey-type'
        })
        survey_vector_field.widget.attrs.update({
            'class': 'form-select',
            'id': 'survey-vector'
        })
        
        # Override choices with empty option
        survey_type_field.choices = [
            ('', 'Seleziona il sensore'),
            ('GPR', 'Georadar'),
            ('MAG', 'Magnetometro'),
            ('FOTO', 'Fotogrammetria'),
            ('ALTR', 'Altro'),
        ]
        survey_vector_field.choices = [
            ('', 'Seleziona il vettore'),
            ('ARL', 'Aereo'),
            ('HND', 'Manuale'),
            ('VHCL', 'Veicolo'),
            ('ALTR', 'Altro'),
        ]
    #form-select
    class Meta:
        model = Rilievi
        fields = ['nome_rilievo', 'file_input', 'survey_type', 'survey_vector']
        widgets = {
            'nome_rilievo': forms.TextInput(attrs={
                'class': 'form-control',
                'id': 'file-name',
            }),
        }

class RilieviFormOutput(forms.ModelForm):
    class Meta:
        model = Rilievi
        fields = ['file_output', 'created_at_output', 'shapefile']
        widgets = {
            'created_at_output': forms.DateTimeInput(attrs={'type': 'datetime-local'}),
        }

'''class RilieviElaboratiForm(forms.ModelForm):
    class Meta:
        model = RilieviElaborati
        fields = ['file']'''

class AziendaForm(forms.ModelForm):
    class Meta:
        model = Azienda
        fields = ['nome_azienda', 'partita_iva', 'mail_referente', 'telefono_referente', 'pec', 'indirizzo_legale']
        widgets = {
            'nome_azienda': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Nome azienda', 'data-translate-placeholder': 'Nome azienda'}),
            'partita_iva': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Partita IVA', 'data-translate-placeholder': 'Partita IVA'}),
            'mail_referente': forms.EmailInput(attrs={'class': 'right me-3', 'placeholder': 'Indirizzo mail referente', 'data-translate-placeholder': 'Indirizzo mail referente'}),
            'telefono_referente': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Contatto telefonico referente', 'data-translate-placeholder': 'Contatto telefonico referente'}),
            'indirizzo_legale': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Indirizzo legale', 'data-translate-placeholder': 'Indirizzo legale'}),
            'pec': forms.EmailInput(attrs={'class': 'right me-3', 'placeholder': 'PEC', 'data-translate-placeholder': 'PEC'}),
        }

class UserForm(forms.ModelForm):
    password = forms.CharField(widget=forms.PasswordInput(attrs={'class': 'right me-3', 'placeholder': 'Password', 'data-translate-placeholder': 'Password'}))

    class Meta:
        model = User
        fields = ['username', 'first_name', 'last_name', 'email', 'password']
        widgets = {
            'username': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Nome utente', 'data-translate-placeholder': 'Nome utente'}),
            'first_name': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Nome', 'data-translate-placeholder': 'Nome'}),
            'last_name': forms.TextInput(attrs={'class': 'right me-3', 'placeholder': 'Cognome', 'data-translate-placeholder': 'Cognome'}),
            'email': forms.EmailInput(attrs={'class': 'right me-3', 'placeholder': 'Email utente', 'data-translate-placeholder': 'Email utente'}),
        }

    def clean_username(self):
        username = self.cleaned_data['username']
        if User.objects.filter(username=username).exists():
            raise forms.ValidationError('Questo username è già in uso.')
        return username

    def clean_email(self):
        email = self.cleaned_data['email']
        if User.objects.filter(email=email).exists():
            raise forms.ValidationError('Questa email è già in uso.')
        return email

class UserProfileForm(forms.ModelForm):
    azienda = forms.ModelChoiceField(
        queryset=Azienda.objects.all(),
        required=True,
        widget=forms.Select(attrs={'class': 'right me-3'}),
        label='Azienda'
    )
    
    class Meta:
        model = UserProfile
        fields = ['azienda']

class AdminRilieviFormInput(forms.ModelForm):
    """Form per l'admin per inserire un rilievo completo con tutti i dati"""
    def __init__(self, *args, **kwargs):
        # Estrai azienda_selezionata dai kwargs se presente
        self.azienda_selezionata = kwargs.pop('azienda_selezionata', None)
        super().__init__(*args, **kwargs)
        # Add data-translate attribute to the label
        self.fields['nome_rilievo'].label = "Nome del rilievo"
        self.fields['nome_rilievo'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-nome-rilievo',
            'placeholder': 'Inserisci il nome del rilievo'
        })
        
        # Configura survey_type e survey_vector
        survey_type_field = self.fields['survey_type']
        survey_vector_field = self.fields['survey_vector']
        
        survey_type_field.widget.attrs.update({
            'class': 'form-select',
            'id': 'admin-survey-type'
        })
        survey_vector_field.widget.attrs.update({
            'class': 'form-select',
            'id': 'admin-survey-vector'
        })
        
        # Override choices with empty option
        survey_type_field.choices = [
            ('', 'Seleziona il sensore'),
            ('GPR', 'Georadar'),
            ('MAG', 'Magnetometro'),
            ('FOTO', 'Fotogrammetria'),
            ('ALTR', 'Altro'),
        ]
        survey_vector_field.choices = [
            ('', 'Seleziona il vettore'),
            ('ARL', 'Aereo'),
            ('HND', 'Manuale'),
            ('VHCL', 'Veicolo'),
            ('ALTR', 'Altro'),
        ]
        
        # Configura priorità
        self.fields['priorita'].widget.attrs.update({
            'class': 'form-select',
            'id': 'admin-priorita'
        })
        
        # Configura file_input
        self.fields['file_input'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-file-input',
            'accept': '.zip'
        })
        self.fields['file_input'].required = True
        
        # Configura file_output
        self.fields['file_output'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-file-output',
            'accept': '.zip'
        })
        self.fields['file_output'].required = False
        
        # Campi opzionali per dati aggiuntivi
        self.fields['m2'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-m2',
            'step': 'any',
            'placeholder': 'es. 1500.5'
        })
        self.fields['m2'].required = False
        
        self.fields['dimensione'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-dimensione',
            'step': 'any',
            'placeholder': 'es. 2.5'
        })
        self.fields['dimensione'].required = False
        
        self.fields['metri_sottoservizi'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-metri-sottoservizi',
            'step': 'any',
            'placeholder': 'es. 45.2'
        })
        self.fields['metri_sottoservizi'].required = False
        
        self.fields['numero_anomalie'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-numero-anomalie',
            'step': '1',
            'min': '0',
            'placeholder': 'es. 15'
        })
        self.fields['numero_anomalie'].required = False
        
        self.fields['t_elab'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-t-elab',
            'step': 'any',
            'placeholder': 'es. 120'
        })
        self.fields['t_elab'].required = False
        
        self.fields['latitudine'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-latitudine',
            'step': 'any',
            'placeholder': 'es. 45.4642'
        })
        self.fields['latitudine'].required = False
        
        self.fields['longitudine'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-longitudine',
            'step': 'any',
            'placeholder': 'es. 9.1900'
        })
        self.fields['longitudine'].required = False
        
        self.fields['shapefile'].widget.attrs.update({
            'class': 'form-control',
            'id': 'admin-shapefile',
            'accept': '.geojson'
        })
        self.fields['shapefile'].required = False
    
    def clean_nome_rilievo(self):
        """Valida che il nome del rilievo sia univoco per azienda"""
        nome_rilievo = self.cleaned_data.get('nome_rilievo')
        
        if not nome_rilievo:
            return nome_rilievo
        
        # Ottieni l'azienda dal form data se disponibile
        azienda_id = None
        if hasattr(self, 'azienda_selezionata') and self.azienda_selezionata:
            azienda_id = self.azienda_selezionata.id
        elif 'admin_azienda_selezionata' in self.data:
            from .models import Azienda
            try:
                azienda = Azienda.objects.get(nome_azienda=self.data['admin_azienda_selezionata'])
                azienda_id = azienda.id
            except Azienda.DoesNotExist:
                pass
        
        if azienda_id:
            # Controlla univocità per azienda
            existing = Rilievi.objects.filter(
                nome_rilievo__iexact=nome_rilievo,
                azienda_id=azienda_id
            )
            # Se stiamo modificando un rilievo esistente, escludilo dal controllo
            if self.instance and self.instance.pk:
                existing = existing.exclude(pk=self.instance.pk)
            
            if existing.exists():
                raise forms.ValidationError(
                    f'Un rilievo con il nome "{nome_rilievo}" esiste già per questa azienda. '
                    'Scegli un nome diverso.'
                )
        else:
            # Se non c'è azienda selezionata, mostra un messaggio generico
            # ma non bloccare la validazione (sarà gestito dalla view)
            pass
        
        return nome_rilievo
    
    class Meta:
        model = Rilievi
        fields = [
            'nome_rilievo', 
            'file_input',
            'file_output',
            'survey_type', 
            'survey_vector',
            'priorita',
            'm2',
            'dimensione',
            'metri_sottoservizi',
            'numero_anomalie',
            't_elab',
            'latitudine',
            'longitudine',
            'shapefile'
        ]


class DeactivateUserForm(forms.Form):
    """Form per disattivare (soft delete) un utente senza rimuoverne i rilievi."""
    utente = forms.ModelChoiceField(
        queryset=User.objects.none(),
        required=True,
        label='Utente da disattivare',
        empty_label='Seleziona un utente',
        widget=forms.Select(attrs={'class': 'form-select'})
    )

    def __init__(self, *args, **kwargs):
        azienda = kwargs.pop('azienda', None)
        super().__init__(*args, **kwargs)

        queryset = User.objects.none()
        if azienda:
            queryset = (
                User.objects
                .filter(userprofile__azienda=azienda, is_superuser=False, is_active=True)
                .select_related('userprofile')
                .order_by('first_name', 'last_name', 'username')
            )
        else:
            queryset = (
                User.objects
                .filter(is_superuser=False, userprofile__azienda__isnull=False, is_active=True)
                .select_related('userprofile')
                .order_by('first_name', 'last_name', 'username')
            )

        self.fields['utente'].queryset = queryset


class ReactivateUserForm(forms.Form):
    """Form per riattivare un utente precedentemente disattivato."""
    utente = forms.ModelChoiceField(
        queryset=User.objects.none(),
        required=True,
        label='Utente da riattivare',
        empty_label='Seleziona un utente',
        widget=forms.Select(attrs={'class': 'form-select'})
    )

    def __init__(self, *args, **kwargs):
        azienda = kwargs.pop('azienda', None)
        super().__init__(*args, **kwargs)

        queryset = User.objects.none()
        if azienda:
            queryset = (
                User.objects
                .filter(userprofile__azienda=azienda, is_superuser=False, is_active=False)
                .select_related('userprofile')
                .order_by('first_name', 'last_name', 'username')
            )
        else:
            queryset = (
                User.objects
                .filter(is_superuser=False, userprofile__azienda__isnull=False, is_active=False)
                .select_related('userprofile')
                .order_by('first_name', 'last_name', 'username')
            )

        self.fields['utente'].queryset = queryset


class ReassignRilieviForm(forms.Form):
    """Form per riassegnare tutti i rilievi da un utente ad un altro."""
    user_sorgente = forms.ModelChoiceField(
        queryset=User.objects.none(),
        required=True,
        label='Utente sorgente',
        empty_label='Seleziona utente sorgente',
        widget=forms.Select(attrs={'class': 'form-select'})
    )
    user_destinazione = forms.ModelChoiceField(
        queryset=User.objects.none(),
        required=True,
        label='Nuovo utente',
        empty_label='Seleziona utente destinazione',
        widget=forms.Select(attrs={'class': 'form-select'})
    )

    def __init__(self, *args, **kwargs):
        azienda = kwargs.pop('azienda', None)
        super().__init__(*args, **kwargs)

        base_queryset = User.objects.none()
        if azienda:
            base_queryset = (
                User.objects
                .filter(userprofile__azienda=azienda, is_superuser=False)
                .select_related('userprofile')
                .order_by('is_active', 'first_name', 'last_name', 'username')
            )

        self.fields['user_sorgente'].queryset = base_queryset
        self.fields['user_destinazione'].queryset = base_queryset.filter(is_active=True)

    def clean(self):
        cleaned_data = super().clean()
        user_sorgente = cleaned_data.get('user_sorgente')
        user_destinazione = cleaned_data.get('user_destinazione')

        if user_sorgente and user_destinazione:
            if user_sorgente == user_destinazione:
                self.add_error('user_destinazione', 'Seleziona un utente diverso dal sorgente.')
            else:
                src_azienda = getattr(user_sorgente.userprofile, 'azienda_id', None)
                dest_azienda = getattr(user_destinazione.userprofile, 'azienda_id', None)
                if src_azienda != dest_azienda:
                    raise forms.ValidationError('Gli utenti devono appartenere alla stessa azienda.')

        return cleaned_data