Walenty / ShellValier

import logging

from itertools import chain, combinations, product

from django.utils import translation
from django.utils.translation import gettext as _

from importer.Phrase import *
from importer.Global import get_current_entry

from .polish_strings import *
from .utils import *

class PhraseDescriptionError(Exception):
    pass

def powerset(iterable):
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))

def powerset_nonempty(iterable):
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(1, len(s) + 1))

# keeps the element order
def uniq_list(iterable):
    u = []
    for element in iterable:
        if element not in u:
            u.append(element)
    return u

def position_prop_description(prop):
    return POSITION_PROP()[prop]

def phrase_description2(phrase, position, negativity, lang, controller=None):
    curr_lang = translation.get_language()
    translation.activate(lang)
    function = position._function._value if position._function else None
    negativity = negativity.name if negativity else '_'
    try:
        desc = phrase_description(phrase, function, negativity, controller=controller)
    except:
        raise PhraseDescriptionError('couldn’t generate description: {}'.format(phrase))
    translation.activate(curr_lang)
    return desc

def phrase_description(phrase, function, negativity, desc_case='nom', inside_lex=False, controller=None):
    if str(phrase) in (
            # malowany -> ppas in in Morfeusz
            #'lex(adjp(agr),agr,agr,pos,malować,natr)',
            #'lex(compar(jak),lex(np(nom),sg,wół,natr),lex(prepnp(na,acc),pl,wrota,ratr1({lex(adjp(agr),agr,agr,pos,malować,natr)})),natr)',
            # oszalały -> adj in Morfeusz
            #'lex(compar(jak),lex(ppasp(agr),agr,agr,aff,oszaleć,natr),natr)',
            # OR
            #'lex(np(str),_,uwaga,ratr({adjp(agr)}+{or}))',
            #'lex(xp(mod[prepnp(z,gen)]),sg,góry,natr)', 'lex(np(str),_,uwaga,atr({adjp(agr)}+{or}))',
            # „jak” nie ma wśród modyfikacyj
            #'lex(cp(int[jak]),aff,dziękować,,atr)',
            # „na jakim świecie żyje” – element pytajny zagnieżdżony w prepnp
            #'lex(cp(int[jaki]),aff,żyć,,ratr1({lex(prepnp(na,loc),sg,świat,ratr1({lex(adjp(agr),agr,agr,pos,jaki,natr)}))}))',
            # „co” nie ma wśród modyfikacyj
            #'lex(xp(mod[cp(rel[co])]),aff,wyskoczyć,,ratr1(subj{lex(np(str),sg,koń,natr)}))',
            #'lex(cp(rel[co]),aff,XOR(przynieść,przynosić),,ratr(subj{lex(np(str),sg,ślina,natr)}+{lex(np(dat),_,XOR(ja,my,on,ty,wy),natr)}+{lex(prepnp(na,acc),_,język,natr)}))',
            #'lex(cp(rel[co]),_,XOR(przychodzić,przyjść),,ratr({lex(np(dat),_,XOR(ja,my,on,ty,wy),natr)}+{lex(prepnp(na,acc),sg,myśl,natr)}))',
            #'lex(np(str),sg,wszystko,ratr(subj{lex(np(str),sg,co,natr)}+{lex(cp(rel[co]),aff,być,,ratr1({lex(prepnp(w,loc),sg,moc,atr({lex(adjp(agr),agr,agr,pos,ludzki,natr)}))}))}))',
            #'lex(np(str),sg,wszystko,ratr(subj{lex(np(str),sg,co,natr)}+{lex(cp(rel[co]),aff,być,,ratr1({lex(prepnp(w,loc),sg,moc,atr({possp}))}))}))',
            #'lex(cp(rel[co]),aff,być,,ratr1({lex(prepnp(w,loc),sg,moc,atr({lex(adjp(agr),agr,agr,pos,ludzki,natr)}))}))',
            #'lex(cp(rel[co]),aff,być,,ratr1({lex(prepnp(w,loc),sg,moc,atr({possp}))}))',
            # „jakby” nie ma wśród modyfikacyj
            #'lex(xp(mod[cp(rel[jakby])]),aff,strzelić,,ratr({prepnp(w,acc)}+{lex(np(str),sg,XOR(grom,piorun),natr)}))',
            ):
        return '???'
    if str(phrase).startswith('lex'):
        return lex_phrase_description(phrase, function, negativity, desc_case=desc_case, controller=controller)
    return make_phrase_description(phrase, function, negativity, desc_case, inside_lex=inside_lex)

