# -*- coding: utf-8 -*-

from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

from django import forms
from django.forms.models import BaseInlineFormSet
from django.utils import timezone
from bda.models import Attribution, Spectacle


class BaseBdaFormSet(BaseInlineFormSet):
    def clean(self):
        """Checks that no two articles have the same title."""
        super(BaseBdaFormSet, self).clean()
        if any(self.errors):
            # Don't bother validating the formset unless each form is valid on
            # its own
            return
        spectacles = []
        for i in range(0, self.total_form_count()):
            form = self.forms[i]
            if not form.cleaned_data:
                continue
            spectacle = form.cleaned_data['spectacle']
            delete = form.cleaned_data['DELETE']
            if not delete and spectacle in spectacles:
                raise forms.ValidationError(
                    "Vous ne pouvez pas vous inscrire deux fois pour le "
                    "même spectacle.")
            spectacles.append(spectacle)


class TokenForm(forms.Form):
    token = forms.CharField(widget=forms.widgets.Textarea())


class AttributionModelMultipleChoiceField(forms.ModelMultipleChoiceField):
    def label_from_instance(self, obj):
        return "%s" % obj.spectacle


class ResellForm(forms.Form):
    attributions = AttributionModelMultipleChoiceField(
                         label='',
                         queryset=Attribution.objects.none(),
                         widget=forms.CheckboxSelectMultiple,
                         required=False)

    def __init__(self, participant, *args, **kwargs):
        super(ResellForm, self).__init__(*args, **kwargs)
        self.fields['attributions'].queryset = participant.attribution_set\
            .filter(spectacle__date__gte=timezone.now())\
            .exclude(revente__seller=participant)


class AnnulForm(forms.Form):
    attributions = AttributionModelMultipleChoiceField(
                         label='',
                         queryset=Attribution.objects.none(),
                         widget=forms.CheckboxSelectMultiple,
                         required=False)

    def __init__(self, participant, *args, **kwargs):
        super(AnnulForm, self).__init__(*args, **kwargs)
        self.fields['attributions'].queryset = participant.attribution_set\
            .filter(spectacle__date__gte=timezone.now(),
                    revente__isnull=False,
                    revente__notif_sent=False,
                    revente__soldTo__isnull=True)


class InscriptionReventeForm(forms.Form):
    spectacles = forms.ModelMultipleChoiceField(
                    queryset=Spectacle.objects.none(),
                    widget=forms.CheckboxSelectMultiple,
                    required=False)

    def __init__(self, tirage, *args, **kwargs):
        super(InscriptionReventeForm, self).__init__(*args, **kwargs)
        self.fields['spectacles'].queryset = tirage.spectacle_set.filter(
                date__gte=timezone.now())


class SoldForm(forms.Form):
    attributions = AttributionModelMultipleChoiceField(
                        label='',
                        queryset=Attribution.objects.none(),
                        widget=forms.CheckboxSelectMultiple)

    def __init__(self, participant, *args, **kwargs):
        super(SoldForm, self).__init__(*args, **kwargs)
        self.fields['attributions'].queryset = (
            participant.attribution_set
                       .filter(revente__isnull=False,
                               revente__soldTo__isnull=False)
                       .exclude(revente__soldTo=participant)
        )
