SGJP / Kuznia

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

from django.core.exceptions import ValidationError
from django.forms import Textarea, TextInput, ModelMultipleChoiceField, \
    ModelChoiceField, ModelForm, Form, CharField, SelectMultiple, Select, \
    TypedMultipleChoiceField, HiddenInput, IntegerField, BooleanField, \
    ChoiceField
from common.forms import hidden_id
from common.util import GroupDict
from dictionary.models import Lexeme, LexemeInflectionPattern, Ending, \
    Pattern, PatternType, Classification, ClassificationValue, Vocabulary, \
    CrossReference, Qualifier, QualifierExclusionClass, Variant, \
    editable_vocabularies, editable_qualifiers, LexemeAttributeValue, \
    TableTemplate, BaseFormLabel, Gender


def disable_field(field):
    if type(field.widget) in (Textarea, TextInput):
        field.widget.attrs['readonly'] = 'readonly'
    else:
        field.widget.attrs['disabled'] = 'disabled'

# ze StackOverflow, http://stackoverflow.com/questions/3737116/
class QualifiersField(ModelMultipleChoiceField):
    def __init__(self, **kwargs):
        super(QualifiersField, self).__init__(Qualifier.objects.none(),
            **kwargs)
        self.to_field_name = None #?

    def set_qualifiers(self, user, qualified=None, lexeme=None, types=None):
        # if qualified and qualified.id:
        #     if lexeme:
        #         vocabularies = lexeme.editable_vocabularies(user)
        #     else:
        #         vocabularies = qualified.editable_vocabularies(user)
        #     qualifiers = Qualifier.objects.filter(vocabulary__in=vocabularies)
        # else:
        qualifiers = editable_qualifiers(user)
        if types:
            qualifiers = qualifiers.filter(type__in=types)
        if not qualifiers:
            disable_field(self)
            return
        self.queryset = queryset = qualifiers.order_by('vocabulary', 'label')
        queryset = queryset.select_related('vocabulary')
        if qualified and qualified.pk:
            initial_qualifiers = qualified.qualifiers.all() & qualifiers
            self.initial = initial_qualifiers

        q_lists = GroupDict()
        for qualifier in queryset:
            q_lists.add(
                qualifier.vocabulary.id, (qualifier.id, qualifier.label))
        self.choices = sorted(q_lists.iteritems())


class QualifierField(ModelChoiceField):
    def __init__(self, **kwargs):
        qualifiers = Qualifier.objects.all()
        super(QualifierField, self).__init__(qualifiers, **kwargs)
        self.set_qualifiers(qualifiers)

    def set_qualifiers(self, qualifiers):
        if not qualifiers:
            disable_field(self)
            return
        qualifiers = qualifiers.select_related('vocabulary').order_by(
            'vocabulary', 'label')

        q_lists = GroupDict()
        for qualifier in qualifiers:
            q_lists.add(
                qualifier.vocabulary.id, (qualifier.id, qualifier.label))
        self.choices = sorted(q_lists.iteritems())