def get_phrase_type(lex_phrase):
    ptype = type(lex_phrase)
    if ptype == LexNP:
        return lex_phrase._np
    if ptype == LexNumP:
        return lex_phrase._nump
    if ptype == LexAdjP:
        return lex_phrase._adjp
    if ptype == LexPPasP:
        return lex_phrase._ppasp
    if ptype == LexPActP:
        return lex_phrase._pactp
    if ptype == LexPrepNP:
        return lex_phrase._prepnp
    if ptype == LexPrepGerP:
        return lex_phrase._prepgerp
    if ptype == LexPrepNumP:
        return lex_phrase._prepnump
    if ptype == LexPrepAdjP:
        return lex_phrase._prepadjp
    if ptype == LexPrepPPasP:
        return lex_phrase._prepppasp
    if ptype == LexInfP:
        return lex_phrase._infp
    if ptype == LexCP:
        return lex_phrase._cp
    if ptype == LexNCP:
        return lex_phrase._ncp
    if ptype == LexXP:
        return lex_phrase._xp
    if ptype == LexAdvP:
        return lex_phrase._advp
    if ptype == LexCompar:
        return lex_phrase._compar
    if ptype == LexQub:
        return lex_phrase._qub
    print(ptype)
    1/0

def postprocess_phraseologism(p):
    return p.replace(' ,', ',')

def lex_phrase_description(phrase, function, negativity, desc_case='nom', controller=None, controller_grammar=None):
    phrase2 = get_phrase_type(phrase)
    desc = make_phrase_description(phrase2, function, negativity, 'nom', inside_lex=True)
    phraseo = uniq_list(map(postprocess_phraseologism, make_phraseologisms(phrase, function, negativity, controller=controller, controller_grammar=controller_grammar)))
    return _('zleksykalizowana') + ' ' + desc + ' ' + _('postaci') + make_ul(map('<i>{}</i>'.format, phraseo))

