Walenty / ShellValier

from random import randint

from django import forms

from django.db.models import OneToOneField, ForeignKey, CharField, ManyToManyField, Q

from django.utils.text import format_lazy
from django.utils.translation import gettext_lazy as _

from django.utils import translation

from crispy_forms.helper import FormHelper
import crispy_forms.bootstrap as bootstrap
import crispy_forms.layout as layout

from connections.models import Entry, POS, Status, SchemaHook
from syntax.models import (
    Schema, SchemaOpinion, InherentSie, Negativity, Predicativity, Aspect,
    Position, SyntacticFunction, Control, PredicativeControl,
)
from syntax.models_phrase import PhraseTypeModel, PhraseType, EmptyAttributes, XPAttributes, AdvPAttributes, ComparAttributes, FixedAttributes, LemmaOperator, LemmaCooccur, Lemma

from semantics.models import (
    Frame, FrameOpinion,
    Argument, SemanticRole, RoleAttribute,
    PredefinedSelectionalPreference, RelationalSelectionalPreference, SelectionalPreferenceRelation,
)

from meanings.models import Synset

from .form_fields.generic_fields import (
    RangeFilter,
    RegexFilter,
    ChoiceFilter,
    ModelChoiceFilter,
    MultipleChoiceFilter,
    ModelMultipleChoiceFilter,
    OperatorField,
    SwitchField,
)

from .form_fields.specialised_fields import (
    PhraseoFilter,
    PhraseTypeFilter,
    RoleNameFilter,
    RoleAttributeFilter,
)

from .form_fields.query_managers import SingleValueQueryManager

# TODO better to import this from the importer, the web app should not be aware of the importer! :)
from importer.PhraseAttributes import attrs_helpers

from . import polish_strings


class QueryForm(forms.Form):
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_class = 'form-horizontal'
        self.helper.label_class = 'col-sm-2'
        self.helper.field_class = 'col-sm-10'
        self.helper.attrs = { 'data_formtype' : 'unknown' }
    
    @staticmethod
    def get_child_form_prefix(child_form):
        print(type(child_form))
        raise NotImplementedError
    
    def get_queries(self, negated_attrs):
        queries = []
        for key, value in self.cleaned_data.items():
            #print('========', key, value)
            if value and not key.startswith('filter') and not key.startswith('negate'):
                form_field = self.fields[key]
                if hasattr(form_field, 'query_manager'):
                    conjunction = form_field.query_manager.default_conjunction
                    negate = key in negated_attrs
                    qs = form_field.query_manager.make_queries(value, conjunction)
                    assert(len(qs) < 2)
                    queries += [~q if negate else q for q in qs]
        return queries
    
    def is_negated(self):
        for key, value in self.cleaned_data.items():
            if key.startswith('negate') and value:
                return True
        return False
    
    @classmethod
    def make_field(cls, field_name):
        field_object = cls.base_fields[field_name]
        return field_object.layout(field_name)

def or_button(button_label, add_button_id):
    return bootstrap.StrictButton('+ {} ({})'.format(_('Lub'), button_label), css_class='or-button btn-xs btn-info', data_add_id=add_button_id)

def other_button(button_label, add_button_id):
    return bootstrap.StrictButton('+ {} ({})'.format(_('Inny'), button_label), css_class='other-button btn-xs btn-warning', data_add_id=add_button_id)