class LexemeEditForm(ModelForm):
    vocabularies = ModelMultipleChoiceField(
        queryset=Vocabulary.objects.none(), required=False)
    style_qualifiers = QualifiersField(
        required=False, label='kwal styl.',
        widget=SelectMultiple(attrs={'class': 'qualifiers'}))
    scope_qualifiers = QualifiersField(
        required=False, label='kwal. zakr.',
        widget=SelectMultiple(attrs={'class': 'qualifiers'}))
    new_owner = ModelChoiceField(
        queryset=Vocabulary.objects.none(), required=False)

    def __init__(self, user, editable=True, **kwargs):
        super(LexemeEditForm, self).__init__(**kwargs)
        editable_vocabs = editable_vocabularies(user)
        instance = getattr(self, 'instance', None)
        other_editable_vocabs = editable_vocabs.exclude(
            pk=instance.owner_vocabulary.pk)
        self.fields['entry'].required = True
        self.fields['new_owner'].queryset = editable_vocabs
        self.fields['vocabularies'].queryset = other_editable_vocabs
        self.fields['vocabularies'].initial = instance.visible_vocabularies(
            user)
        owner_choices = editable_vocabs.values_list('id', 'id')
        self.fields['new_owner'].choices = owner_choices
        if instance and instance.id:
            self.fields['new_owner'].initial = instance.owner_vocabulary
        if other_editable_vocabs.count() == 0:
            disable_field(self.fields['vocabularies'])
        self.fields['style_qualifiers'].set_qualifiers(
            user, instance, types=[Qualifier.TYPE_STYLE])
        self.fields['scope_qualifiers'].set_qualifiers(
            user, instance, types=[Qualifier.TYPE_SCOPE])
        if not editable and instance and instance.id:
            for name, field in self.fields.iteritems():
                if not name.startswith('qualifiers') and name != 'vocabularies':
                    disable_field(field)

    def clean_comment(self):
        data = self.cleaned_data['comment']
        return data.replace('\r', '')

    class Meta:
        model = Lexeme
        fields = (
            'part_of_speech',
            'entry',
            'pronunciation',
            'valence',
            'status',
            'gloss',
            'note',
            'comment',
            'source',
            'borrowing_source',
            'qualifiers_dor',
            'qualifiers_style',
            'qualifiers_scope',
            'specialist',
            'extended_note',
        )
        widgets = {
            'comment': Textarea(attrs={'cols': 40, 'rows': 5}),
            'extended_note': Textarea(attrs={'cols': 40, 'rows': 5}),
            'gloss': TextInput(attrs={'size': 40}),
            'note': TextInput(attrs={'size': 40}),
            'pronunciation': TextInput(attrs={'size': 40}),
            'valence': TextInput(attrs={'size': 40}),
            'source': TextInput(attrs={'size': 40}),
            'qualifiers_dor': TextInput(attrs={'size': 40}),
            'qualifiers_style': TextInput(attrs={'size': 40}),
            'qualifiers_scope': TextInput(attrs={'size': 40}),
        }

# abstract
class LexemeAttributeForm(Form):
    def __init__(self, attribute, required=True, **kwargs):
        super(LexemeAttributeForm, self).__init__(**kwargs)
        self.fields['value'].label = attribute.name
        self.fields['value'].required = attribute.required and required


class LexemeOpenAttributeForm(LexemeAttributeForm):
    value = CharField(widget=TextInput(attrs={'size': 40}))

    def __init__(self, attribute, initial_value=None, **kwargs):
        assert not attribute.closed and not attribute.multiple
        super(LexemeOpenAttributeForm, self).__init__(attribute, **kwargs)
        if initial_value is not None:
            self.fields['value'].initial = initial_value.value


class LexemeClosedAttributeForm(LexemeAttributeForm):
    value = ModelChoiceField(
        queryset=LexemeAttributeValue.objects.none(),
        widget=Select(attrs={'class': 'attr-value-select'}))

    def __init__(self, attribute, initial_value=None, **kwargs):
        assert attribute.closed and not attribute.multiple
        super(LexemeClosedAttributeForm, self).__init__(attribute, **kwargs)
        self.fields['value'].queryset = attribute.values
        self.fields['value'].initial = initial_value


class LexemeMultipleAttributeForm(LexemeAttributeForm):
    value = ModelMultipleChoiceField(
        queryset=LexemeAttributeValue.objects.none())

    def __init__(self, attribute, initial_value=None, **kwargs):
        assert attribute.closed and attribute.multiple
        super(LexemeMultipleAttributeForm, self).__init__(attribute, **kwargs)
        self.fields['value'].queryset = attribute.values
        self.fields['value'].initial = initial_value