def make_phrase_description(phrase, function, negativity, desc_case, inside_lex=False):
    ptype = type(phrase)
    if ptype == NP:
        case = phrase._case._value
        if function == 'subj' and case == 'str':
            case = 'str_subj'
        return make_inflected_string(NP_(), desc_case).format(case=CASE_FOR_NP()[case])
    if ptype == NumP:
        case = phrase._case._value
        return make_inflected_string(NUMP(), desc_case).format(case=CASE_FOR_NP()[case])
    if ptype == AdjP:
        return make_inflected_string(ADJP(), desc_case).format(case=CASE_FOR_ADJP()[phrase._case._value])
    if ptype == PPasP:
        return make_inflected_string(PPASP(), desc_case).format(case=CASE_FOR_ADJP()[phrase._case._value])
    if ptype == PActP:
        return make_inflected_string(PACTP(), desc_case).format(case=CASE_FOR_ADJP()[phrase._case._value])
    if ptype == PrepNP:
        prep, case = phrase._prep._value, phrase._prep._case._value
        return make_inflected_string(PREPNP(), desc_case).format(prep=prep, case=CASE_FOR_PREPNP()[case])
    if ptype == PrepGerP:
        prep, case = phrase._prep._value, phrase._prep._case._value
        return make_inflected_string(PREPGERP(), desc_case).format(prep=prep, case=CASE_FOR_PREPNP()[case])
    if ptype == PrepNumP:
        prep, case = phrase._prep._value, phrase._prep._case._value
        return make_inflected_string(PREPNUMP(), desc_case).format(prep=prep, case=CASE_FOR_PREPNP()[case])
    if ptype == PrepAdjP:
        prep, case = phrase._prep._value, phrase._prep._case._value
        return make_inflected_string(PREPADJP(), desc_case).format(prep=prep, case=CASE_FOR_PREPNP()[case])
    if ptype == PrepPPasP:
        prep, case = phrase._prep._value, phrase._prep._case._value
        return make_inflected_string(PREPPPASP(), desc_case).format(prep=prep, case=CASE_FOR_PREPNP()[case])
    if ptype == ComPrepNP:
        return make_inflected_string(COMPREPNP(), desc_case).format(prep=phrase._prep)
    if ptype == InfP:
        aspect = phrase._aspect._value
        return make_inflected_string(INFP(), desc_case).format(aspect=make_inflected_string(ASPECT()[aspect], desc_case))
    if ptype == CP:
        typ = phrase._type._value
        if phrase._type._realisations:
            typ_str = make_inflected_string(CP_TYPE().get(typ + '_r', CP_CONJ()), desc_case).format(
                conj='/'.join(phrase._type._realisations))
        else:
            typ_str = make_inflected_string(CP_TYPE().get(typ, CP_CONJ()), desc_case).format(conj=typ)
        return make_inflected_string(CP_(), desc_case).format(typ=typ_str)
    if ptype == NCP:
        case, typ = phrase._case._value, phrase._type._value
        if case == 'part':
            case = 'gen'
        to = TO[case]
        if phrase._type._realisations:
            typ_str = make_inflected_string(NCP_TYPE().get(typ + '_r', NCP_CONJ()), desc_case).format(
                to=to, conj='/'.join(phrase._type._realisations))
        else:
            typ_str = make_inflected_string(NCP_TYPE().get(typ, NCP_CONJ()), desc_case).format(to=to, conj=typ)
        return make_inflected_string(NCP_(), desc_case).format(typ=typ_str)
    if ptype == PrepNCP:
        prep, case, typ = phrase._prep._value, phrase._prep._case._value, phrase._type._value
        to = TO[case]
        if phrase._type._realisations:
            typ_str = make_inflected_string(PREPNCP_TYPE().get(typ + '_r', PREPNCP_CONJ()), desc_case).format(
                prep=prep, to=to, conj='/'.join(phrase._type._realisations))
        else:
            typ_str = make_inflected_string(PREPNCP_TYPE().get(typ, PREPNCP_CONJ()), desc_case).format(prep=prep, to=to, conj=typ)
        # we use NCP here as it’s the same (fraza zdaniowa wprowadzana przez...)
        return make_inflected_string(NCP_(), desc_case).format(typ=typ_str)
    if ptype in (XP, AdvP):
        sem, realisations = phrase._category._value, phrase._category._limitations
        if ptype == AdvP and sem == 'misc':
            return make_inflected_string(ADVP_MISC(), desc_case)
        if ptype == AdvP and sem == 'pron':
            return make_inflected_string(ADVP_PRON(), desc_case)
        b = (bool(realisations) or inside_lex)
        #desc = make_inflected_string(XP_()[b] if ptype == XP else ADVP(), desc_case)
        #ret = '{desc} {sem}'.format(desc=desc, sem=make_inflected_string(XP_SEM()[sem], desc_case))
        ret = make_inflected_string(XP_(b)[sem] if ptype == XP else ADVP()[sem], desc_case)
        # don’t describe realisations for fixed/lexicalised phrases
        if realisations and not inside_lex:
            rs = make_ul(map(lambda r: phrase_description(r, function, negativity, 'nom', inside_lex=inside_lex), realisations))
            if len(realisations) == 1:
                ret += _(' z dopuszczalną realizacją: ') + rs
            else:
                ret += _(' z dopuszczalnymi realizacjami: ') + rs
        return ret
    # TODO opis?
    if ptype == Compar:
        prep = phrase._category._value
        return make_inflected_string(COMPAR(), desc_case).format(prep=prep)
    if ptype == Nonch:
        return make_inflected_string(NONCH(), desc_case)
    if ptype == OR:
        return make_inflected_string(OR_(), desc_case)
    if ptype == Refl:
        return make_inflected_string(REFL(), desc_case)
    if ptype == Recip:
        return make_inflected_string(RECIP(), desc_case)
    if ptype == E:
        return make_inflected_string(E_(), desc_case)
    if ptype == PossP:
        return make_inflected_string(POSSP(), desc_case)
    if ptype == DistrP:
        return make_inflected_string(DISTRP(), desc_case)
    if ptype == Fixed:
        assert (desc_case == 'nom')
        phrase, phraseo = phrase._phrase, phrase._text.strip('\'')
        return _('zleksykalizowana {phrase} zamrożona w postaci <i>{phraseo}</i>').format(
                phrase=make_phrase_description(phrase, function, negativity, 'nom', inside_lex=True),
                phraseo=phraseo)
    # TODO nie było w dokumentacji
    if ptype == Qub:
        return make_inflected_string(QUB(), desc_case)
    print(ptype)
    1/0
    return 'fraza TODO'

