SGJP / Kuznia

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

from django.db.models import *
from django.contrib.auth.models import User, Permission
from common.util import no_history, GroupDict
from accounts.util import users_with_perm


class NotDeletedManager(Manager):
    use_for_related_field = True

    def get_query_set(self):
        return super(NotDeletedManager, self).get_query_set().filter(
            deleted=False)


class LexemeNotDeletedManager(Manager):
    use_for_related_field = True

    def get_query_set(self):
        return super(
            LexemeNotDeletedManager, self).get_query_set().filter(
            lexeme__deleted=False)


class LexicalClass(Model):
    symbol = CharField(primary_key=True, max_length=16, db_column='czm')

    def __unicode__(self):
        return self.symbol

    class Meta:
        db_table = 'czescimowy'


class PartOfSpeech(Model):
    symbol = CharField(primary_key=True, max_length=16, db_column='pos')
    lexical_class = ForeignKey(LexicalClass, db_column='czm')
    full_name = CharField(max_length=128, db_column='nazwa')
    index = IntegerField()
    color_scheme = IntegerField()

    def __unicode__(self):
        return self.symbol

    class Meta:
        db_table = 'klasygramatyczne'
        ordering = ['index']


class QualifierExclusionClass(Model):
    name = CharField(
        unique=True, max_length=64, db_column='nazwa', verbose_name=u'nazwa')
    vocabulary = ForeignKey(
        'Vocabulary', db_column='slownik', verbose_name=u'słownik')

    def __unicode__(self):
        return self.name

    class Meta:
        db_table = 'klasy_wykluczania'


def get_exclusion_classes():
    exclusion_classes = {}
    for ec in QualifierExclusionClass.objects.all():
        qualifiers = ec.qualifier_set.all()
        if qualifiers:
            q_list = [q.pk for q in qualifiers]
            exclusion_classes[ec.pk] = q_list
    return exclusion_classes


# kwalifikatory dla leksemów, odmian,
# zakonczen i form wyjatkowych
class Qualifier(Model):
    label = CharField(max_length=64, db_column='kwal', verbose_name=u'nazwa')
    vocabulary = ForeignKey(
        'Vocabulary', db_column='slownik', verbose_name=u'słownik',
        related_name='qualifiers')
    exclusion_class = ForeignKey(
        QualifierExclusionClass, db_column='klasa', null=True, blank=True,
        verbose_name=u'klasa wykluczania')
    deleted = BooleanField(db_column='usuniety', default=False)

    objects = NotDeletedManager()
    all_objects = Manager()

    def is_empty(self):
        return not (
            self.lexeme_set.exists() or
            self.ending_set.exists() or
            self.lexemeinflectionpattern_set.exists())

    def set_for(self, something, add):
        if add:
            if self.exclusion_class:
                qualifiers = (something.qualifiers.all() &
                              self.exclusion_class.qualifier_set.all())
                if qualifiers.count() > 0 and list(qualifiers) != [self]:
                    return
            something.qualifiers.add(self) #add
        else:
            something.qualifiers.remove(self) #add

    def __unicode__(self):
        #return u'%s (%s)' % (self.label, self.vocabulary.id)
        return self.label

    class Meta:
        unique_together = ('label', 'vocabulary')
        db_table = 'kwalifikatory'
        ordering = ['label']


def visible_qualifiers(user):
    return Qualifier.objects.filter(vocabulary__in=visible_vocabularies(user))


def editable_qualifiers(user):
    return Qualifier.objects.filter(vocabulary__in=editable_vocabularies(user))


class Classification(Model):
    name = CharField(
        unique=True, max_length=64, db_column='nazwa',
        verbose_name=u'nazwa klasyfikacji')
    parts_of_speech = ManyToManyField(PartOfSpeech)

    def value_tree(self):
        parts = []
        all_values = self.values.select_related('parent_node') \
            .prefetch_related('child_nodes')
        for v in all_values:
            if v.parent_node is None:
                parts.append(v.subtree(all_values))
        return parts

    def make_choices(self):
        return make_choices(self.value_tree())

    def __unicode__(self):
        return self.name

    class Meta:
        db_table = 'klasyfikacje'


def make_choices(tree):
    choices = []
    for value, subtree in tree:
        choices.append((value.pk, value.label))
        subchoices = make_choices(subtree)
        choices += [(pk, u'    ' + label) for (pk, label) in
            subchoices] #  
    return choices


class ClassificationValue(Model):
    label = CharField(
        unique=True, max_length=64, db_column='nazwa',
        verbose_name=u'nazwa wartości')
    classification = ForeignKey(Classification, db_column='klas_id',
        related_name='values')
    parent_node = ForeignKey(
        'self', db_column='rodzic', null=True, blank=True,
        verbose_name=u'rodzic wartości', related_name='child_nodes')
    lexemes = ManyToManyField('Lexeme', blank=True, through='LexemeCV')
    deleted = BooleanField(db_column='usunieta', default=False)

    objects = NotDeletedManager()
    all_objects = Manager()

    def subtree(self, all_values):
        subtrees = []
        for child in all_values:
            if child in self.child_nodes.all():
                subtrees.append(child.subtree(all_values))
        return self, subtrees

    def is_empty(self):
        return not self.lexemes.exists()

    def add_lexeme(self, lexeme):
        LexemeCV.objects.get_or_create(lexeme=lexeme, classification_value=self)

    def remove_lexeme(self, lexeme):
        LexemeCV.objects.filter(lexeme=lexeme,
            classification_value=self).delete()

    def __unicode__(self):
        return self.label

    class Meta:
        db_table = 'wartosci_klasyfikacji'