class LIPEditForm(ModelForm):
    pattern_name = CharField(widget=TextInput(
        attrs={'class': 'pattern', 'size': '10'}), label=u'Wzór')
    qualifiers = QualifiersField(
        required=False, label=u'Kwal.',
        widget=SelectMultiple(attrs={'class': 'lip-qualifiers'}))
    lexical_class = CharField(widget=HiddenInput(), label=u'')

    def __init__(self, part_of_speech, lexeme, user, editable=True, index=None,
                 **kwargs):
        super(LIPEditForm, self).__init__(**kwargs)
        if part_of_speech.lexical_class_id != 'subst':
            self.fields['gender'].widget = HiddenInput()
            self.fields['gender'].label = ''
        instance = getattr(self, 'instance', None)
        self.fields['lexical_class'].initial = part_of_speech.lexical_class_id
        self.fields['qualifiers'].set_qualifiers(
            user, instance, lexeme,
            types=[Qualifier.TYPE_STYLE, Qualifier.TYPE_FORM])
        if instance and instance.id:
            self.fields['pattern_name'].initial = instance.pattern.name
            if not editable:
                for name, field in self.fields.iteritems():
                    if name != 'qualifiers':
                        disable_field(field)
        self.index = index

    def clean(self):
        cleaned_data = self.cleaned_data
        try:
            pattern = Pattern.objects.get(name=cleaned_data['pattern_name'])
        except Pattern.DoesNotExist:
            raise ValidationError(u'Niepoprawna nazwa wzoru.')
        lc = cleaned_data['lexical_class']
        if pattern.type.lexical_class_id != lc:
            raise ValidationError(u'Wzór nie pasuje do części mowy.')
        cleaned_data['pattern'] = pattern
        return cleaned_data

    def save(self, *args, **kwargs):
        lip = self.instance
        lip.pattern = self.cleaned_data['pattern']
        if self.index:
            lip.index = self.index
        super(LIPEditForm, self).save(*args, **kwargs)
        lip.save()
        return lip

    class Meta:
        model = LexemeInflectionPattern
        fields = ['gender']
        widgets = {'gender': Select(attrs={'class': 'gender'})}


class ClassificationForm(Form):
    values = TypedMultipleChoiceField(
        choices=[], empty_value=None, coerce=int,
        widget=SelectMultiple(attrs={'class': 'classification-values'}))

    def __init__(self, classification, editable=True, values=None,
                 required=True, **kwargs):
        super(ClassificationForm, self).__init__(**kwargs)
        self.fields['values'].label = classification.name
        self.fields['values'].choices = classification.make_choices()
        self.fields['values'].required = required
        if values:
            self.fields['values'].initial = [value.pk for value in values]
        if not editable:
            for _name, field in self.fields.iteritems():
                disable_field(field)


class AddClassificationForm(ModelForm):
    det = hidden_id('classification_form')

    class Meta:
        model = Classification


class AddClassificationValueForm(ModelForm):
    det = hidden_id('value_form')

    def __init__(self, classification=None, **kwargs):
        super(AddClassificationValueForm, self).__init__(**kwargs)
        if classification is not None:
            parent_choices = [('', u'<brak>')] + classification.make_choices()
            self.fields['parent_node'].choices = parent_choices
            self.fields['classification'].initial = classification.pk

    class Meta:
        model = ClassificationValue
        fields = ['label', 'parent_node', 'classification']
        widgets = {
            'classification': HiddenInput(),
        }


class AddExclusionClassForm(ModelForm):
    det = hidden_id('add_exclusion_class')

    def __init__(self, vocabulary=None, **kwargs):
        super(AddExclusionClassForm, self).__init__(**kwargs)
        self.fields['vocabulary'].initial = vocabulary

    class Meta:
        model = QualifierExclusionClass
        widgets = {
            'vocabulary': HiddenInput(),
        }


class ExclusionClassForm(Form):
    det = hidden_id('remove_exclusion_class')
    ec = ModelChoiceField(
        queryset=QualifierExclusionClass.objects.all(), label=u'') # dziura

    def __init__(self, queryset=None, **kwargs):
        super(ExclusionClassForm, self).__init__(**kwargs)
        if queryset:
            self.fields['ec'].queryset = queryset