def and_or_form_creator(button_label, button_id, field=None, data_add=None, add_other=False, help=None, tooltip=None, *args, **kwargs):
    add_button = None
    data_add = 'switch' if data_add is None else data_add
    if field is not None:
        add_button = bootstrap.FieldWithButtons(field, bootstrap.StrictButton('+ {}'.format(_('Dodaj')), css_id=button_id, css_class='add-button btn-xs btn-success', data_add=data_add, *args, **kwargs))
    else:
        add_button = bootstrap.StrictButton('+ {}'.format(button_label), css_id=button_id, css_class='add-button btn-xs btn-success', data_add=data_add, *args, **kwargs)
    ret = [
        layout.HTML('<div class="and-or-forms py-1" data-formtype="{}">'.format(data_add)),
        add_button,
        or_button(button_label, button_id),
        layout.HTML('</div>'),
    ]
    if add_other:
        ret.insert(-1, other_button(button_label, button_id))
    if help:
        help_tooltip = ''
        if tooltip:
            help_tooltip = ' <span data-toggle="tooltip" data-placement="bottom" title="{}"><img src="/static/common/img/info.svg" alt="info" width="12" height="12"/></span>'.format(tooltip)
        ret.insert(-1, layout.HTML('<small class="form-text text-muted">{}{}</small>'.format(help, help_tooltip)))
    return ret

class EntryForm(QueryForm):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        #self.helper.form_method = 'get'
        # TODO remove if this form is to be used with different views
        self.helper.form_action = 'entries:get_entries'
        self.helper.form_id = 'main-form'
        self.helper.attrs = { 'data_formtype' : 'entry' }
        self.model_class = Entry
        
        entry_components = [
            self.make_field('lemma'),
            self.make_field('pos'),
            self.make_field('phraseology'),
            self.make_field('status'),
        ]
        
        schema_components = [
            self.make_field('num_schemata'),
        ] + \
        and_or_form_creator(_('Schemat'), 'add-schema-0', data_add='schema', add_other=True, help=_('Schemat(y) występujące w haśle')) + \
        and_or_form_creator(_('Pozycja'), 'add-position-0', data_add='position', add_other=True,
            help=_('Pozycja/e występujące w haśle'),
            tooltip=_('Pozycje mogą występować w różnych schematach. Aby ograniczyć filtrowanie do występowania wymaganych pozycji w obrębie jednego schematu, proszę użyć filtru POZYCJA wewnątrz filtra SCHEMAT powyżej.')
            ) + \
        and_or_form_creator(_('Fraza'), 'add-phrase-0', field=self.make_field('phrase_type'), data_prefix='phrase_',
            help=_('Fraza/y występujące w haśle'),
            tooltip=_('Frazy mogą występować w różnych schematach i na różnych pozycjach. Aby ograniczyć filtrowanie do występowania wymaganych fraz w obrębie jednej pozycji, proszę użyć filtru POZYCJA powyżej lub wewnątrz filtra SCHEMAT.')
        ) + \
        [
            self.make_field('filter_schemata'),
        ]
        
        
        
        frame_components = [
            self.make_field('num_frames'),
        ] + \
        and_or_form_creator(_('Rama'), 'add-frame-0', data_add='frame', add_other=True, help=_('Rama/y występujące w haśle')) + \
        and_or_form_creator(_('Argument'), 'add-argument-0', data_add='argument', help=_('Argument(y) występujące w haśle')) + \
        [
            self.make_field('filter_frames'),
        ]
        
        components = [
            layout.Fieldset(_('Własności hasła'), *entry_components),
            layout.Fieldset(_('Własności składniowe'), *schema_components),
            layout.Fieldset(_('Własności semantyczne'), *frame_components),
            layout.Submit('main-submit', _('Filtruj'), css_class='btn-sm'),
            layout.Reset('main-reset', _('Wyczyść'), css_class='btn-sm'),
        ]
        
        self.helper.layout = layout.Layout(*components)
    
    lemma = RegexFilter(
        label=_('Lemat'),
        lookup='name',
        max_length=200,
        autocomplete='lemma',
    )
    pos = ModelMultipleChoiceFilter(
        label=_('Część mowy'),
        queryset=POS.objects.exclude(tag='unk'),
        key='tag',
        human_values=polish_strings.POS(),
        lookup='pos',
    )
    phraseology = PhraseoFilter()
    status = ModelMultipleChoiceFilter(
        label ='Status',
        queryset=Status.objects.all().order_by('-priority'),
        key = 'key',
        human_values=polish_strings.STATUS(),
        lookup='status',
    )
    num_schemata = RangeFilter(
        label=_('Liczba schematów'),
        lookup='schemata_count',
    )
    num_frames = RangeFilter(
        label=_('Liczba ram'),
        lookup='frames_count',
    )
    phrase_type = PhraseTypeFilter(
        queryset=PhraseTypeModel.objects.filter(main_phrase_types__positions__schemata__isnull=False).distinct(),
        #help_text=_('Typ frazy występujący w haśle.'),
    )
    filter_schemata = SwitchField(_('Ukryj niepasujące schematy'))
    filter_frames = SwitchField(_('Ukryj niepasujące ramy'))
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == Schema:
            return 'subentries__schemata__in'
        if child_form.model_class == Position:
            return 'subentries__schemata__positions__in'
        if child_form.model_class == PhraseType:
            return 'subentries__schemata__positions__phrase_types__in'
        if child_form.model_class == Frame:
            return 'subentries__schema_hooks__argument_connections__argument__frame__in'
        if child_form.model_class == Argument:
            return 'subentries__schema_hooks__argument_connections__argument__in'
        raise KeyError(type(child_form))