class LexemeCV(Model):
    lexeme = ForeignKey('Lexeme')
    classification_value = ForeignKey('ClassificationValue')

    class Meta:
        unique_together = ['lexeme', 'classification_value']


class BaseFormLabel(Model):
    symbol = CharField(max_length=32, blank=True, db_column='efobaz')

    def __unicode__(self):
        return self.symbol

    class Meta:
        db_table = 'efobazy'


class InflectionCharacteristic(Model):
    symbol = CharField(max_length=16, blank=True, db_column='charfl')
    part_of_speech = ForeignKey(PartOfSpeech, db_column='pos')
    basic_form_label = ForeignKey(BaseFormLabel, db_column='efobaz')

    def __unicode__(self):
        return '%s:%s' % (self.symbol, self.part_of_speech.symbol)

    class Meta:
        db_table = 'charfle'
        unique_together = ('symbol', 'part_of_speech')


class PatternType(Model):
    lexical_class = ForeignKey(
        LexicalClass, db_column='czm', verbose_name=u'cz. mowy')
    # typ wzoru (np. dla rzeczowników:
    # odmiana męska, żeńska lub nijaka)
    symbol = CharField(
        max_length=32, blank=True, db_column='wtyp', verbose_name=u'typ wzoru')

    # TODO to powinno być raczej w bazie
    def base_form_labels(self):
        bfl_ids = set(self.tabletemplate_set.distinct()
        .values_list('cell__base_form_label', flat=True))
        # prowizorka ze względu na wzór 0000
        bfl_ids |= set(self.pattern_set.distinct()
        .values_list('endings__base_form_label', flat=True))
        return BaseFormLabel.objects.filter(pk__in=bfl_ids)

    def __unicode__(self):
        return '%s (%s)' % (self.symbol, self.lexical_class.symbol)

    class Meta:
        db_table = 'typywzorow'


class Pattern(Model):
    PATTERN_STATUS_CHOICES = (
    # (<symbol>, u'<opis>'),
    )

    # kiedyś trzeba zrobić porządek w nazwach.
    name = CharField(
        max_length=32, unique=True, db_column='w_id', verbose_name=u'nazwa')
    type = ForeignKey(PatternType, db_column='typ')
    # rdzeń przykładowej formy hasłowej
    example = CharField(max_length=64, db_column='przyklad',
        verbose_name=u'przyklad')
    # zakończenie formy podstawowej (uwaga: w zasadzie tylko dla prezentacji
    # wzoru, rdzenie w Odmieniasie trzeba tworzyć uważniej, wiedząc, która forma
    # jest hasłowa dla danego charfla)
    basic_form_ending = CharField(
        max_length=32, db_column='zakp', blank=True,
        verbose_name=u'zakończenie formy podstawowej')
    # np. "chwilowo nieużywany, ale trzymamy, bo wymyśliliśmy"
    status = CharField(
        max_length=8, choices=PATTERN_STATUS_CHOICES, verbose_name=u'status')
    comment = TextField(blank=True, db_column='komentarz',
        verbose_name=u'komentarz')

    def ending_set(self, subroot='', tag_prefix=None):
        endings = self.endings
        if tag_prefix:
            endings = endings.filter(
                base_form_label__symbol__startswith=tag_prefix)
        return set(subroot + e for e in
            endings.values_list('string', flat=True))

    def get_basic_form_ending(self, inflection_characteristic):
        return self.endings.filter(
            base_form_label=inflection_characteristic.basic_form_label)[
            0].string

    def __unicode__(self):
        return self.name

    class Meta:
        db_table = 'wzory'
        ordering = ['name']
        permissions = (
            ('view_pattern', u'Może oglądać wzory'),
        )


def prepare_table(table):
    for row in table:
        for cell in row:
            if type(cell) == dict and 'forms' in cell:
                cell['forms'].sort()
                seen_forms = []
                unique_forms = []
                for form in cell['forms']:
                    if form[1] not in seen_forms:
                        seen_forms.append(form[1])
                        unique_forms.append(form)
                cell['forms'] = [{'form': form, 'qualifiers': qualifiers}
                    for (key, form, qualifiers) in unique_forms]
            elif type(cell) == dict and 'label' in cell:
                seen_labels = []

                def new(label):
                    new = label not in seen_labels
                    seen_labels.append(label)
                    return new

                cell['label'] = filter(new, cell['label'])