class AddQualifierForm(ModelForm):
    det = hidden_id('add_qualifier')

    def __init__(self, vocabulary=None, **kwargs):
        super(AddQualifierForm, self).__init__(**kwargs)
        self.fields['vocabulary'].initial = vocabulary
        if vocabulary:
            self.fields['exclusion_class'].queryset = (
                QualifierExclusionClass.objects
                .filter(vocabulary=vocabulary).distinct())

    def clean(self):
        cleaned_data = self.cleaned_data
        ec = cleaned_data['exclusion_class']
        if ec:
            ec_vocab = ec.vocabulary
            if ec_vocab and ec_vocab != cleaned_data['vocabulary']:
                raise ValidationError(
                    u'Klasa wykluczania niezgodna ze słownikiem.')
        return cleaned_data

    class Meta:
        model = Qualifier
        fields = ['label', 'exclusion_class', 'vocabulary']
        widgets = {
            'vocabulary': HiddenInput(),
        }


class ChangeClassForm(ModelForm):
    def __init__(self, **kwargs):
        super(ChangeClassForm, self).__init__(**kwargs)
        exclusion_classes = (
            self.instance.vocabulary.qualifierexclusionclass_set.all())
        self.fields['exclusion_class'].queryset = exclusion_classes

    def clean(self):
        ec = self.cleaned_data['exclusion_class']
        q = self.instance
        if ec:
            ec_qualifiers = ec.qualifier_set.all()
            if Lexeme.objects.filter(qualifiers=q).filter(
                    qualifiers__in=ec_qualifiers):
                raise ValidationError(u'Kolizja w klasie wykluczania')
            if LexemeInflectionPattern.objects.filter(
                    qualifiers=q).filter(qualifiers__in=ec_qualifiers):
                raise ValidationError(u'Kolizja w klasie wykluczania')
            if Ending.objects.filter(qualifiers=q).filter(
                    qualifiers__in=ec_qualifiers):
                raise ValidationError(u'Kolizja w klasie wykluczania')
        return self.cleaned_data

    class Meta:
        model = Qualifier
        fields = ['exclusion_class']


class CrossReferenceForm(ModelForm):
    entry = CharField(label=u'hasło', widget=TextInput(attrs={
        'class': 'entry',
        'size': 12,
    }))
    homonym_number = IntegerField(label=u'hom.',
        widget=TextInput(attrs={
            'class': 'homonym-number',
            'readonly': 'readonly',
            'size': 1,
        }))

    def __init__(self, lexeme=None, pos=None, **kwargs):
        super(CrossReferenceForm, self).__init__(**kwargs)
        if lexeme is not None:
            if pos is None:
                pos = lexeme.part_of_speech
            crtypes = pos.crtype_to.all()
            type_choices = crtypes.values_list('pk', 'desc')
            self.fields['type'].widget.choices = type_choices
            self.fields['from_lexeme'].initial = lexeme.pk

    def clean(self):
        cleaned_data = self.cleaned_data
        from_lexeme = cleaned_data.get('from_lexeme')
        entry = cleaned_data.get('entry')
        hom = cleaned_data.get('homonym_number')
        cr_type = cleaned_data.get('type')
        try:
            to_lexeme = Lexeme.objects.get(
                entry=entry, homonym_number=hom, part_of_speech=cr_type.to_pos)
        except Lexeme.DoesNotExist:
            raise ValidationError(u'Wybrany leksem nie istnieje.')
        except Lexeme.MultipleObjectsReturned:
            # jeśli się zdarzy, to jest niespójność w danych
            raise ValidationError(u'Niejednoznaczny numer homonimu!')
        if from_lexeme and to_lexeme and cr_type:
            if cr_type.from_pos != from_lexeme.part_of_speech:
                raise ValidationError(u'Nieprawidłowa część mowy w odsyłaczu.')
        cleaned_data['to_lexeme'] = to_lexeme
        return cleaned_data

    def save(self, commit=True):
        cr = super(CrossReferenceForm, self).save(False)
        cr.to_lexeme = self.cleaned_data['to_lexeme']
        if commit:
            cr.save()
        return cr

    class Meta:
        model = CrossReference
        fields = ['type', 'from_lexeme']
        widgets = {
            'type': Select(attrs={'class': 'type'}),
            'from_lexeme': HiddenInput(),
        }