# for forms that can appear multiple times in the query constructor field
# (e.g. a phrase form), create a separate form class for each form ‘instance’,
# with globally unique field names to ensure proper javascript behaviour
# and retrieving the field values in views
class FormFactory(object):
    
    form_class_name = None
    form_model = None
    form_formtype = None
    form_header = None
    
    @staticmethod
    def unique_number():
        return randint(1000, 12345678)
    
    @staticmethod
    def unique_name(field_name, unique_number):
        return '{}_{}'.format(field_name, unique_number)
    
    @staticmethod
    def make_helper_attrs(form_type, unique_number):
        return { 'data_formtype' : form_type , 'data_formnumber' : unique_number }
    
    @staticmethod
    def make_layout(title, components, as_subform=True):
        elements = []
        if as_subform:
            elements.append('{} <span class="collapsed-info text-info"></span> <button class="btn collapse-button btn-xs btn-secondary" data-collapsed="false" type="button">{}</button><button class="btn remove-button btn-xs btn-danger" type="button">{}</button>'.format(title, _('Zwiń'), _('Usuń')))
        elements += components
        if not as_subform:
            elements += [
                layout.Submit('main-submit', _('Filtruj'), css_class='btn-sm'),
                layout.Reset('main-reset', _('Wyczyść'), css_class='btn-sm'),
            ]
        return layout.Layout(layout.Fieldset(
            *elements
        ))
    
    @staticmethod
    def additional_queries():
        return []
    
    @classmethod    
    def get_form(cls, unique_number=None, as_subform=True, *args, **kwargs):
        unique_number = cls.unique_number() if unique_number is None else unique_number
        
        assert(cls.form_class_name is not None)
        assert(cls.form_model is not None)
        assert(cls.form_formtype is not None)
        assert(cls.form_header is not None)
        
        form_class = type(cls.form_class_name, (QueryForm,), {
            #'__init__' : form_init,
            'get_child_form_prefix' : lambda self, child_form: cls.get_child_form_prefix(child_form),
        })
        
        def form_init(self, *args, **kwargs):
            super(type(self), self).__init__(*args, **kwargs)
            self.helper.attrs = cls.make_helper_attrs(cls.form_formtype, unique_number)
            self.model_class = cls.form_model
            
            components = [self.make_field(cls.unique_name('negated', unique_number))]
            for field_name, field_maker, component_maker in cls.field_makers:
                if component_maker:
                    component = component_maker(unique_number, form_class)
                else:
                    component = self.make_field(cls.unique_name(field_name, unique_number))
                if type(component) == list:
                    components += component
                else:
                    components.append(component)
            self.helper.layout = cls.make_layout(cls.form_header, components, as_subform=as_subform)
        
        form_class.__init__ = form_init
        
        def get_queries(self, negated_attrs):
            return super(type(self), self).get_queries(negated_attrs) + cls.additional_queries()
        
        form_class.get_queries = get_queries
        
        form_class.base_fields[cls.unique_name('negated', unique_number)] = SwitchField(_('Zaneguj'), css_class='negate-switch')
        for field_name, field_maker, layout_maker in cls.field_makers:
            if field_name is not None:
                form_class.base_fields[FormFactory.unique_name(field_name, unique_number)] = field_maker()
        return form_class(*args, **kwargs)
    
    @staticmethod
    def get_child_form_prefix(child_form):
        raise NotImplementedError