# zakonczenie formy bazowej
class Ending(Model):
    pattern = ForeignKey(Pattern, related_name='endings', db_column='w_id')
    # etykieta (tag) formy bazowej
    base_form_label = ForeignKey(BaseFormLabel, db_column='efobaz')
    # kolejnosc dla zakonczen o tym samym base_form_label
    index = IntegerField(db_column='zind')
    string = CharField(max_length=16, db_column='zak', blank=True)
    qualifiers = ManyToManyField(
        Qualifier, blank=True, db_table='kwalifikatory_zakonczen')

    def editable_vocabularies(self, user):
        return editable_vocabularies(user)

    def __unicode__(self):
        return '%s : %s : %s' % (
            self.pattern.name, self.string, self.base_form_label)

    class Meta:
        db_table = 'zakonczenia'
        unique_together = ('pattern', 'base_form_label', 'index')
        ordering = ['index']


class Lexeme(Model):
    STATUS_CHOICES = (
        ('cand', u'kandydat'),
        ('desc', u'wprowadzony'),
        ('conf', u'zatwierdzony'),
    )

    entry = CharField(max_length=64, db_column='haslo', db_index=True,
        verbose_name=u'hasło', blank=True) # dla nowo utworzonych
    # pozostałość historyczna:
    entry_suffix = CharField(blank=True, max_length=16, db_column='haslosuf',
        verbose_name=u'sufiks hasła')
    gloss = TextField(blank=True, db_column='glosa', verbose_name=u'glosa')
    note = TextField(blank=True, db_column='nota', verbose_name=u'nota')
    pronunciation = TextField(
        blank=True, db_column='wymowa', verbose_name=u'wymowa')
    valence = TextField(blank=True, verbose_name=u'łączliwość')
    homonym_number = IntegerField(db_column='hom', default=1)
    part_of_speech = ForeignKey(
        PartOfSpeech, db_column='pos', verbose_name=u'cz. mowy')
    owner_vocabulary = ForeignKey(
        'Vocabulary', db_column='slownik', related_name='owned_lexemes')
    source = CharField(max_length=32, blank=True, db_column='zrodlo')
    status = CharField(max_length=8, db_column='status', choices=STATUS_CHOICES)
    qualifiers = ManyToManyField(
        Qualifier, blank=True, db_table='kwalifikatory_leksemow')
    comment = TextField(blank=True, db_column='komentarz',
        verbose_name=u'komentarz')
    last_modified = DateTimeField(auto_now=True, db_column='data_modyfikacji')
    # osoba, ktora ostatnia zmieniala opis leksemu
    responsible = ForeignKey(
        User, blank=True, null=True, db_column='odpowiedzialny')
    patterns = ManyToManyField(Pattern, through='LexemeInflectionPattern')
    deleted = BooleanField(db_column='usuniety', default=False)

    objects = NotDeletedManager()
    all_objects = Manager()

    def inflection_tables(self, variant, qualifiers=None):
        lips = self.lexemeinflectionpattern_set.order_by('index') \
            .select_related('inflection_characteristic', 'pattern')
        ics = GroupDict()
        for lip in lips:
            ic = lip.inflection_characteristic
            ics.add(ic, lip.pattern.name)
        return [(ic, patterns,
        self.inflection_table(variant, ic, qualifiers=qualifiers))
            for ic, patterns in ics.iteritems()]

    def inflection_table(self, variant, inflection_characteristic,
                         qualifiers=None):
        lips = self.lexemeinflectionpattern_set.filter(
            inflection_characteristic=inflection_characteristic) \
            .prefetch_related('qualifiers').select_related(
            'pattern__type', 'inflection_characteristic')
        tables = [lip.inflection_table(variant, qualifiers=qualifiers)
            for lip in lips]
        table1 = tables[0]
        for table2 in tables[1:]:
            for row1, row2 in zip(table1, table2):
                for cell1, cell2 in zip(row1, row2):
                    if cell1['type'] == 'forms':
                        assert cell2['type'] in ('forms', 'empty')
                        if cell2['type'] == 'forms':
                            cell1['forms'].extend(cell2['forms'])
                    elif cell1['type'] == 'label':
                        assert cell2['type'] in ('label', 'empty')
                        if cell2['type'] == 'label':
                            cell1['label'].extend(cell2['label'])
                    elif cell1['type'] == 'empty':
                        cell1.update(cell2)
        prepare_table(table1)
        return table1

    def refresh_forms(self):
        self.lexemeform_set.all().delete()
        for form in self.all_forms():
            self.lexemeform_set.add(LexemeForm(form=form))

    def all_forms(self, affixes=True, label_filter=None, variant='1'):
        forms = set()
        for lip in self.lexemeinflectionpattern_set.all():
            forms |= set(
                form for (indexes, form, qualifiers)
                    in lip.all_forms(
                    affixes=affixes, label_filter=label_filter,
                    variant=variant))
        return forms

    def get_root(self, pattern, inflection_characteristic):
        basic_form = self.entry
        pos = self.part_of_speech.symbol
        return get_root(basic_form, pos, pattern, inflection_characteristic)

    def visible_vocabularies(self, user):
        return visible_vocabularies(user) & self.vocabularies.all()

    def editable_vocabularies(self, user):
        return editable_vocabularies(user) & self.vocabularies.all()

    def change_owner(self, new_owner):
        old_owner = self.owner_vocabulary
        new_owner.add_lexeme(self)
        self.owner_vocabulary = new_owner
        old_owner.remove_lexeme(self)

    def classification_values(self, classification):
        return self.classificationvalue_set.filter(
            classification=classification)

    def lip_data(self, lips=None):
        if lips is None:
            lips = self.lexemeinflectionpattern_set.all()
        patterns = []
        ics = []
        for lip in lips:
            if patterns == [] or lip.pattern.name != patterns[-1]:
                patterns.append(lip.pattern.name)
            if ics == [] or lip.inflection_characteristic.symbol != ics[-1]:
                ics.append(lip.inflection_characteristic.symbol)
        patterns = '/'.join(patterns)
        ics = '/'.join(ics)
        return {'patterns': patterns, 'inflection_characteristics': ics}

    def fix_homonym_number(self):
        homonym_numbers = (Lexeme.objects.filter(
            entry=self.entry, part_of_speech=self.part_of_speech)
        .exclude(pk=self.pk)).values_list('homonym_number',
            flat=True)
        for i in xrange(1, len(homonym_numbers) + 2):
            if i not in homonym_numbers:
                self.homonym_number = i
                break

    def attributes(self, part_of_speech=None, ics=None):
        if ics is None:
            lips = self.lexemeinflectionpattern_set.all()
            ics = tuple(lip.inflection_characteristic for lip in lips)
        pos = part_of_speech or self.part_of_speech
        attrs = LexemeAttribute.objects.all()
        attrs = attrs.filter(parts_of_speech=pos)
        attrs = (attrs.filter(inflection_characteristics__in=ics)
                 | attrs.filter(takes_ic=False))
        return attrs

    def attributes_values(self, part_of_speech=None, ics=None):
        for attr in self.attributes(part_of_speech, ics):
            yield (attr, self.attribute_value(attr))

    def attribute_value(self, attribute):
        if attribute.multiple:
            return attribute.values.filter(lexemes=self)
        else:
            try:
                return attribute.values.get(lexemes=self)
            except LexemeAttributeValue.DoesNotExist:
                return None

    def perm(self, user, action):
        if action == 'view':
            vocabs = self.vocabularies.all()
            return bool(vocabs & visible_vocabularies(user))
        elif action == 'change':
            priority = (not (self.responsible and
                             self.responsible.has_perm(
                                 'dictionary.lexeme_priority'))
            or user.has_perm('dictionary.lexeme_priority'))
            edit_vocab = self.owner_vocabulary in editable_vocabularies(user)
            return edit_vocab and priority

    def undelete(self):
        no_history()
        self.deleted = False
        self.save()
        self.history_set.get(column_name='usuniety').delete()

    def sgjp_info(self):
        commonness = Classification.objects.get(name=u'pospolitość')
        commonness_labels = list(self.classification_values(
            commonness).values_list('label', flat=True))
        if commonness_labels == ['pospolita']:
            commonness_labels = []
        return {
            'SJPDor': bool(self.vocabularies.filter(id='SJPDor')),
            'commonness': commonness_labels,
            'qualifiers': self.qualifiers.values_list('label', flat=True),
        }

    def __unicode__(self):
        return '%s (%s)' % (self.entry, self.part_of_speech.symbol)

    class Meta:
        db_table = 'leksemy'
        permissions = (
            ('view_lexeme', u'Może oglądać leksemy'),
            ('view_all_lexemes', u'Może oglądać wszystkie leksemy'),
            ('lexeme_priority', u'Ważniejszy głos przy modyfikowaniu leksemów'),
            ('export_lexemes', u'Może eksportować leksemy'),
        )