class VocabularyForm(Form):
    det = hidden_id('vocabulary_form')
    vocabulary = ModelChoiceField(
        label=u"dodaj słownik", queryset=Vocabulary.objects.none())
    classification = ModelChoiceField(
        widget=HiddenInput(), queryset=Classification.objects.all())

    def __init__(self, queryset, classification=None, **kwargs):
        super(VocabularyForm, self).__init__(**kwargs)
        self.fields['vocabulary'].queryset = queryset
        if classification:
            self.fields['classification'].initial = classification


class PatternEditForm(ModelForm):
    def __init__(self, editable=True, **kwargs):
        super(PatternEditForm, self).__init__(**kwargs)
        self.fields['type'].choices = PatternType.options()
        if not editable:
            instance = getattr(self, 'instance', None)
            if instance and instance.id:
                for name, field in self.fields.iteritems():
                    disable_field(field)

    class Meta:
        model = Pattern
        fields = (
            'type', 'name', 'example', 'basic_form_ending', 'status', 'comment')


class QualifierForm(Form):
    qualifiers = QualifiersField(
        required=False, label=u'',
        widget=SelectMultiple(attrs={'class': 'qualifiers'}))

    def __init__(self, user, qualified=None, editable=True,
                 **kwargs):
        super(QualifierForm, self).__init__(**kwargs)
        self.fields['qualifiers'].set_qualifiers(
            user, qualified, types=[Qualifier.TYPE_STYLE, Qualifier.TYPE_FORM])
        if not editable:
            disable_field(self.fields['qualifiers'])


class ExportForm(Form):
    vocabs = ModelMultipleChoiceField(
        queryset=Vocabulary.objects.all(), label=u'słowniki')
    antivocabs = ModelMultipleChoiceField(
        queryset=Vocabulary.objects.all(), label=u'antysłowniki',
        required=False)
    variant = ModelChoiceField(
        queryset=Variant.objects.filter(type=Variant.TYPE_EXPORT),
        label=u'wariant')
    refl = BooleanField(label=u'tagi z "refl"', required=False)
    commonness = BooleanField(label=u'etykiety pospolitości', required=False)
    #excluding_qualifiers = QualifiersField(
    #  required=False, label=u'kwal. wykluczające')


class MagicQualifierForm(Form):
    qualifier = QualifierField(label=u'kwal. leksemu')
    regex = CharField(label=u'wzorzec tagu', required=False)


ADD_REMOVE_CHOICES = (
    ('add', u'Dodaj'),
    ('remove', u'Usuń'),
)


class StatusActionForm(Form):
    action = ChoiceField(
        choices=[('set', u'ustaw')], label=u'',
        widget=Select(attrs={'class': 'action-choice'}))


class StatusValueForm(Form):
    value = ChoiceField(
        choices=Lexeme.STATUS_CHOICES, label=u'',
        widget=Select(attrs={'class': 'value-choice'}))

    def __init__(self, request, **kwargs):
        super(StatusValueForm, self).__init__(**kwargs)


class UsingVocabularyActionForm(Form):
    action = ChoiceField(
        choices=ADD_REMOVE_CHOICES, label=u'',
        widget=Select(attrs={'class': 'action-choice'}))


class VocabularyValueForm(Form):
    value = ModelChoiceField(
        queryset=Vocabulary.objects.none(), label=u'',
        widget=Select(attrs={'class': 'value-choice'}))

    def __init__(self, request, **kwargs):
        super(VocabularyValueForm, self).__init__(**kwargs)
        self.fields['value'].queryset = editable_vocabularies(request.user)


class LexemeQualifierActionForm(Form):
    action = ChoiceField(
        choices=ADD_REMOVE_CHOICES, label=u'',
        widget=Select(attrs={'class': 'action-choice'}))


class LexemeQualifierValueForm(Form):
    value = QualifierField(label=u'',
        widget=Select(attrs={'class': 'value-choice'}))

    def __init__(self, request, **kwargs):
        super(LexemeQualifierValueForm, self).__init__(**kwargs)
        self.fields['value'].set_qualifiers(editable_qualifiers(request.user))