class SchemaFormFactory(FormFactory):
    
    form_class_name = 'SchemaForm'
    form_model = Schema
    form_formtype = 'schema'
    form_header = _('Schemat składniowy')
    
    field_makers = (
        (
            'opinion',
            lambda: ModelMultipleChoiceFilter(
                label=_('Opinia o schemacie'),
                queryset=SchemaOpinion.objects.filter(schemata__isnull=False).distinct(),
                key='key',
                human_values=polish_strings.SCHEMA_OPINION(),
                lookup='opinion',
            ),
            None,
        ), 
        (
            'type',
            lambda: MultipleChoiceFilter(
                label=_('Typ'),
                choices=(
                    (False, (_('zwykły'), None)),
                    (True,  (_('frazeologiczny'), None)),
                ),
                lookup='phraseologic',
            ),
            None,
        ),
        (
            'sie',
            lambda: ModelMultipleChoiceFilter(
                label=_('Zwrotność'),
                queryset=InherentSie.objects.all(),
                key='name',
                human_values=polish_strings.TRUE_FALSE_YES_NO,
                lookup='subentries__inherent_sie',
            ),
            None,
        ),
        (
            'neg',
            lambda: ModelMultipleChoiceFilter(
                label=_('Negatywność'),
                queryset=Negativity.objects.exclude(name=''),
                key='name',
                human_values=polish_strings.NEGATION(),
                lookup='subentries__negativity',
            ),
            None,
        ),
        (
            'pred',
            lambda: ModelMultipleChoiceFilter(
                label=_('Predykatywność'),
                queryset=Predicativity.objects.all(),
                key='name',
                human_values=polish_strings.TRUE_FALSE_YES_NO,
                lookup='subentries__predicativity',
            ),
            None,
        ),
        (
            'aspect',
            lambda: ModelMultipleChoiceFilter(
                label=_('Aspekt'),
                queryset=Aspect.objects.exclude(name='').exclude(name='_'),
                key='name',
                human_values=polish_strings.ASPECT(),
                lookup='subentries__aspect',
            ),
            None,
        ),
        #phrase = RegexFilter(
        #label='Fraza',
        #max_length=200,
        ##initial='np.* !& !np.* | xp.*',
        #lookup='positions__phrase_types__text_rep',
        #additional_operators=True,
        #autocomplete='phrasetype',
        #)
        (
            'num_positions',
            lambda: RangeFilter(
                label=_('Liczba pozycyj'),
                lookup='positions_count',
            ),
            None,
        ),
        #(
        #    'num_phrase_types',
        #    lambda: RangeFilter(
        #        label='Liczba typów fraz w pozycji',
        #        entry_lookup='subentries__schemata__positions__phrases_count',
        #        object_lookup='positions__phrases_count',
        #    )
        #),
        (
            None, None,
            lambda n, cls: and_or_form_creator(_('Pozycja'), 'add-position-{}'.format(n), data_add='position', add_other=True, help=_('Pozycja/e występujące w schemacie')),
        ),
    )
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == Position:
            return 'positions__in'
        raise KeyError(type(child_form))