def filter_visible(lexemes, user):
    vocab_ids = [v.id for v in visible_vocabularies(user)]
    # uniknięcie podzapytania *bardzo* zwiększa wydajność!
    return lexemes.filter(vocabularies__id__in=vocab_ids).distinct()


def get_root(basic_form, pos, pattern, ic, use_pattern_ending=False):
    bfl = ic.basic_form_label
    basic_endings = pattern.endings.filter(base_form_label=bfl)
    ends = []
    if use_pattern_ending:
        ends.append(pattern.basic_form_ending)
    if basic_endings:
        ends += [e.string for e in pattern.endings.filter(base_form_label=bfl)]
    if pos == 'ger':
        ends = [end + 'ie' for end in ends]
    if pos == 'pact':
        ends = [end + 'cy' for end in ends]
    if pos in ('ppas', 'appas'):
        ends = [end + 'y' for end in ends]
    good_ends = [end for end in ends if basic_form.endswith(end)]
    assert len(set(good_ends)) <= 1 # inaczej rdzeń nie jest jednoznaczny
    if good_ends:
        return basic_form[:len(basic_form) - len(good_ends[0])]
    else:
        if not use_pattern_ending:
            return get_root(basic_form, pos, pattern, ic,
                use_pattern_ending=True)
        else:
            return None