def combine(phrase, texts):
    assert (len(texts) == len(phrase._words._lemmas))
    if len(texts) == 1:
        return texts[0]
    if phrase._words._selection == 'xor' or len(phrase._words._lemmas) > 5:
        return list(chain.from_iterable(texts))
    else:
        joiner = ' ' if  phrase._words._cooccur == 'concat' else ' i/lub '
        return list(chain.from_iterable(map(joiner.join, powerset_nonempty(x)) for x in product(*texts)))

# controller_grammar: (gender, number) of the controller if controller!=None
def make_phraseologisms(phrase, function, negativity, attrs={}, controller=None, controller_grammar=None):
    control = False
    ptype = type(phrase)
    if ptype in (NP, PrepNP, ComPrepNP):
        # “any ((com)prep)np”
        if ptype == NP:
            case = phrase._case._value
        else:
            case = phrase._prep._case._value if ptype == PrepNP else 'gen'
        CASE = correct_case(case, function, negativity)
        prep = (phrase._prep._value + ' ') if ptype != NP else ''
        feats = ['subst', CASE]
        forms = [get_form(lemma, feats) for lemma in ('ktoś', 'coś')]
        return ['{}‹{}›'.format(prep, '/'.join(o for o, t in forms))]
    # TODO merge LexNP with LexPrepNP/LexPrepGerP?
    if ptype == LexNP:
        case = phrase._np._case._value
        if case == 'agr':
            # nom for e.g. ‹ktoś żądny czegoś›
            case = attrs['case'] if 'case' in attrs else 'nom'
        POS = lambda lemma: correct_pos(lemma, 'subst')
        NUM = lambda lemma: correct_num(lemma, phrase._number)
        if not function and controller and controller._function and controller._function._value:
            function = controller._function._value
        CASE = correct_case(case, function, negativity)
        if case == 'str' and not function:
            logging.warning('{}: couldn’t resolve str case in {}; assuming {}'.format(get_current_entry()._base, phrase, CASE))
        feats = [POS, NUM, CASE]
        nps = []
        for lemma in phrase._words._lemmas:
            lemma = correct_lemma(lemma)
            for orth, tag in get_forms(lemma, correct_feats(lemma, feats)):
                mod_attrs = get_subst_attrs(lemma, tag)
                nps += make_modified_phrases(phrase, orth, NP, function, negativity, mod_attrs)
        return nps
    if ptype in (LexPrepNP, LexPrepGerP):
        phrase2 = phrase._prepnp if ptype == LexPrepNP else phrase._prepgerp
        prep, case = phrase2._prep._value, phrase2._prep._case._value
        if prep == 'jako':
            # ktoś aplikuje *jako ktoś* (kontrola przez podmiot)
            # ktoś rozpoznaje kogoś *jako kogoś* (kontrola przez dopełnienie)
            assert(controller)
            assert(controller_grammar)
            function = controller._function._value if controller._function else None
            control = True
        POS = lambda lemma: correct_pos(lemma, 'subst') if ptype == LexPrepNP else 'ger'
        NUM = controller_grammar[1] if control else lambda lemma: correct_num(lemma, phrase._number)
        CASE = correct_case(case, function)
        feats = [POS, NUM, CASE]
        if ptype == LexPrepGerP:
            feats += ['aff']
        nps = []
        for lemma in phrase._words._lemmas:
            lemma = correct_lemma(lemma)
            # eg. zaofiarować dobra:pl jako *coś*
            feats2 = [feats[0], feats[1] if lemma not in ('ktoś', 'coś') else 'sg'] + feats[2:]
            for orth, tag in get_forms(lemma, correct_feats(lemma, feats2, praep=True)):
                mod_attrs = get_subst_attrs(lemma, tag)
                nps += make_modified_phrases(phrase, orth, NP, function, negativity, mod_attrs)
        return [combine_with_prep(prep, np) for np in nps]
    if ptype in (LexNumP, LexPrepNumP):
        case = (phrase._nump if ptype == LexNumP else phrase._prepnump._prep)._case._value
        prep = (phrase._prepnump._prep._value + ' ') if ptype != LexNumP else ''
        CASE = correct_case(case, function)
        phrs = []
        words = []
        for word in phrase._words._lemmas:
            if word.startswith('E('):
                if word == 'E(_)':
                    word = 'E(f.m1.m2.m3.n)'
                words += ['E({})'.format(gend) for gend in word.strip('E()').split('.')]
            else:
                words.append(word)
        for num in phrase._nums._lemmas:
            POS = correct_pos(num, 'num')
            for word in words:
                # wiele wody
                NUM = correct_num(num, 'pl') if word != 'woda' else 'sg'
                gend = get_gender(word)
                # gender before congr/rec to avoid empty result due to filtering priority
                feats = [POS, NUM, CASE] + gend + [correct_congr(num)]
                num_form = get_form(correct_num_lemma(num), feats)
                congr = num_form[1].split(':')[4]
                word_case = CASE if congr == 'congr' else 'gen'
                word_form = get_form(word, ['subst', NUM, word_case])
                # back to digits if this is the case
                num_form = (num, num_form[1]) if num in NUM_LEMMA else num_form
                phr = '{} {}'.format(num_form[0], word_form[0]) if word_form[0] else num_form[0]
                mod_attrs = { 'num': NUM, 'case': CASE, 'gend' : gend }
                phrs += make_modified_phrases(phrase, phr, NumP, function, negativity, mod_attrs)
        return ['{}{}'.format(prep, phr) for phr in phrs]
    if ptype == AdjP:
        feats = ['adj', attrs['num'], attrs['case'], attrs['gend'], 'pos']
        return ['‹{}›'.format(get_form('jakiś', feats)[0])]
    if ptype in (LexAdjP, LexPPasP, LexPActP):
        if ptype == LexAdjP:
            phrase2 = phrase._adjp
            POS = lambda lemma: correct_pos(lemma, 'adj')
        elif ptype == LexPPasP:
            phrase2 = phrase._ppasp
            POS = 'ppas'
        else:
            phrase2 = phrase._pactp
            POS = 'pact'
        if phrase2._case._value == 'agr' and 'case' in attrs:
            case = attrs['case']
            assert (case != 'agr')
            CASE = correct_case(case, function)
        else:
            if phrase2._case._value == 'pred':
                assert(controller)
                #assert(controller_grammar)
            CASE = correct_case(phrase2._case._value, function, negativity)
        # np. uczynić coś *jakimś* / kobietę *jakąś*
        # w składni nie będzie controller_grammar
        if controller and controller_grammar:
            function = controller._function._value if controller._function else None
            control = True
        if phrase._number == 'agr' and 'num' in attrs:
            num = attrs['num']
            assert (num != 'agr')
            NUM = lambda lemma: correct_num(lemma, num)
        elif control:
            NUM = controller_grammar[1]
        else:
            NUM = lambda lemma: correct_num(lemma, phrase._number)
        if phrase._gender == 'agr' and 'gend' in attrs:
            gend = attrs['gend']
            assert (gend != 'agr')
            GEND = gend
        elif control:
            GEND = controller_grammar[0]
        else:
            GEND = correct_gend(phrase._gender)
        DEG = correct_deg(phrase._degree) if ptype == LexAdjP else ''
        feats = [POS, NUM, CASE, GEND, DEG]
        if ptype != LexAdjP:
            feats.append('aff')
        adjps = []
        for lemma in phrase._words._lemmas:
            lemma_adjps = []
            for orth, tag in get_forms(lemma, correct_feats(lemma, feats)):
                mod_attrs = get_subst_attrs(lemma, tag)
                lemma_adjps += make_modified_phrases(phrase, orth, AdjP, function, negativity, mod_attrs)
            adjps.append(lemma_adjps)
        return combine(phrase, adjps)
    if ptype in (LexPrepAdjP, LexPrepPPasP):
        phrase2 = phrase._prepadjp if ptype == LexPrepAdjP else phrase._prepppasp
        prep, case = phrase2._prep._value, phrase2._prep._case._value
        if prep == 'jako':
            # ktoś jawi się *jako jakiś* (kontrola przez podmiot)
            # ktoś rozpoznaje kogoś *jako jakiegoś* (kontrola przez dopełnienie)
            assert(controller)
            assert(controller_grammar)
        # np. uznawać kogoś *za jakiegoś* / coś *za jakieś* / facetów *za jakichś*
        # w składni nie będzie controller_grammar
        if controller and controller_grammar:
            function = controller._function._value if controller._function else None
            control = True
        if control:
            GEND, NUM = controller_grammar
        else:
            NUM = lambda lemma: correct_num(lemma, phrase._number)
            GEND = correct_gend(phrase._gender)
        CASE = correct_case(case, function)
        DEG = correct_deg(phrase._degree) if ptype == LexPrepAdjP else ''
        feats_adjp = ['adjp', CASE]
        feats_adj = ['adj', NUM, CASE, GEND, DEG] if ptype == LexPrepAdjP else ['ppas', NUM, CASE, GEND, DEG, correct_aff(phrase._negativity)]
        adjps = []
        for lemma in phrase._words._lemmas:
            if case == 'postp':
                assert (ptype == LexPrepAdjP)
                try:
                    orth, tag = get_form(lemma, feats_adjp)
                    mod_attrs = {}
                except:
                    orth, tag = get_form(lemma, feats_adj)
                    mod_attrs = get_subst_attrs(lemma, tag)
                adjps = make_modified_phrases(phrase, orth, AdjP, function, negativity, mod_attrs)
            else:
                for orth, tag in get_forms(lemma, feats_adj):
                    mod_attrs = get_subst_attrs(lemma, tag)
                    adjps += make_modified_phrases(phrase, orth, AdjP, function, negativity, mod_attrs)
        return [combine_with_prep(prep, adjp) for adjp in adjps]
    if ptype == LexInfP:
        aspect = phrase._infp._aspect._value
        neg = correct_neg(phrase._negativity)
        sie = correct_sie(phrase._inherent_sie)
        POS = 'inf'
        feats = [POS]
        infps = []
        for lemma in phrase._words._lemmas:
            for orth, tag in get_forms(lemma, feats):
                head = '{}{}{}'.format(neg, orth, sie)
                infps += make_modified_phrases(phrase, head, InfP, function, negativity, {})
        return infps
    if ptype in (CP, NCP, PrepNCP):
        typ = phrase._type._value
        to = ''
        if ptype in (NCP, PrepNCP):
            case = phrase._case._value if ptype == NCP else phrase._prep._case._value
            to = TO[case]
        prep = '{} '.format(phrase._prep._value) if ptype == PrepNCP else ''
        conj = None
        if typ == 'żeby2':
            conj = 'że' if negativity != 'neg' else 'że/żeby'
        elif typ in ('int', 'rel') and phrase._type._realisations:
            conj = '/'.join(phrase._type._realisations)
        elif typ == 'int':
            conj = 'co/czy/ile/kto…'
        elif typ == 'rel':
            #ktory = get_form('który', ['adj', attrs['num'], 'nom', attrs['gend'], 'pos'])[0]
            #conj = '{}/co'.format(ktory)
            conj = 'co/gdzie/kto…'
        elif typ in ('gdy', 'jak', 'kiedy', 'że', 'żeby',):
            conj = typ
        if conj is not None:
            return ['{}{}, {} …'.format(prep, to, conj)]
        print('===========', typ)
        1/0
    # TODO order (się)
    if ptype in (LexCP, LexNCP):
        print(phrase)
        typ = (phrase._cp if ptype == LexCP else phrase._ncp)._type._value
        to = '' if ptype == LexCP else '{}, '.format(TO[phrase._ncp._case._value])
        comp = ''
        if typ == 'żeby2':
            comp = 'żeby '
        elif typ == 'gdy':
            comp = 'gdy '
        elif typ not in ('int', 'rel',):
            comp = typ + ' '
        neg = correct_neg(phrase._negativity)
        sie = correct_sie(phrase._inherent_sie)
        subj = None
        # dependent like „co”, „na kogo”, „który” – should go first
        first = []
        # then pronouns: mi, ci etc., generic NP: ktoś/coś, LexQub: tylko etc.
        pron = []
        rest = []
        #print()
        realisations = (phrase._cp if ptype == LexCP else phrase._ncp)._type._realisations
        realisations = set(realisations) if realisations else set()
        for position in phrase._modification._dependents:
            #print('---')
            assert(len(position._phrases) == 1)
            dep_phrase = position._phrases[0]
            func = position._function._value if position._function else None
            dep_phr = (dep_phrase, make_phraseologisms(dep_phrase, func, phrase._negativity, {}))
            if func == 'subj':
                subj = dep_phr
            words = None
            if type(dep_phrase) == LexNumP:
                words = dep_phrase._nums._lemmas
            elif type(dep_phrase) == LexXP:
                words = dep_phrase._lex._words._lemmas
            elif hasattr(dep_phrase, '_words'):
                words = dep_phrase._words._lemmas
            #print(words)
            if words:
                realisations.difference_update(words)
            if words and {'co', 'gdzie', 'ile', 'jak', 'skąd', 'dokąd', 'który',}.intersection(words):
                first.append(dep_phr)
            elif func != 'subj':
                if (words and {'ja', 'ty', 'on', 'my', 'wy'}.intersection(words)) or type(dep_phrase) in (NP, LexQub):
                    pron.append(dep_phr)
                else:
                    rest.append(dep_phr)
        # all realisations should have been matched by modifications
        # TODO: assertion fails (but shouldn’t!) for lex(cp(int[jaki]),aff,żyć,,ratr1({lex(prepnp(na,loc),sg,świat,ratr1({lex(adjp(agr),agr,agr,pos,jaki,natr)}))})) – nested ‘jaki’
        # TODO: assertion fails for some phrases where the realisation is not among modifications, see (*****) in notes — correct those schemata
        #assert (not realisations)
        # TODO workaround:
        if realisations:
            # TODO workaround produces mess for ‘na jakim świecie żyje’
            assert (len(realisations) == 1 and not first)
            first.append((None, list(realisations)))
        
        assert (len(first) == 1 or typ not in ('int',))
        #print()
        deps1 = [d[1] for d in first] + [d[1] for d in pron]
        if subj and subj not in first + rest:
            deps1.append(subj[1])
        deps2 = [d[1] for d in rest]
        # TODO: always ter? sg/m1 if no subj?
        # TODO separate numbers/genders for subject realisations?
        subj_num = 'sg'
        if subj and hasattr(subj[0], '_number'):
            subj_num = correct_num('', subj[0]._number)
        if typ != 'jakby':
            feats = ['fin', subj_num, 'ter']
        else:
            subj_gend = 'm1'
            if subj:
                subj_gends = set(get_gender(w)[0] for w in subj[0]._words._lemmas)
                assert (len(subj_gends) == 1)
                subj_gend = subj_gends.pop()
            feats = ['praet', subj_num, subj_gend]
        phrs = []
        for lemma in phrase._words._lemmas:
            for dps1 in product(*deps1):
                for dps2 in product(*deps2):
                    verb_form = get_form(lemma, feats)[0]
                    phrs.append('{}{}{}{}{}{}{}{}{}'.format(to, comp, ' '.join(dps1), ' ' if dps1 else '', sie, neg, verb_form, ' ' if dps2 else '', ' '.join(dps2)))
        for phr in phrs:
            print('  ===>', phr)
        return phrs
    if ptype in (XP, AdvP):
        if phrase._category._limitations:
            return chain.from_iterable(make_phraseologisms(phr, function, negativity, {}) for phr in phrase._category._limitations)
        else:
            return [XP_SEM_PHRASEO[phrase._category._value]]
    if ptype == LexXP:
        return make_phraseologisms(phrase._lex, function, negativity, {}, controller=controller, controller_grammar=controller_grammar)
    if ptype == LexAdvP:
        POS = 'adv'
        DEG = correct_deg(phrase._degree)
        feats = [POS, DEG]
        advps = []
        for lemma in phrase._words._lemmas:
            for orth, tag in get_forms(lemma, feats):
                advps += make_modified_phrases(phrase, orth, AdvP, function, negativity, {})
        return advps
    if ptype == Compar:
        return ['{} …'.format(phrase._category._value)]
    if ptype == LexCompar:
        comp = phrase._compar._category._value
        lex_phrs = []
        for lex in phrase._lexes:
            # TODO case (determined by function?) will depend on the control
            # TODO ‹padać jak rażony piorunem› – no control, compar has str case, should be nom, gets resolved to acc...
            phrs = make_phraseologisms(lex, function, negativity, {}, controller=controller, controller_grammar=controller_grammar)
            lex_phrs.append(phrs)
        return ['{} {}'.format(comp, ' '.join(phrs)) for phrs in product(*lex_phrs)]
    if ptype == PossP:
        feats = ['adj', attrs['num'], attrs['case'], attrs['gend'], 'pos']
        forms = [get_form(lemma, feats) for lemma in ('mój', 'pański')]
        return ['/'.join(o for o, t in forms) + '/Anny/…']
    if ptype == OR:
        return '„…”'
    if ptype == Fixed:
        return [phrase._text.strip('\'')]
    if ptype == LexQub:
        qubs = []
        for orth in phrase._words._lemmas:
            qubs += make_modified_phrases(phrase, orth, Qub, function, negativity, {})
        return qubs
    print(ptype)
    1/0
    return ['TODO']