class PositionFormFactory(FormFactory):
    
    form_class_name = 'PositionForm'
    form_model = Position
    form_formtype = 'position'
    form_header = _('Pozycja składniowa')
    
    field_makers = (
        (
            'gram_function',
            lambda: ModelMultipleChoiceFilter(
                label=_('Funkcja gramatyczna'),
                queryset=SyntacticFunction.objects.all(),
                key='name',
                human_values=polish_strings.GRAM_FUNCTION(),
                lookup='function',
            ), None,
        ),
        (
            'control',
            lambda: ModelMultipleChoiceFilter(
                label=_('Kontrola'),
                queryset=Control.objects.filter(positions__isnull=False).distinct(),
                key='name',
                human_values=polish_strings.CONTROL(),
                lookup='control',
            ), None,
        ),
        (
            'pred_control',
            lambda: ModelMultipleChoiceFilter(
                label=_('Kontrola predykatywna'),
                queryset=PredicativeControl.objects.all(),
                key='name',
                human_values=polish_strings.CONTROL(),
                lookup='pred_control',
            ), None,
        ),
        (
            'num_phrases',
            lambda: RangeFilter(
                label=_('Liczba fraz'),
                lookup='phrases_count',
            ),
            None,
        ),
        (
            'phrase_type',
            #lambda: PhraseTypeFilter(help_text=_('Typ frazy występujący na pozycji.')),
            lambda: PhraseTypeFilter(),
            lambda n, cls: and_or_form_creator(_('Fraza'), 'add-phrase-{}'.format(n), field=cls.make_field(FormFactory.unique_name('phrase_type', n)), data_prefix='phrase_', help=_('Fraza/y występujące na pozycji')),
        ),
    )
     
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == PhraseType:
            return 'phrase_types__in'
        raise KeyError(type(child_form))


class LemmaFormFactory(FormFactory):
    
    form_class_name = 'LemmaForm'
    form_model = Lemma
    form_formtype = 'lemma'
    form_header = _('Lemat')
    
    field_makers = (
        (
            'lemma',
            lambda: RegexFilter(
                label=_('Lemat'),
                max_length=32,
                lookup='name',
                autocomplete='lex_lemma'
            ), None,
        ),
    )


class LexFormFactory(FormFactory):
    
    form_class_name = 'LexForm'
    form_model = PhraseType
    form_formtype = 'phrase_lex'
    form_header = _('Fraza zleksykalizowana')
    
    field_makers = (
        (
            'lemma_operator',
            lambda: ModelMultipleChoiceFilter(
                label=_('Wybór lematów'),
                queryset=LemmaOperator.objects.all(),
                key='name',
                human_values=polish_strings.LEMMA_OPERATOR(),
                lookup='lemma_operator',
            ), None,
        ),
        (
            'lemma_cooccur',
            lambda: ModelMultipleChoiceFilter(
                label=_('Łączenie lematów'),
                queryset=LemmaCooccur.objects.all(),
                key='name',
                human_values=polish_strings.LEMMA_COOCCUR(),
                lookup='lemma_cooccur',
            ), None,
        ),
        (
            None, None,
            lambda n, cls: and_or_form_creator(_('Lemat'), 'add-lemma-{}'.format(n), data_add='lemma'),
        ),
        (
            'lex_type',
            lambda: PhraseTypeFilter(lex=True, help_text=_('Typ składniowy frazy zleksykalizowanej.')),
            lambda n, cls: and_or_form_creator(_('Typ frazy'), 'add-lex-{}'.format(n), field=cls.make_field(FormFactory.unique_name('lex_type', n)), data_prefix='phrase_lex')
        ),
    )
    
    @staticmethod
    def additional_queries():
        return [Q(('main_type__name', 'lex'))]
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == PhraseType:
            return 'id__in'
        if child_form.model_class == Lemma:
            return 'lemmata__in'
        raise KeyError(type(child_form))