class LexemeAttribute(Model):
    name = CharField(max_length=32)
    closed = BooleanField() # czy jest zamknięta lista wartości
    multiple = BooleanField()
    required = BooleanField()
    parts_of_speech = ManyToManyField(PartOfSpeech)
    takes_ic = BooleanField()
    inflection_characteristics = ManyToManyField(
        InflectionCharacteristic, blank=True)

    def __unicode__(self):
        return self.name


class LexemeAttributeValue(Model):
    value = CharField(max_length=32, blank=True)
    display_value = CharField(max_length=32, blank=True)
    attribute = ForeignKey(LexemeAttribute, related_name='values')
    lexemes = ManyToManyField(Lexeme, blank=True, through='LexemeAV')

    def add_lexeme(self, lexeme):
        LexemeAV.objects.get_or_create(lexeme=lexeme, attribute_value=self)

    def remove_lexeme(self, lexeme):
        LexemeAV.objects.filter(lexeme=lexeme, attribute_value=self).delete()

    def __unicode__(self):
        return self.value

    class Meta:
        ordering = ['value']


class LexemeAV(Model):
    lexeme = ForeignKey('Lexeme')
    attribute_value = ForeignKey('LexemeAttributeValue')

    class Meta:
        unique_together = ['lexeme', 'attribute_value']


class LexemeInflectionPattern(Model):
    lexeme = ForeignKey(Lexeme, db_column='l_id')
    index = IntegerField(db_column='oind')
    pattern = ForeignKey(Pattern, db_column='w_id', verbose_name=u'wzór')
    # charakterystyka fleksyjna (rodzaj, aspekt)
    inflection_characteristic = ForeignKey(
        InflectionCharacteristic, db_column='charfl',
        verbose_name=u'char. fleks.')
    # rdzen odmiany przy zastosowaniu danego wzoru
    root = CharField(max_length=64, db_column='rdzen')
    # tu mozna sygnalizowac, ze dany sposob
    # odmiany leksemu jest gorszy, przestarzaly, etc
    qualifiers = ManyToManyField(
        Qualifier, blank=True, db_table='kwalifikatory_odmieniasiow')

    objects = LexemeNotDeletedManager()
    all_objects = Manager()

    def table_template(self, variant):
        return TableTemplate.objects.get(
            variant=variant, pattern_type=self.pattern.type,
            inflection_characteristic=self.inflection_characteristic)

    def cells(self, variant='1'):
        tt = self.table_template(variant)
        return tt.cell_set.select_related('base_form_label', 'tablecell')

    def base_endings(self, label_filter=None):
        bfls = self.pattern.type.base_form_labels()
        endings = Ending.objects.filter(
            base_form_label__in=bfls, pattern=self.pattern) \
            .select_related('base_form_label').prefetch_related('qualifiers')
        if label_filter is not None:
            endings = endings.filter(
                base_form_label__symbol__regex=label_filter)
        bfl_dict = GroupDict((bfl, []) for bfl in bfls)
        for ending in endings:
            bfl_dict.add(ending.base_form_label, ending)
        return bfl_dict

    def inflection_table(self, variant, separated=False, qualifiers=None,
                         edit_view=False):
        tt = self.table_template(variant)
        cells = self.cells(variant)
        headers = tt.tableheader_set.all()
        rows = set()
        last_col = 0
        for cell in cells:
            rows.add(cell.tablecell.row)
            col = cell.tablecell.col + cell.tablecell.colspan - 1
            if col > last_col:
                last_col = col
        for header in headers:
            rows.add(header.row)
            col = header.col + header.colspan - 1
            if col > last_col:
                last_col = col
        table = [[{'type': 'empty'}
            for i in xrange(last_col)] for j in xrange(len(rows))]
        rows = sorted(rows)
        # słownik: nr rzędu w bazie -> rzeczywisty numer rzędu
        row_translate = dict(zip(rows, xrange(len(rows))))
        base_endings = self.base_endings()
        for cell in cells:
            x = cell.tablecell.col - 1
            y = row_translate[cell.tablecell.row]
            table_cell = table[y][x]
            assert table_cell['type'] != 'span'
            separator = u'·' if separated else u''
            forms = self.forms(
                cell, base_endings, separator=separator, qualifiers=qualifiers,
                edit_view=edit_view)
            if not forms:
                continue
            if table_cell['type'] == 'empty':
                table[y][x] = {
                    'type': 'forms',
                    'forms': forms,
                    'rowspan': cell.tablecell.rowspan,
                    'colspan': cell.tablecell.colspan,
                }
                for i in xrange(cell.tablecell.colspan):
                    for j in xrange(cell.tablecell.rowspan):
                        if (i, j) != (0, 0):
                            assert table[y + j][x + i]['type'] == 'empty'
                            table[y + j][x + i]['type'] = 'span'
            else:
                assert cell.tablecell.rowspan == table_cell['rowspan']
                assert cell.tablecell.colspan == table_cell['colspan']
                table_cell['forms'] += forms
        for header in headers:
            x = header.col - 1
            y = row_translate[header.row]
            assert table[y][x]['type'] == 'empty'
            table[y][x] = {
                'type': 'label',
                'label': [header.label],
                'css_class': header.css_class,
                'rowspan': header.rowspan,
                'colspan': header.colspan,
            }
            for i in xrange(header.colspan):
                for j in xrange(header.rowspan):
                    if (i, j) != (0, 0):
                        assert table[y + j][x + i]['type'] == 'empty'
                        table[y + j][x + i]['type'] = 'span'
        return [row for row in table
            if not all(cell['type'] == 'empty' for cell in row)]

    def all_forms(self, separator='', affixes=True, label_filter=None,
                  variant='1', qualifiers=None):
        forms = []
        base_endings = self.base_endings(label_filter)
        for cell in self.cells(variant=variant):
            forms += self.forms(
                cell, base_endings, separator, affixes, qualifiers=qualifiers)
        return forms

    def forms(self, cell, base_endings, separator='',
              affixes=True, qualifiers=None, edit_view=False):
        if qualifiers:
            qualifiers_set = set(qualifiers)

        def filter_quals(quals):
            if not qualifiers:
                return set(quals)
            else:
                return set(quals) & qualifiers_set

        endings = base_endings[cell.base_form_label]
        if not edit_view:
            #l_qual = set(self.lexeme.qualifiers.all()) & set(qualifiers)
            lip_qual = filter_quals(self.qualifiers.all())
        forms = [
            (
                (cell.index, self.index, ending.index),
                (
                    cell.prefix + self.root + separator + ending.string + cell.suffix
                    if affixes else self.root + separator + ending.string),
                #+ '#' + cell.base_form_label.symbol,
                combine_qualifiers(lip_qual,
                    filter_quals(ending.qualifiers.all()))
                if not edit_view else filter_quals(ending.qualifiers.all()),
            )
            for ending in endings
        ]
        return forms

    def editable_vocabularies(self, user):
        return self.lexeme.editable_vocabularies(user)

    def __unicode__(self):
        return '%s : %s/%s : %s' % (
            self.lexeme.entry,
            self.pattern.name,
            self.pattern.type.symbol,
            self.inflection_characteristic.symbol,
        )

    class Meta:
        db_table = 'odmieniasie'
        unique_together = ('lexeme', 'index')
        ordering = ['index']