def make_modified_phrases(phrase, head, head_type, function, negativity, mod_attrs):
    texts = []
    if phrase._modification is not None and phrase._modification._atr != 'natr':
        for mod_list in make_modifications(phrase._modification, function, negativity, mod_attrs):
            if phrase._modification._atr == 'ratr1':
                for mod_ptype, mod in mod_list:
                    texts.append(build_phrase(head, mod, head_type, mod_ptype, order_override=phrase._modification._order))
            elif phrase._modification._atr == 'atr1':
                for mod_ptype, mod in mod_list:
                    texts.append(build_phrase(head, '({})'.format(mod), head_type, mod_ptype, order_override=phrase._modification._order))
            elif phrase._modification._atr == 'ratr':
                #for mod_list2 in powerset_nonempty(mod_list):
                #    p = head
                #    for mod_ptype, mod in mod_list2:
                #        p = build_phrase(p, '{}'.format(mod), head_type, mod_ptype)
                #    texts.append(p)
                p = head
                for mod_ptype, mod in mod_list:
                    p = build_phrase(p, '{}'.format(mod), head_type, mod_ptype, order_override=phrase._modification._order)
                texts.append(p)
            elif phrase._modification._atr == 'atr':
                p = head
                for mod_ptype, mod in mod_list:
                    p = build_phrase(p, '({})'.format(mod), head_type, mod_ptype, order_override=phrase._modification._order)
                texts.append(p)
            else:
                print(phrase._modification._atr)
                1/0
    else:
        texts.append(head)
    return uniq_list(texts)

# TODO is the ‘first’ heuristic for choosing phrase type enough?
def make_coordinations(mods):
    ptype = mods[0][0]
    ret = [(ptype, ' i/lub '.join(text for _, text in x)) for x in powerset_nonempty(mods)]
    return ret

def make_modifications(modification, function, negativity, attrs):
    mods = []
    for position in modification._dependents:
        position_mods = []
        for p in position._phrases:
            mod = make_phraseologisms(p, function, negativity, attrs=attrs)
            # pass the mod phrase’s type for determining text order
            position_mods.append([(type(p), m) for m in mod])
        if len(position_mods) > 1:
            mods.append(chain.from_iterable(make_coordinations(mds) for mds in product(*position_mods)))
        else:
            mods.append(position_mods[0])
    return list(product(*mods))

def make_ul(items):
    return '<ul>{}</ul>'.format(''.join(map('<li>{}</li>'.format, items)))