class FrameFormFactory(FormFactory):
    
    form_class_name = 'FrameForm'
    form_model = Frame
    form_formtype = 'frame'
    form_header = _('Rama semantyczna')
    
    field_makers = (
        (
            'opinion',
            lambda: ModelMultipleChoiceFilter(
                label=_('Opinia'),
                queryset=FrameOpinion.objects.exclude(key='unk').filter(frame__isnull=False).distinct(),
                key='key',
                human_values=polish_strings.FRAME_OPINION(),
                lookup='opinion',
            ), None,
        ),
        (
            'num_arguments',
            lambda: RangeFilter(
                label=_('Liczba argumentów'),
                lookup='arguments_count',
            ), None
        ),
        (
            'num_preferences',
            lambda: RangeFilter(
                label=_('Liczba preferencyj selekcyjnych argumentu'),
                lookup='arguments__preferences_count',
            ), None
        ),
        (
            None, None,
            lambda n, cls: and_or_form_creator(_('Argument'), 'add-argument-{}'.format(n), data_add='argument'),
        ),
    )
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == Argument:
            return 'arguments__in'
        raise KeyError(type(child_form))


class ArgumentFormFactory(FormFactory):
    
    form_class_name = 'ArgumentForm'
    form_model = Argument
    form_formtype = 'argument'
    form_header = _('Argument semantyczny')
    
    field_makers = (
        (
            'role',
            lambda: RoleNameFilter(
                label=_('Rola'),
                lookup='role__role',
            ), None,
        ),
        (
            'role_attribute',
            lambda: RoleAttributeFilter(
                label=_('Atrybut roli'),
                lookup='role__attribute',
            ), None,
        ),
        (
            'preference_type',
            lambda: ChoiceFilter(
                label=_('Preferencja selekcyjna'),
                choices=(('', _('wybierz')), ('predefined', _('Predefiniowana grupa znaczeń')), ('relational', _('Wyrażona przez relację')), ('synset', _('Wyrażona przez jednostkę leksykalną Słowosieci'))),
            ),
            lambda n, cls: and_or_form_creator(_('Preferencja selekcyjna'), 'add-preference-{}'.format(n), field=cls.make_field(FormFactory.unique_name('preference_type', n)))
        ),
        (
            None, None,
            lambda n, cls: and_or_form_creator(_('Pozycja'), 'add-position-{}'.format(n), data_add='position'),
        ),
        (
            'phrase_type',
            lambda: PhraseTypeFilter(help_text=_('Typ frazy, przez którą może być realizowany argument.')),
            lambda n, cls: and_or_form_creator(_('Fraza'), 'add-phrase-{}'.format(n), field=cls.make_field(FormFactory.unique_name('phrase_type', n)), data_prefix='phrase_'),
        ),
    )
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == PredefinedSelectionalPreference:
            return 'predefined__in'
        if child_form.model_class == RelationalSelectionalPreference:
            return 'relations__in'
        if child_form.model_class == Synset:
            return 'synsets__in'
        if child_form.model_class == PhraseType:
            return 'argument_connections__schema_connections__phrase_type__in'
        raise KeyError(type(child_form))


class PredefinedPreferenceFormFactory(FormFactory):
    
    form_class_name = 'PredefinedPreferenceForm'
    form_model = PredefinedSelectionalPreference
    form_formtype = 'predefined'
    form_header = _('Preferencja predefiniowana')
    
    field_makers = (
        (
            'predefined',
            lambda: ModelMultipleChoiceFilter(
                label=_('Predefiniowane'),
                queryset=PredefinedSelectionalPreference.objects.all(),
                key='key',
                lookup='key',
            ), None,
        ),
    )


class RelationalPreferenceFormFactory(FormFactory):
    
    form_class_name = 'RelationalPreferenceForm'
    form_model = RelationalSelectionalPreference
    form_formtype = 'relational'
    form_header = _('Preferencja – relacja')
    
    field_makers = (
        (
            'relation',
            lambda: ModelMultipleChoiceFilter(
                label=_('Relacja'),
                queryset=SelectionalPreferenceRelation.objects.all(),
                key='key',
                human_values=polish_strings.RELATION(),
                lookup='relation',
                checkboxes=False,
            ), None,
        ),
        (
            'to_role',
            lambda: RoleNameFilter(
                label=_('Do: rola'),
                lookup='to__role__role',
            ), None,
        ),
        (
            'to_attribute',
            lambda: RoleAttributeFilter(
                label=_('Do: atrybut'),
                lookup='to__role__attribute',
            ), None,
        )
    )
       