def all_forms(pattern, ic, pos, base, variant='1', affixes=True):
    root = get_root(base, pos, pattern, ic)
    tt = TableTemplate.objects.get(
        variant=variant, pattern_type=pattern.type,
        inflection_characteristic=ic)
    forms = set()
    for cell in tt.cell_set.all():
        endings = Ending.objects.filter(
            base_form_label=cell.base_form_label, pattern=pattern)
        forms |= set(
            cell.prefix + root + ending.string + cell.suffix
            if affixes else root + ending.string
                for ending in endings)
    return forms


def combine_qualifiers(lip_qualifiers, e_qualifiers):
    #qualifiers = set(l_qualifiers)
    qualifiers = set()
    for q in list(lip_qualifiers) + list(e_qualifiers):
        if q.exclusion_class:
            excluded = set(q.exclusion_class.qualifier_set.all())
            qualifiers -= excluded
        qualifiers.add(q)
    return qualifiers


def filter_visible_lips(lips, user):
    vocabs = visible_vocabularies(user)
    return lips.filter(lexeme__vocabularies__in=vocabs).distinct()


# Sluzy do doczepienia flag do poszczegolnych form
# poszczegolnych leksemow
#class UncommonForm(Model):
#  lexeme_inflection_pattern = ForeignKey(
#    LexemeInflectionPattern, db_column='o_id')
#  #raczej tag, ale z jakiego tagsetu ?
#  #base_form_label/tag =
#  qualifiers = ManyToManyField(
#    Qualifier, blank=True, db_table='kwalifikatory_form')
#
#  class Meta:
#    db_table = 'formy_wyjatkowe'
#    unique_together = (
#      'lexeme_inflection_pattern',
#      'tag',
#    )


class Vocabulary(Model):
    id = CharField(max_length=64, primary_key=True, db_column='slownik')
    lexemes = ManyToManyField(Lexeme, blank=True, through='LexemeAssociation',
        related_name='vocabularies')
    managers = ManyToManyField(User, blank=True,
        related_name='managed_vocabularies')
    viewers = ManyToManyField(User, blank=True,
        related_name='visible_vocabularies')
    editors = ManyToManyField(User, blank=True,
        related_name='editable_vocabularies')
    # bardziej by pasowało w Classification, ale już trudno
    classifications = ManyToManyField(Classification, blank=True,
        related_name='vocabularies')

    def owned_lexemes_pk(self):
        return self.owned_lexemes.values_list('pk', flat=True)

    def all_viewers(self):
        perm = Permission.objects.get(codename='view_all_lexemes')
        return self.viewers.all().distinct() | users_with_perm(perm)

    def all_editors(self):
        return self.editors.all()

    def all_managers(self):
        perm = Permission.objects.get(codename='manage_all_vocabularies')
        return self.managers.all().distinct() | users_with_perm(perm)

    def add_lexeme(self, lexeme):
        la, created = LexemeAssociation.objects.get_or_create(
            lexeme=lexeme, vocabulary=self)
        return created

    def remove_lexeme(self, lexeme):
        assert self != lexeme.owner_vocabulary
        LexemeAssociation.objects.filter(lexeme=lexeme,
            vocabulary=self).delete()

    def set_lexeme(self, lexeme, add):
        if add:
            self.add_lexeme(lexeme)
        else:
            self.remove_lexeme(lexeme)

    def __unicode__(self):
        return self.id

    class Meta:
        db_table = 'slowniki'
        permissions = (
            ('manage_vocabulary', u'Może zarządzać słownikami'),
            ('manage_all_vocabularies', u'Zarządza wszystkimi słownikami'),
        )


