#!/usr/bin/python3

import re
import sys

from zeichenklassen import v, c, p, f, n

'''
Das folgende (umgekehrte) Silbenpattern besteht aus
 - beliebige Folge von Konsonanten
 - nicht-leere Folge von Vokalen
 - Folge von Nasalen und Liquiden
 - Folge von Frikativen
 - Folge von Plosiven
 Die Reihenfolge ist umgedreht, da die Buchstabenfolge von hinten nach vorne
 analysiert wird, um den Onset maximieren zu können.
'''
pattern = rf'{c}*{v}+(?:w?z|(?:h(?!c)|{n}?{f}?{p}?))(?:{c}*(?=\ |$))?'

komposita = {}
with open('lib/komposita.txt', encoding='utf-8') as file:
    for line in file:
        teile = line.split()
        komposita[''.join(teile)] = teile

def syllabify(words, tags):
    ''' zerlegt Wörter in Silben und verarbeitet dabei jedes Wort rückwärts '''
    alle_silben = []
    for word, tag in zip(words, tags):
        # zerlege Komposita in ihre Bestandteile
        if word in komposita:
            word = ' '.join(komposita[word])
        
        # Großbuchstaben durch Kleinbuchstaben ersetzen
        letters = word.lower()
        # meien --> mei en
        letters = re.sub(rf'(ei)([ue])', r'\1 \2', letters)
        # archeit --> arc heit
        letters = re.sub(r'([^s]c)(heit)', r'\1 \2', letters)
        # getwerc --> ge twerc
        letters = re.sub(r'^(ge)(tw|sw|cr)', r'\1 \2', letters)
        # Gedêônes --> Gedê ônes
        letters = re.sub(r'([âêîôû])([âêîôûaeiou])', r'\1 \2', letters)
        # Ezechiêles --> Ezechi êles
        letters = re.sub(r'([aeiou])([âêîôû])', r'\1 \2', letters)
        # blüende --> blü ende
        letters = re.sub(r'([äö])(e)', r'\1 \2', letters)
        # beschwingt --> be schwingt
        letters = re.sub(rf'^(ge|ger|be|ver|er|ent|ze)((end|sch|s[ptlw]|irr)\w*{v})', r'\1 \2', letters)
        # trûtschaft --> trût schaft
        letters = re.sub(r'([dbgtpk])(sch)', r'\1 \2', letters)
        # hartman --> hart man
        letters = re.sub(rf'({v}\w*[pbtdkgfw])([mw]\w*{v})', r'\1 \2', letters)
        letters = re.sub(rf'({v}\w*[pbtdgfw])(n\w*{v})', r'\1 \2', letters)
        # megtlicher --> megt licher
        letters = re.sub(rf'({v}\w*[td])(l\w*{v})', r'\1 \2', letters)
        # ietslîchiu --> iets lîchiu
        if re.match(r'A[DV]', tag):
            letters = re.sub(rf'({v}\w*)(lîch)', r'\1 \2', letters)
        # enphangen --> en phangen
        letters = re.sub(rf'^(e[nm])(p)', r'\1 \2', letters)
        # geunêret --> ge unêret
        if tag.startswith('VVPP'):
            letters = re.sub(rf'^(ge)({v})', r'\1 \2', letters)
        # unêret --> un êret
        letters = re.sub(rf'\b(un)(êre)', r'\1 \2', letters)
        # enist --> en ist
        if tag.startswith('PTKNEG|V'):
            letters = re.sub(rf'^(en)(\w*{v})', r'\1 \2', letters)
        # Geminaten:  wille --> wil le
        letters = re.sub(rf'({v}\w*)({c})\2(\w*{v})', r'\1\2 \2\3', letters)
        # beßer --> bes ser
        letters = re.sub(rf'({v}\w*)ß(\w*{v})', r'\1s s\2', letters)

        # Silben rückwärts erkennen
        silben = re.findall(pattern, letters[::-1])
        # korrekte Reihenfolge wiederherstellen
        silben = [s[::-1] for s in silben[::-1]]

        if not silben:
            sys.exit(f'Fehler: Das Wort {word} kann nicht silbifiziert werden')
        
        # erkannte Silben aufsammeln
        alle_silben.append(silben)
    return alle_silben