class SynsetPreferenceFormFactory(FormFactory):
    
    form_class_name = 'SynsetPreferenceForm'
    form_model = Synset
    form_formtype = 'synset'
    form_header = _('Preferencja – Słowosieć')
    
    field_makers = (
        (
            'synset',
            lambda: RegexFilter(
                label=_('Jednostka leksykalna'),
                max_length=200,
                lookup='lexical_units__text_rep',
                autocomplete='lu'
            ), None,
        ),
    )


class PhraseAttributesFormFactory(FormFactory):
    
    # field types are dynamic here
    field_makers = None
    
    @classmethod
    def make_form_class(cls, n, model, lex_model, phrase_type):
        #print('*****************', n, model, lex_model, phrase_type)
        lex_phrase = lex_model is not None
        fields = list(filter(lambda x: type(x) in (OneToOneField, ForeignKey, CharField, ManyToManyField) and not x.name.endswith('_ptr'), model._meta.get_fields()))
        if lex_phrase:
            lex_fields = list(filter(lambda x: type(x) in (OneToOneField, ForeignKey, CharField, ManyToManyField) and not x.name.endswith('_ptr'), lex_model._meta.get_fields()))
        else:
            lex_fields = []
        all_fields = [(f, '{}'.format(f.name)) for f in fields] + [(f, 'lex_{}'.format(f.name)) for f in lex_fields]
        
        class AttributesForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('phrase_{}{}'.format('lex' if lex_model else '', phrase_type), n)
                self.helper.form_id = 'phrase-form'
                self.model_class = PhraseType
                
                components = [self.make_field(cls.unique_name('negated', n))]
                for field, name in all_fields:
                    uniq_name = cls.unique_name(name, n)
                    if name == 'reals':
                        flds = and_or_form_creator(_('Fraza'), 'add-phrase-1-{}'.format(n), field=self.make_field(uniq_name), data_prefix='phrase_')
                    elif name.endswith('_lexes'):
                        flds = and_or_form_creator(_('Fraza'), 'add-phrase-2-{}'.format(n), field=self.make_field(uniq_name), data_prefix='phrase_lex')
                    elif name.endswith('_lex'):
                        flds = and_or_form_creator(_('Fraza'), 'add-phrase-3-{}'.format(n), field=self.make_field(uniq_name), data_prefix='phrase_lex')
                    elif name == 'phrase':
                        flds = and_or_form_creator(_('Fraza'), 'add-phrase-4-{}'.format(n), field=self.make_field(uniq_name), data_prefix='phrase_')
                    else:
                        flds = [self.make_field(uniq_name)]
                    components += flds
                pt = polish_strings.PHRASE_TYPE()[phrase_type]
                header = pt.capitalize() if phrase_type in polish_strings.NO_PHRASE_NAME else format_lazy(_('Fraza {}'), pt)
                if lex_model:
                    header += ' ({})'.format(_('zleksykalizowana'))
                self.helper.layout = cls.make_layout(
                    header.capitalize(),
                    components
                )
            
            # add a phrase type query
            def get_queries(self, negated_attrs):
                pt_q = Q(('{}main_type__name'.format('lexicalized_phrase__' if lex_phrase else ''), phrase_type))
                return super().get_queries(negated_attrs) + [pt_q]
            
            @staticmethod
            def get_child_form_prefix(child_form):
                if model == XPAttributes and child_form.model_class == PhraseType:
                    return 'attributes__xpattributes__reals__in'
                if model == AdvPAttributes and child_form.model_class == PhraseType:
                    return 'attributes__advpattributes__reals__in'
                if model == ComparAttributes and child_form.model_class == PhraseType:
                    return 'attributes__lexphrasetypeattributes__lexcomparattributes__lexes__in'
                if model == FixedAttributes and child_form.model_class == PhraseType:
                    return 'attributes__fixedattributes__phrase__in'
                print(model, child_form.model_class)
                raise KeyError(type(child_form))
        
        
        AttributesForm.base_fields[cls.unique_name('negated', n)] = SwitchField(_('Zaneguj'), css_class='negate-switch')
        for field, name in all_fields:
            #print('***', name, field.name, type(field))
            if field.name == 'reals':
                queryset = None
                if model == XPAttributes:
                    # choice only from phrase types that are realisations of some XP
                    queryset = PhraseTypeModel.objects.filter(main_phrase_types__xpattributes__isnull=False).distinct()
                if model == AdvPAttributes:
                    # choice only from phrase types that are realisations of some AdvP
                    queryset = PhraseTypeModel.objects.filter(main_phrase_types__advpattributes__isnull=False).distinct()
                form_field = PhraseTypeFilter(queryset=queryset, help_text=_('Realizacja składniowa frazy.'))
            elif field.name == 'lexes':
                form_field = PhraseTypeFilter(
                    queryset=PhraseTypeModel.objects.filter(main_phrase_types__lex_phrases__lexcomparattributes__isnull=False).distinct(),
                    help_text=_('Fraza składowa zleksykalizowanej konstrukcji porównawczej.'), lex=True)
            elif field.name == 'lex':
                form_field = PhraseTypeFilter(help_text=_('Fraza zleksykalizowana.'))
            elif field.name == 'phrase':
                form_field = PhraseTypeFilter(
                    queryset=PhraseTypeModel.objects.filter(main_phrase_types__fixedattributes__isnull=False).distinct(),
                    help_text=_('Typ składniowy frazy zleksykalizowanej.'))
            elif type(field) == CharField:
                # TODO other autocompletes?
                autocomplete = 'fixed' if field.name == 'text' else None
                form_field = RegexFilter(
                    label=polish_strings.PHRASE_ATTRIBUTE().get(field.name, field.name),
                    lookup='attributes__{}attributes__{}'.format(phrase_type, field.name),
                    max_length=200,
                    autocomplete=autocomplete,
                )
            else:
                lex_attr = name.startswith('lex')
                queryset_q = Q(('{}{}attributes__isnull'.format('lex' if lex_attr else '', phrase_type), False))
                queryset = type(field.related_model()).objects.filter(queryset_q).distinct()
                form_field = ModelMultipleChoiceFilter(
                    label=polish_strings.PHRASE_ATTRIBUTE().get(field.name, field.name),
                    queryset=queryset,
                    key='name',
                    human_values=polish_strings.PHRASE_ATTRIBUTE_VALUE(),
                    checkboxes=(len(queryset) <= 8),
                    lookup='{}attributes__{}{}attributes__{}'.format(
                        'lexicalized_phrase__' if lex_phrase and not lex_attr else '',
                        'lexphrasetypeattributes__lex' if lex_attr else '',
                        phrase_type,
                        field.name,
                    ),
                )
            AttributesForm.base_fields[cls.unique_name(name, n)] = form_field
        
        return AttributesForm
    
    @classmethod    
    def get_form(cls, phrase_type, unique_number=None, *args, **kwargs):
        unique_number = cls.unique_number() if unique_number is None else unique_number
        lex = phrase_type.startswith('lex')
        phrase_type = phrase_type[3:] if lex else phrase_type
        form_class = None
        if phrase_type in attrs_helpers:
            helper = attrs_helpers[phrase_type]
            attrs_cls, lex_attrs_cls = helper.attrs_cls, helper.lex_attrs_cls
            if lex:
                assert(lex_attrs_cls is not None)
                form_class = cls.make_form_class(unique_number, attrs_cls, lex_attrs_cls, phrase_type)
            else:
                form_class = cls.make_form_class(unique_number, attrs_cls, None, phrase_type)
        if form_class is None:
            form_class = cls.make_form_class(unique_number, EmptyAttributes, None, phrase_type)
        return form_class(*args, **kwargs)