def visible_vocabularies(user):
    if user.has_perm('dictionary.view_all_lexemes'):
        return Vocabulary.objects.all()
    else:
        return user.visible_vocabularies.all()


def editable_vocabularies(user):
    return user.editable_vocabularies.all()


def readonly_vocabularies(user):
    return visible_vocabularies(user).exclude(
        id__in=editable_vocabularies(user))


def managed_vocabularies(user):
    if user.has_perm('dictionary.manage_all_vocabularies'):
        return Vocabulary.objects.all()
    else:
        return user.managed_vocabularies.all()


class LexemeAssociation(Model):
    lexeme = ForeignKey(Lexeme, db_column='l_id')
    vocabulary = ForeignKey(Vocabulary, db_column='slownik')

    objects = LexemeNotDeletedManager()
    all_objects = Manager()

    def __unicode__(self):
        return '%s/%s' % (self.lexeme.entry, self.vocabulary.id)

    class Meta:
        db_table = 'leksemy_w_slownikach'
        unique_together = ['lexeme', 'vocabulary']


class CrossReferenceType(Model):
    symbol = CharField(max_length=10, db_column='typods')
    desc = CharField(max_length=40, db_column='naglowek')
    index = IntegerField(db_column='kolejnosc')
    from_pos = ForeignKey(
        PartOfSpeech, db_column='pos1', related_name='crtype_to')
    to_pos = ForeignKey(
        PartOfSpeech, db_column='pos2', related_name='crtype_from')
    #reverse = ForeignKey('self', db_column='odwrotny')

    def __unicode__(self):
        return self.symbol

    class Meta:
        db_table = 'typyodsylaczy'


class CRManager(Manager):
    use_for_related_field = True

    def get_query_set(self):
        return super(CRManager, self).get_query_set().filter(
            from_lexeme__deleted=False, to_lexeme__deleted=False)


class CrossReference(Model):
    from_lexeme = ForeignKey(Lexeme, db_column='l_id_od',
        related_name='refs_to')
    to_lexeme = ForeignKey(
        Lexeme, db_column='l_id_do', related_name='refs_from',
        verbose_name=u'nr docelowy')
    type = ForeignKey(
        CrossReferenceType, db_column='typods_id', verbose_name=u'typ')

    objects = CRManager()
    all_objects = Manager()

    def __unicode__(self):
        return '%s: %s -> %s' % (
            self.type.symbol, self.from_lexeme.entry, self.to_lexeme.entry)

    class Meta:
        db_table = 'odsylacze'


class Variant(Model):
    id = CharField(max_length=32, primary_key=True, db_column='wariant')

    def __unicode__(self):
        return self.id

    class Meta:
        db_table = 'warianty'


class TableTemplate(Model):
    variant = ForeignKey(Variant, db_column='wariant')
    pattern_type = ForeignKey(PatternType, db_column='wtyp')
    inflection_characteristic = ForeignKey(
        InflectionCharacteristic, db_column='charfl')

    def __unicode__(self):
        return '%s : %s : %s : %s' % (
            self.variant, self.inflection_characteristic.part_of_speech,
            self.pattern_type.symbol, self.inflection_characteristic)

    class Meta:
        db_table = 'szablony_tabel'

#klatka paradygmatu
#(element szablonu tabelki odmiany)
class Cell(Model):
    table_template = ForeignKey(TableTemplate, db_column='st_id')
    #etykieta formy bazowej
    base_form_label = ForeignKey(BaseFormLabel, db_column='efobaz')
    #znacznik docelowego tagsetu
    tag = TextField(blank=True, db_column='tag')
    prefix = CharField(max_length=20, blank=True, db_column='prefiks')
    suffix = CharField(max_length=20, blank=True, db_column='sufiks')
    #kolejnosc klatki w paradygmacie
    index = IntegerField(db_column='kind')

    def __unicode__(self):
        return '%s [%s] %s- -%s {%s}' % (
            self.table_template, self.base_form_label, self.prefix, self.suffix,
            self.tag)

    class Meta:
        db_table = 'klatki'
        ordering = ['index']


class TableCell(Model):
    cell = OneToOneField(Cell, db_column='k_id')
    row = IntegerField()
    col = IntegerField()
    rowspan = IntegerField()
    colspan = IntegerField()

    def __unicode__(self):
        return '%s [%s->%s,%s->%s]' % (
            self.cell, self.row, self.rowspan, self.col, self.colspan)

    class Meta:
        db_table = 'komorki_tabel'