ACTION_FIELDS = (
    ('status',
    (u'Status', StatusActionForm, StatusValueForm)),
    ('using_vocabulary',
    (u'Słownik używający', UsingVocabularyActionForm, VocabularyValueForm)),
    ('lexeme_qualifier',
    (u'Kwalifikator leksemu',
    LexemeQualifierActionForm, LexemeQualifierValueForm)),
)


class ActionFieldForm(Form):
    field = ChoiceField(
        choices=[(id, data[0]) for id, data in ACTION_FIELDS], label=u'',
        widget=Select(attrs={'class': 'field-choice'}))


class TemplateChoiceForm(Form):
    table_template = ModelChoiceField(
        TableTemplate.objects.none(), label=u'Szablon tabel')

    def __init__(self, **kwargs):
        super(TemplateChoiceForm, self).__init__(**kwargs)
        choices = GroupDict()
        template_field = self.fields['table_template']
        for tt in TableTemplate.objects.order_by('variant', 'name'):
            choices.add(tt.variant.id, (tt.id, tt))
        template_field.choices = sorted(choices.iteritems())


class CellRestrictionsForm(Form):
    pattern_types = ModelMultipleChoiceField(
        queryset=PatternType.objects.none(), label=u'',
        widget=SelectMultiple(attrs={'class': 'pattern-types-select'}))

    # wybrane/dostępne typy wzorów
    def __init__(self, sel_pt, av_pt, **kwargs):
        super(CellRestrictionsForm, self).__init__(**kwargs)
        self.fields['pattern_types'].queryset = av_pt
        self.fields['pattern_types'].initial = sel_pt

class GenderForm(Form):
    genders = ModelMultipleChoiceField(
        queryset=Gender.objects.all(), label=u'',
        widget=SelectMultiple(attrs={'class': 'gender-select'}))

    def __init__(self, initial=None, **kwargs):
        super(GenderForm, self).__init__(**kwargs)
        if initial:
            self.fields['genders'].initial = initial
        else:
            self.fields['genders'].initial = self.fields['genders'].queryset

class AttributeValuesForm(Form):
    values = ModelMultipleChoiceField(
        queryset=LexemeAttributeValue.objects.none(),
        widget=SelectMultiple(attrs={'class': 'attrs-select'}))

    def __init__(self, attribute, initial=None, **kwargs):
        assert attribute.closed and not attribute.multiple
        super(AttributeValuesForm, self).__init__(**kwargs)
        self.fields['values'].label = attribute.name
        self.fields['values'].queryset = attribute.values
        if initial is None:
            initial = attribute.values.all()
        self.fields['values'].initial = initial

class BaseFormLabelForm(Form):
    base_form_label = ModelChoiceField(
        queryset=BaseFormLabel.objects.none(), label=u'',
        widget=Select(attrs={'class': 'bfl-select'}))

    def __init__(self, bfls, initial=None, **kwargs):
        super(BaseFormLabelForm, self).__init__(**kwargs)
        self.fields['base_form_label'].queryset = bfls
        self.fields['base_form_label'].initial = initial

CSS_CLASS_CHOICES = (
    ('header', u'nagł.'),
    ('header-c', u'wyśr.'),
    ('data', u'dane'),
    ('blank', u'blank'),
)

class CSSClassForm(Form):
    css_class = ChoiceField(
        choices=CSS_CLASS_CHOICES, label='klasa',
        widget=Select(attrs={'class': 'css-class-select'}))

    def __init__(self, initial=None, **kwargs):
        super(CSSClassForm, self).__init__(**kwargs)
        self.fields['css_class'].initial = initial

class TemplatePreviewForm(Form):
    pattern_type = ModelChoiceField(
        queryset=PatternType.objects.none(), label=u'typ wzoru',
        widget=Select(attrs={'class': 'pattern-type-select'}))

    def __init__(self, pattern_types, **kwargs):
        super(TemplatePreviewForm, self).__init__(**kwargs)
        self.fields['pattern_type'].queryset = pattern_types

class TemplatePreviewGenderForm(Form):
    gender = ModelChoiceField(
        queryset=Gender.objects.all(), label=u'rodzaj',
        widget=Select(attrs={'class': 'gender-select'}))