class TableHeader(Model):
    table_template = ForeignKey(TableTemplate, db_column='st_id')
    row = IntegerField()
    col = IntegerField()
    rowspan = IntegerField()
    colspan = IntegerField()
    label = CharField(max_length=64, blank=True, db_column='nagl')
    css_class = CharField(max_length=8, db_column='styl')

    def __unicode__(self):
        return '%s (%s,%s) [%s]' % (
            self.label, self.row, self.col, self.css_class)

    class Meta:
        db_table = 'naglowki_tabel'


class NewTableTemplate(Model):
    name = TextField()
    variant = ForeignKey(Variant)
    parts_of_speech = ManyToManyField(PartOfSpeech)
    pattern_types = ManyToManyField(PatternType)
    attributes = ManyToManyField(LexemeAttribute)
    attribute_values = ManyToManyField(LexemeAttributeValue)


class NewCell(Model):
    table_template = ForeignKey(NewTableTemplate)
    base_form_label = ForeignKey(BaseFormLabel)
    prefix = CharField(max_length=20, blank=True)
    suffix = CharField(max_length=20, blank=True)
    parts_of_speech = ManyToManyField(PartOfSpeech)
    pattern_types = ManyToManyField(PatternType)
    inflection_characteristics = ManyToManyField(InflectionCharacteristic)
    attribute_values = ManyToManyField(LexemeAttributeValue)


class NewTableCell(Model):
    cell = ForeignKey(NewCell)
    pattern_types = ManyToManyField(PatternType)
    inflection_characteristics = ManyToManyField(InflectionCharacteristic)
    row = IntegerField()
    col = IntegerField()
    rowspan = IntegerField()
    colspan = IntegerField()
    index = IntegerField()


class NewExportCell(Model):
    cell = ForeignKey(Cell)
    pattern_types = ManyToManyField(PatternType)
    tag_template = TextField()


class NewTableHeader(Model):
    table_template = ForeignKey(NewTableTemplate)
    inflection_characteristics = ManyToManyField(InflectionCharacteristic)
    pattern_types = ManyToManyField(PatternType)
    attributes = ManyToManyField(LexemeAttribute)
    attribute_values = ManyToManyField(LexemeAttributeValue)
    row = IntegerField()
    col = IntegerField()
    rowspan = IntegerField()
    colspan = IntegerField()
    label = CharField(max_length=64, blank=True, db_column='nagl')
    css_class = CharField(max_length=8, db_column='styl')

# na szybko i brudno
class ParadygmatyWSJP(Model):
    wariant = CharField(max_length=4)
    typr = ForeignKey(PatternType, db_column='typr')
    charfl = ForeignKey(InflectionCharacteristic, db_column='charfl')
    podparad = CharField(max_length=4, blank=True)
    row = IntegerField()
    col = IntegerField()
    rowspan = IntegerField()
    colspan = IntegerField()
    efobaz = ForeignKey(BaseFormLabel, db_column='efobaz')
    morf = TextField()
    pref = CharField(max_length=20, blank=True)
    suf = CharField(max_length=20, blank=True)
    kskl = IntegerField()

    class Meta:
        db_table = 'paradygmatywsjp'


class LexemeForm(Model):
    lexeme = ForeignKey(Lexeme)
    form = CharField(max_length=128, db_index=True)

    objects = LexemeNotDeletedManager()
    all_objects = Manager()


class SavedFilter(Model):
    serialized_filter = TextField()
    name = CharField(max_length=64)
    user = ForeignKey(User)

    class Meta:
        unique_together = ('name', 'user')


class SavedExportData(Model):
    serialized_data = TextField()
    name = CharField(max_length=64, unique=True)

# model przeznaczony tylko do odczytu!
class History(Model):
    table_name = CharField(max_length=120, db_column='table_name_')
    column_name = CharField(max_length=120, db_column='column_name_',
        blank=True)
    timestamp = DateTimeField(db_column='timestamp_')
    user = ForeignKey(User, db_column='user_id_', db_index=True)
    old_value = TextField(db_column='old_value_', blank=True)
    new_value = TextField(db_column='new_value_', blank=True)
    lexeme = ForeignKey(
        Lexeme, db_column='lexeme_id_', null=True, blank=True, db_index=True)
    pattern = ForeignKey(
        Pattern, db_column='pattern_id_', null=True, blank=True, db_index=True)
    row_id = IntegerField(db_column='id_')
    operation = CharField(max_length=120, db_column='operation_')
    table_oid = IntegerField(db_column='table_oid_')
    column_ord = IntegerField(db_column='ordinal_position_of_column_')
    transaction_began = DateTimeField(db_column='transaction_began_')

    def __unicode__(self):
        return '%s %s.%s %s -> %s' % (
            self.operation, self.table_name, self.column_name,
            repr(self.old_value),
            repr(self.new_value))

    class Meta:
        db_table = 'history'


class InputLexeme(Model):
    entry = CharField(max_length=64, db_index=True)


class InputForm(Model):
    input_lexeme = ForeignKey(InputLexeme)
    form = CharField(max_length=64, db_index=True)
    #tag = TextField()