from helper import *
import pandas as pd

def funktion_mit_karte(text):
    """Verarbeitet Text und liefert Daten für eine Karte (z.B. Potsdam Zentrum)."""
    # Beispiel: Fester Punkt (Potsdam)
    daten = pd.DataFrame({'lat': [52.4006], 'lon': [13.0590]})
    ausgabe_text = f"Folgende Koordinate wurde gefunden: {daten.iloc[0].lat}, {daten.iloc[0].lon}"
    return ausgabe_text, daten

def cesar_all(eingabetext):
    eingabetext = eingabetext.rstrip()

    if eingabetext == "":
        return ("HILFE: [Cesar-Verschiebe-Chiffre]  \n"
                "Von der eingegebenen Zeichenkette werden, "
                "alle möglichen Verschiebungen gemäß der "
                "Cesarchiffre generiert und ausgegeben. "
                "Sonderzeichen und Zahlen werden unverändert "
                "wiedergegeben.")
    else:
        abcgross = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        abcklein = "abcdefghijklmnopqrstuvwxyz"
        txt = eingabetext
        ausgabe = ""
        for r in range(1, 27):
            atxt = ""
            for i in txt:
                if i.upper() not in abcgross:
                    atxt = atxt + i  # nicht codierbare Zeichen direkt zur Ausgabe bitte!
                    continue
                abc = abcgross
                if i == i.lower():
                    abc = abcklein
                for j in range(26):
                    if i == abc[j]:
                        if j + r >= 26:
                            atxt = atxt + abc[j + r - 26]
                        else:
                            atxt = atxt + abc[j + r]
            if r < 10:
                ausgabe += "0"
            ausgabe += f"{r}: {atxt}  \n"
        return ausgabe

def buchstabenwortwert(eingabetext):
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        return ("HILFE: [Buchstabenwortwerte ermitteln]  \n"
                "Diese Funktion berechnet den Buchstabenwert "
                "der eingegeben Zeichenkette. (A=1 B=2 .... "
                "Ä=27 Ö=28 Ü=29 ß=30) Bei mehreren durch "
                "Leerzeichen getrennten Wörtern wird auch "
                "für jedes einzelne Wort der Wortwert errechnet. "
                "Desweiteren wird die Quersumme und die iterierte "
                "Quersumme des Gesamtbuchstabenwertes als auch für "
                "jedes Wort das Buchstabenwertprodukt und das "
                "Gesamtbuchstabenwertprodukt ermittelt.")
    else:
        ausgabe = ""
        bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
              'M': 13, 'N': 14,
              'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
              'Z': 26,
              'Ä': 27, 'Ö': 28, 'Ü': 29, 'SS': 30}
        wortsumme = 0
        wortprodukt = 1
        atxt = ""
        az = ""
        eworttxt = ""
        ewortptxt = ""
        banzahla = 0
        banzwtxt = ""
        einzelworte = eingabetext.split()
        for wort in einzelworte:
            ewortsumme = 0
            ewortprod = 1
            banzahlw = 0
            ewtr = False
            for b in wort:
                if b.upper() not in bw:
                    atxt = atxt + b + "=0 "
                    az = az + "0,"
                    continue
                else:
                    ewtr = True
                    ewortprod *= bw[b.upper()]
                    ewortsumme += bw[b.upper()]
                    wortsumme += bw[b.upper()]
                    wortprodukt *= bw[b.upper()]
                    atxt = atxt + b + "=" + str(bw[b.upper()]) + " "
                    az = az + str(bw[b.upper()]) + ","
                    banzahla += 1
                    banzahlw += 1
            banzwtxt = banzwtxt + str(banzahlw) + "/"
            eworttxt = eworttxt + str(ewortsumme) + "/"
            if not ewtr:
                ewortptxt = ewortptxt + "0/"
            else:
                ewortptxt = ewortptxt + str(ewortprod) + "/"

        ausgabe += atxt + "  \n"
        ausgabe += "Buchstabenwerte: "
        ausgabe += az[0:-1] + "  \n"
        ausgabe += "Buchstabenwortwerte: "
        ausgabe += eworttxt[0:-1] + "  \n"
        ausgabe += "Summe aller Buchstabenwerte: "
        ausgabe += str(wortsumme) + "  \n"
        ausgabe += "Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme: "
        ausgabe += str(q_sum(wortsumme)) + " / " + str(iq_sum(wortsumme)) + "  \n"
        ausgabe += "Buchstabenanzahl pro Wort: "
        ausgabe += banzwtxt[0:-1] + "  \n"
        ausgabe += "Gesamtanzahl aller Buchstaben: "
        ausgabe += str(banzahla) + "  \n"
        ausgabe += "Wortprodukte(0 wenn kein Buchstabe gefunden): "
        ausgabe += ewortptxt[0:-1] + "  \n"
        ausgabe += "Buchstabenwert-Produkt:(Nullen werden ignoriert): "
        ausgabe += str(wortprodukt) + "  \n"
        return ausgabe


def buchstabenwertzutext():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    bw = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k',
          12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u',
          22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 27: 'ä', 28: 'ö', 29: 'ü', 30: 'ß'}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Buchstabenwerte zu Text]
Die eingegebenen Buchstabenwert werden in die
entsprechenden Buchstaben umgewandelt.
(A=1 B=2 .... Ä=27 Ö=28 Ü=29 ß=30)
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                if ausz not in bw:
                    Ausgabe.insert(1.0, "Die eingegebene Zahl ist kein gültiger Buchstabenwert!\n", "re")
                else:
                    Ausgabe.insert(1.0, bw[ausz] + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    if az in bw:
                        atxt = atxt + bw[az]
                    else:
                        ignor = ignor + str(z) + " "
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung folgendes wurde ignoriert:\n", "re")


def zeichenkette_rueckwaerts():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Zeichenkette rückwärts]
Diese Funktion gibt die eingegebene Zeichenkette
von hinten nach vorn gelesen aus.\n""")
    else:
        Ausgabe.insert(1.0, eingabetext[::-1] + "\n")


def zeichenzaehlen():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Zeichenzählen]
Es wird das Vorkommen jedes einzelnen Zeichens gezählt
und ausgegeben. 
Achtung! Leerzeichen, Tabulatorzeichen und Zeilenumbrüche
werden nur vor dem letzten sichtbaren Zeichen gezählt!!!""" + "\n\n")
    else:
        anzahl = {}
        for b in eingabetext:
            if b in anzahl:
                anzahl[b] = anzahl[b] + 1
            else:
                anzahl[b] = 1
        s = []
        for key in anzahl:
            s.append(key)
        s.sort(reverse=True)
        for i in s:
            if ord(i) == 9:
                Ausgabe.insert(1.0, "[TAB] = {} mal\n".format(anzahl[i]))
            elif ord(i) == 32:
                Ausgabe.insert(1.0, "[SPACE] = {} mal\n".format(anzahl[i]))
            elif ord(i) == 10:
                Ausgabe.insert(1.0, "[LINEFEED] = {} mal\n".format(anzahl[i]))
            else:
                Ausgabe.insert(1.0, "{} = {} mal\n".format(i, anzahl[i]))
        Ausgabe.insert(1.0, "Es wurden {} unterschiedliche Zeichen gefunden.\n".format(len(anzahl)))


def quersummen():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Quersumme(n)]
Von den eingegebenen Zahlen werden die
Quersummen und iterierten Quersummen errechnet
und ausgegeben.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, "Quersumme: {}  iterierte Quersumme: {}\n".format(q_sum(ausz), iq_sum(ausz)))
        else:
            txt = eingabetext.split(se)
            qtxt = ""
            iqtxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    qtxt = qtxt + str(q_sum(az)) + "/"
                    iqtxt = iqtxt + str(iq_sum(az)) + "/"
            Ausgabe.insert(1.0, iqtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "iterierte Quersummen\n", "bu")
            Ausgabe.insert(1.0, qtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "Quersummen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def einschluessemit4():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Einschlüsse zählen]
Es werden die Einschlüsse in Buchstaben und
Ziffern gezählt. Neben der Anzahl der Einschlüss
für jeden einzelnen Buchstaben, für jedes Wort und
die gesammte Eingabe ermittelt.
Da es sich bei der Zahl 4 je nach Schreibweise um
eine Zahl mit oder ohne Einschluß handeln kann gibt
es zwei Versionen.
!!! Hier ist Klein- und Großschreibung wichtig, denn
z.B. b=1 aber B=2 !!!""" + "\n\n")
    else:
        bw1 = "ADOPQRabdegopq4690"
        wortsummenliste = []
        wortliste = eingabetext.split()
        az = ""
        for wort in wortliste:
            wz = 0
            for b in wort:
                if b == "B" or b == "8":
                    az = az + "2"
                    wz = wz + 2
                elif b in bw1:
                    az = az + "1"
                    wz = wz + 1
                else:
                    az = az + "0"
            az = az + " "
            wortsummenliste.append(wz)
        Ausgabe.insert(1.0, str(sum(wortsummenliste)) + "\n")
        Ausgabe.insert(1.0, "insgesamt gefundene Einschlüsse:", "bu")
        wtxt = ""
        for z in wortsummenliste:
            wtxt = wtxt + str(z) + " "
        Ausgabe.insert(1.0, wtxt + "\n")
        Ausgabe.insert(1.0, "Einschlüsse pro Wort:", "bu")
        Ausgabe.insert(1.0, az + "\n")
        Ausgabe.insert(1.0, "Einschlüsse je Zeichen:\n", "bu")


def einschluesseohne4():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Einschlüsse zählen]
Es werden die Einschlüsse in Buchstaben und
Ziffern gezählt. Neben der Anzahl der Einschlüss
für jeden einzelnen Buchstaben, für jedes Wort und
die gesammte Eingabe ermittelt.
Da es sich bei der Zahl 4 je nach Schreibweise um
eine Zahl mit oder ohne Einschluß handeln kann gibt
es zwei Versionen.
!!! Hier ist Klein- und Großschreibung wichtig, denn
z.B. b=1 aber B=2 !!!""" + "\n\n")
    else:
        bw1 = "ADOPQRabdegopq690"
        wortsummenliste = []
        wortliste = eingabetext.split()
        az = ""
        for wort in wortliste:
            wz = 0
            for b in wort:
                if b == "B" or b == "8":
                    az = az + "2"
                    wz = wz + 2
                elif b in bw1:
                    az = az + "1"
                    wz = wz + 1
                else:
                    az = az + "0"
            az = az + " "
            wortsummenliste.append(wz)
        Ausgabe.insert(1.0, str(sum(wortsummenliste)) + "\n")
        Ausgabe.insert(1.0, "insgesamt gefundene Einschlüsse:", "bu")
        wtxt = ""
        for z in wortsummenliste:
            wtxt = wtxt + str(z) + " "
        Ausgabe.insert(1.0, wtxt + "\n")
        Ausgabe.insert(1.0, "Einschlüsse pro Wort:", "bu")
        Ausgabe.insert(1.0, az + "\n")
        Ausgabe.insert(1.0, "Einschlüsse je Zeichen:\n", "bu")


def morsetoabc():
    alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
                "..": "I", ".---": "J", "-.-": "K", ".-..": "L",
                "--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
                "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
                "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
                "--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
                "..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
                ".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
                "-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
                ".----.": "'", "...--..": "ß"
                }
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Morsecode zu Text]
Die Eingabe des Morsecodes hat wie folgt zu erfolgen:
- für lang und . für kurz, zwischen den Buchstaben ein
Leerzeichen und als Worttrennung ein / wobei davor und
danach ein Leerzeichen steht.
Für unbekannte Morsecodes erscheint in der Ausgabe ein #.""" + "\n\n")
    else:
        morse = eingabetext.split()
        atxt = ""
        for sign in morse:
            if sign == "/":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + "#"
            else:
                atxt = atxt + alphabet[sign]
        Ausgabe.insert(1.0, atxt + "\n")


def abctomorse():
    alphabet = {".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E", "..-.": "F", "--.": "G", "....": "H",
                "..": "I", ".---": "J", "-.-": "K", ".-..": "L",
                "--": "M", "-.": "N", "---": "O", ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
                "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
                "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4", ".....": "5", "-....": "6",
                "--...": "7", "---..": "8", "----.": "9", "-----": "0", "--.--": "Ñ",
                "..-..": "É", ".-..-": "È", ".--.-": "À", "..--": "Ü", "---.": "Ö", ".-.-": "Ä", "..--.-": "_",
                ".--.-.": "@", "..--..": "?", "-...-": "=", "-.-.-.": ";", "---...": ":",
                "-..-.": "/", ".-.-.-": ".", "-....-": "-", "--..--": ",", ".-.-.": "+", "-.--.-": ")", "-.--.": "(",
                ".----.": "'", "...--..": "SS"
                }
    umkehr_alpha = {v: k for k, v in alphabet.items()}  # Alphabet mit getauschten key und values generieren
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Morsecode]
Eingabetext wird als Morsecode ausgegeben.
Nicht kodierbare Zeichen erscheinen unverändert
in der Ausgabe.""" + "\n\n")
    else:
        atxt = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "/ "
            elif b.upper() not in umkehr_alpha:
                atxt = atxt + b + " "
            else:
                atxt = atxt + umkehr_alpha[b.upper()] + " "
        Ausgabe.insert(1.0, atxt + "\n")


def rot5():
    ro5 = {"0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [ROT 5]
ROT 5 bezeichnet eine Verschiebechiffrierung, bei
welcher die Ziffern 0-9 um je 5 Stellen verschoben
werden. Aus 0 wird 5, aus 1 wird 6, aus 7 wird 2,usw.
Kodieren und Dekodieren geschieht hier mit ein und
derselben Funktion, alle Zeichen die keine Ziffern
sind werden unverändert wiedergegeben.""" + "\n\n")
    else:
        atxt = ""
        for z in eingabetext:
            if z not in ro5:
                atxt = atxt + z
            else:
                atxt = atxt + ro5[z]
        Ausgabe.insert(1.0, atxt + "\n")


def rot13():
    ro13 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
            'K': 'X', 'L': 'Y', 'M': 'Z',
            'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
            'X': 'K', 'Y': 'L', 'Z': 'M'}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [ROT 13]
ROT 13 bezeichnet eine Verschiebechiffrierung, bei
welcher die 26 Buchstaben (A-Z) um genau 13 Stellen
verschoben werden. Da dies genau die Hälfte des Alphabets
ist, wird z.B. aus einem A ein N und aus einem N ein A
und somit wird über die selbe Funktion sowohl kodiert als
auch dekodiert. Die Klein- und Großschreibung bleibt
erhalten und alle Zeichen die keine Buchstaben sind 
werden unverändert wiedergegeben.""" + "\n\n")
    else:
        atxt = ""
        for z in eingabetext:
            if z.upper() not in ro13:
                atxt = atxt + z
            elif z.lower() == z:
                a = ro13[z.upper()]
                atxt = atxt + a.lower()
            else:
                atxt = atxt + ro13[z.upper()]
        Ausgabe.insert(1.0, atxt + "\n")


def rot18():
    ro18 = {'A': 'N', 'B': 'O', 'C': 'P', 'D': 'Q', 'E': 'R', 'F': 'S', 'G': 'T', 'H': 'U', 'I': 'V', 'J': 'W',
            'K': 'X', 'L': 'Y', 'M': 'Z',
            'N': 'A', 'O': 'B', 'P': 'C', 'Q': 'D', 'R': 'E', 'S': 'F', 'T': 'G', 'U': 'H', 'V': 'I', 'W': 'J',
            'X': 'K', 'Y': 'L', 'Z': 'M',
            "0": "5", "1": "6", "2": "7", "3": "8", "4": "9", "5": "0", "6": "1", "7": "2", "8": "3", "9": "4"}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [ROT 18]
ROT 18 ist eigentlich nix anderes als, daß hier ROT 5
mit ROT 13 kombiniert wird. Die Buchstaben A-Z werden
um 13 Stellen verschoben und die Ziffern 0-9 um 5 Stellen.
Alle sonstigen Zeichen bleiben unverändert und die Kleine-
oder Großschreibung bleibt auch erhalten, und auch hier
kodiert/dekodiert ein und dieselbe Funktion.""" + "\n\n")
    else:
        atxt = ""
        for z in eingabetext:
            if z.upper() not in ro18:
                atxt = atxt + z
            elif z.lower() == z:
                a = ro18[z.upper()]
                atxt = atxt + a.lower()
            else:
                atxt = atxt + ro18[z.upper()]
        Ausgabe.insert(1.0, atxt + "\n")


def rot47():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [ROT 47]
Bei ROT47 geschieht eigentlich nix anderes als
bei ROT5 oder ROT13 nur das hier die druckbaren
ASCII-Zeichen mit den Werten 33-126(dezimal) zur
Auswahl stehen, also nahezu alle Zeichen die auf
eine Standardtastatur aufgedruckt sind.
Das Ergebnis ist aber deutlich unlesbarer als
z.B. bei ROT13. Alle weiteren Zeichen (z.B. ÄÖÜß)
werden unverändert wiedergegeben und auch hier
kodiert/dekodiert ein und dieselbe Funktion.""" + "\n\n")
    else:
        x = []
        for i in eingabetext:
            j = ord(i)
            if 33 <= j <= 126:
                x.append(chr(33 + ((j + 14) % 94)))
            else:
                x.append(i)
        Ausgabe.insert(1.0, ''.join(x) + "\n")


def asciitodez():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Dezimalzahlen]
Der eingegebene Text wird in Dezimalzahlen umgewandelt. """ + "\n\n")
    else:
        z = []
        for i in eingabetext:
            z.append(str(ord(i)))
        Ausgabe.insert(1.0, ' '.join(z) + "\n")


def deztoascii():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Dezimalzahlen zu Text]
Die eingegebenen Dezimalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, chr(ausz) + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def asciitohex():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Hexadezimalzahlen]
Der eingegebene Text wird in Hexadezimalzahlen umgewandelt. """ + "\n\n")
    else:
        z = []
        for i in eingabetext:
            hexstr = ("{:X}".format(ord(i)))  # großes X für Hex in Großbuchstaben
            z.append(hexstr)
        Ausgabe.insert(1.0, ' '.join(z) + "\n")


def hextoascii():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Hexadezimalzahlen zu Text]
Die eingegebenen Hexadezimalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 16)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, chr(ausz) + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 16)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def asciitooctal():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Octalzahlen]
Der eingegebene Text wird in Octalzahlen umgewandelt. """ + "\n\n")
    else:
        z = []
        for i in eingabetext:
            z.append("{:o}".format(ord(i)))
        Ausgabe.insert(1.0, ' '.join(z) + "\n")


def octaltoascii():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Octalzahlen zu Text]
Die eingegebenen Octalzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 8)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, chr(ausz) + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 8)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def asciitobin16():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Binärzahlen]
Der eingegebene Text wird in Binärzahlen mit
einer festgelegten Breite von 16bit (16 Zeichen)
umgewandelt. """ + "\n\n")
    else:
        z = []
        for i in eingabetext:
            z.append("{:0>16b}".format(ord(i)))
        Ausgabe.insert(1.0, ' '.join(z) + "\n")


def asciitobin8():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Binärzahlen]
Der eingegebene Text wird in Binärzahlen mit
einer festgelegten Breite von 8bit (8 Zeichen)
umgewandelt. """ + "\n\n")
    else:
        z = []
        for i in eingabetext:
            if ord(i) > 255:
                Ausgabe.insert(1.0,
                               "Sorry der Eingabetext enthält Zeichen,\nwelche sich nicht"
                               " mit 8 bit in binär darstellen lassen!\n")
                return
            z.append("{:0>8b}".format(ord(i)))
        Ausgabe.insert(1.0, ' '.join(z) + "\n")


def bintoascii():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Binärzahlen zu Text]
Die eingegebenen Binärzahlen werden in die
entsprechenden UNICODE-Zeichen umgewandelt.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ . - / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 2)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, chr(ausz) + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z, 2)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    atxt = atxt + chr(az)
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zeichen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def zahlwortsuche_de():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche DE 0-12]
Diese Funktion versucht deutsche Zahlworte
zwischen 0 und 12 in einem Text aufzuspüren.
Da alle Zeichen ignoriert werden, welche
keine Buchstaben sind, werden auch Zahlwörter
gefunden welche sich z.B. über zwei Worte
verteilen.""" + "\n\n")
    else:
        zahlen = ["null", "eins", "zwei", "drei", "vier", "fünf", "fuenf", "sechs", "sieben", "acht",
                  "neun", "zehn", "elf", "zwölf", "zwoelf", "zwanzig", "hundert", "tausend"]
        ntxt = ""
        abc = "abcdefghijklmnopqrstuvwxyzäöüß"
        for b in eingabetext:
            if b.lower() not in abc:
                continue
            ntxt = ntxt + b.lower()
        for z in zahlen:
            if z.lower() in ntxt:
                ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
        atxt = ""
        tt = False
        for b in ntxt:
            if b == "-":
                tt = True
                continue
            if b == "_":
                tt = False
                atxt = atxt + " "
            if tt:
                atxt = atxt + b
        if atxt == "":
            Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
        else:
            Ausgabe.insert(1.0, ntxt + "\n")
            Ausgabe.insert(1.0, "Eingangstext:", "bu")
            Ausgabe.insert(1.0, atxt + "\n\n")
            Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")


def zahlwortsuche_en():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Zahlwortsuche EN 0-15]
Diese Funktion versucht englische Zahlworte
zwischen 0 und 15 in einem Text aufzuspüren.
Da alle Zeichen ignoriert werden, welche
keine Buchstaben sind, werden auch Zahlwörter
gefunden welche sich z.B. über zwei Worte
verteilen.""" + "\n\n")
    else:
        zahlen = ["eleven", "twelve", "thirteen", "fourteen", "fifteen", "fourty", "sixty", "seventy",
                  "eighty", "ninety", "zero", "one", "two", "three", "four", "five", "six", "seven",
                  "eight", "nine", "ten", "twenty", "thirty", "fifty"]
        ntxt = ""
        abc = "abcdefghijklmnopqrstuvwxyz"
        for b in eingabetext:
            if b.lower() not in abc:
                continue
            ntxt = ntxt + b.lower()
        for z in zahlen:
            if z.lower() in ntxt:
                ntxt = ntxt.replace(z.lower(), "-" + z.upper() + "_")
        atxt = ""
        tt = False
        for b in ntxt:
            if b == "-":
                tt = True
                continue
            if b == "_":
                tt = False
                atxt = atxt + " "
            if tt:
                atxt = atxt + b
        if atxt == "":
            Ausgabe.insert(1.0, "Leider keine Zahlwörter gefunden!\n", "re")
        else:
            Ausgabe.insert(1.0, ntxt + "\n")
            Ausgabe.insert(1.0, "Eingangstext:", "bu")
            Ausgabe.insert(1.0, atxt + "\n\n")
            Ausgabe.insert(1.0, "Gefundene Zahlwörter:", "bu")


def kenny_kodieren():
    alphabet = {"a": "mmm", "b": "mmp", "c": "mmf", "d": "mpm", "e": "mpp", "f": "mpf", "g": "mfm", "h": "mfp",
                "i": "mff", "j": "pmm", "k": "pmp",
                "l": "pmf", "m": "ppm", "n": "ppp", "o": "ppf", "p": "pfm", "q": "pfp", "r": "pff", "s": "fmm",
                "t": "fmp", "u": "fmf", "v": "fpm", "w": "fpp",
                "x": "fpf", "y": "ffm", "z": "ffp", "ä": "mmmmpp", "ö": "ppfmpp", "ü": "fmfmpp", "ß": "fmmfmm",
                "A": "Mmm", "B": "Mmp", "C": "Mmf", "D": "Mpm",
                "E": "Mpp", "F": "Mpf", "G": "Mfm", "H": "Mfp", "I": "Mff", "J": "Pmm", "K": "Pmp", "L": "Pmf",
                "M": "Ppm", "N": "Ppp", "O": "Ppf", "P": "Pfm",
                "Q": "Pfp", "R": "Pff", "S": "Fmm", "T": "Fmp", "U": "Fmf", "V": "Fpm", "W": "Fpp", "X": "Fpf",
                "Y": "Ffm", "Z": "Ffp", "Ä": "Mmmmpp",
                "Ö": "Ppfmpp", "Ü": "Fmfmpp"
                }
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Kennyspeak codieren]
Hilfe sie haben Kenny getötet.. ach nee er kann
ja noch seine unverständlichen m p f -Laute von
sich geben und hier geht es darum normalen
Text in genau diese Laute umzusetzen, wo jedem
Buchstaben A-Z eine 3 Zeichen-Kombination
zugeordnet ist die sich aus m,p,f 
zusammensetzt.(a=mmm h=mfp x=fpf)""" + "\n\n")
    else:
        atxt = ""
        for b in eingabetext:
            if b in alphabet:
                atxt = atxt + alphabet[b]
            else:
                atxt = atxt + b
        Ausgabe.insert(1.0, atxt + "\n")


def unkennify(text):
    # Funktion hier entnommen und angepasst: https://www.namesuppressed.com/software/kenny.py
    decoded = ''
    codemap = str.maketrans('MmPpFf', '001122')
    n_len = len(text)
    i = 0
    while i + 3 <= n_len:
        if match('[MmPpFf]{3,}', text[i:i + 3]):
            num = int(text[i:i + 3].translate(codemap), 3)  # 'mpf' -> '012' -> 5
            cypher = chr(num + ord('a'))  # 5 -> 'f'
            if text[i].isupper():
                cypher = cypher.upper()
            decoded = decoded + cypher
            i = i + 3
        else:
            decoded = decoded + text[i]
            i = i + 1
    if i < n_len:
        decoded = decoded + text[i:]
    return decoded


def kenny_dekodieren():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Kennyspeak decodieren]
Wie? Du verstehst Kenny's mpf-Gebrabbel nicht?
Na gut da kann ich helfen!!
Nicht kennifiziertes wird unverändert ausgegeben.""" + "\n\n")
    else:
        Ausgabe.insert(1.0, unkennify(eingabetext) + "\n")


def kenny_raten():
    wbk = {"000": "a", "001": "b", "002": "c", "010": "d", "011": "e", "012": "f", "020": "g", "021": "h",
           "022": "i", "100": "j", "101": "k", "102": "l", "110": "m", "111": "n", "112": "o", "120": "p",
           "121": "q", "122": "r", "200": "s", "201": "t", "202": "u", "210": "v", "211": "w", "212": "x",
           "220": "y", "221": "z"
           }
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [KENNYspeak raten]
Diese Funktion dient zum dekodieren von kennyfizierten
Texten, bei denen die 3 Buchstaben mpf vertauscht oder durch
andere Zeichen ersetzt wurden. Hierzu werden vor der
Dekodierung die 3 häufigsten Zeichen im Text ermittelt und
alle anderen Zeichen entfernt bevor die 6 möglichen Lösungen
ausgegeben werden.
(Falls zum kodieren die Zahlen 0,1 oder 2 verwendet wurden,
werden sie durch Buchstaben a,b,c.. ersetzt)""" + "\n\n")
    else:
        wtxt = ""
        for b in eingabetext:
            if b == chr(9) or b == chr(32) or b == chr(10):
                continue  # erstmal leerzeichen, tab, linefeed raus
            wtxt = wtxt + b.lower()
        anzahl = {}  # restliche zeichen zählen und in ein wörterbuch
        for c in wtxt:
            if c in anzahl:
                anzahl[c] = anzahl[c] + 1
            else:
                anzahl[c] = 1
        s = []  # zum Sortieren lieber eine liste
        for key in anzahl:
            s.append([anzahl[key], key])
        s.sort(reverse=True)
        abc3 = [s[0][1], s[1][1], s[2][1]]  # die 3 häufigsten Zeichen im Text wären gefunden
        cwtxt = ""
        for b in wtxt:  # alles raus außer den 3 häufigsten Zeichen
            if b not in abc3:
                continue
            cwtxt = cwtxt + b
        abca = ["a", "b", "c", "d"]  # falls 0,1,2 verwendet wurden in a, b, c... ändern
        if "0" in abc3 or "1" in abc3 or "2" in abc3:
            for i in range(3):
                if abc3[i] in ["0", "1", "2"]:
                    for j in abca:
                        if j in abc3:
                            continue
                        else:
                            cwtxt = cwtxt.replace(abc3[i], j)
                            abc3[i] = j
                            break
        for p in all_perms(abc3):
            txt0 = cwtxt.replace(p[0], "0")
            txt1 = txt0.replace(p[1], "1")
            txt2 = txt1.replace(p[2], "2")
            atxt = ""
            for i in range(0, len(txt2), 3):
                tri = txt2[i:i + 3]
                if tri in wbk:
                    atxt = atxt + wbk[tri]
            Ausgabe.insert(1.0, "{}\n".format(atxt))
            Ausgabe.insert(1.0, "{}\n".format(p), "bu")


def primzahlalphabet_dekodieren():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Primzahlalphabet dekodieren]
Hier können Primzahlen kleiner als 1 Million
in Buchstaben umgewandelt werden. Es wird dabei
davon ausgegangen, daß den Primzahlen 
wiederholend die Buchstaben A-Z zugeordnet
werden,2=A 3=B 5=C 7=D 11=E.......
....97=Y 101=Z 103=A 107=B ... usw.""" + "\n\n")
    else:
        grenze = 1000000
        primes = primzahlliste(grenze)
        pdict = {}
        bz = 65
        for p in primes:
            if bz == 91:
                bz = 65
            pdict[p] = chr(bz)
            bz += 1
        seperator = ("|,", "_", ".", "-", "/", ";", ",")
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
            if se == "" and " " in eingabetext:
                se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                if ausz in pdict:
                    Ausgabe.insert(1.0, pdict[ausz] + "\n")
                else:
                    Ausgabe.insert(1.0, eingabetext + " ist keine Primzahl oder größer als 1 Million!\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    if az in pdict:
                        atxt = atxt + pdict[az]
                    else:
                        ignor = ignor + str(z) + " "
            Ausgabe.insert(1.0, atxt + "\n")
            Ausgabe.insert(1.0, "umgewandelte Zahlen:\n", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "ignoriert wurde:\n", "re")


def primzahlpruefen():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Primzahl prüfen]
Für eine eingegebene Zahl wird überprüft,
ob es sich um eine Primzahl handelt.
Ist die eingegebene Zahl eine Primzahl
wird auch informiert, die wievielte
Primzahl es ist.
Zahlen über 1299709 (der 100000. Primzahl)
werden abgelehnt.""" + "\n\n")
    else:
        try:
            ausz = int(eingabetext)
        except ValueError:
            Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
        else:
            if ausz > 1299709:
                Ausgabe.insert(1.0,
                               "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen"
                               " bis maximal 1299709 !\n", "re")
                return
            primes = primzahlliste(1299710)
            if ausz not in primes:
                Ausgabe.insert(1.0, "{} ist keine Primzahl\n".format(ausz))
            else:
                Ausgabe.insert(1.0, "{} ist die {}. Primzahl\n".format(ausz, primes.index(ausz) + 1))


def nte_primzahl():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [n.te Primzahl]
Du willst wissen wie z.B. die 1000. Primzahl lautet,
dann bist du hier genau richtig.
Die Funktion liefert maximal die 100000. Primzahl.
""" + "\n\n")
    else:
        try:
            ausz = int(eingabetext)
        except ValueError:
            Ausgabe.insert(1.0, "Keine Zahl erkannt!\n", "re")
        else:
            if ausz > 100000:
                Ausgabe.insert(1.0,
                               "Sorry, aber ich mag nur die ersten 100000 Primzahlen,\ndas sind Zahlen bis"
                               " maximal 1299709 !\n", "re")
                return
            primes = primzahlliste(1299710)
            Ausgabe.insert(1.0, "Die {}. Primzahl lautet:{}\n".format(ausz, primes[ausz - 1]))


def primfaktoren():
    hilfetext = """HILFE: [Primfaktorenzerlegung]
Für die eingegebene Zahl werden die Primfaktoren ermittelt
und ausgegeben. Sollte die Zahl einen Primfaktoren haben, welcher
größer als 100 Millionen ist, wird die Suche abgebrochen, da die
Suche sonst zu lange dauert.
Die Funktion läßt sich damit also auch, bei Zahlen kleiner als 200 
Millionen, dazu benutzen um festzustellen, ob die eingegebene Zahl eine
Primzahl ist.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            n = int(eingabetext)
        except ValueError:
            Ausgabe.insert(1.0, "Es konnte leider keine Zahl erkannt werden.\n", "re")
            return
        faktoren = []
        for i in chain([2], range(3, n // 2 + 1, 2)):
            if i > 100000000:
                Ausgabe.insert(1.0,
                               "Sorry, aber die Primfaktorensuche wurde abgebrochen,\nda mindestens 1 Faktor"
                               " größer als 100 Millionen ist.\n", "re")
                return
            while n % i == 0:
                faktoren.append(i)
                n = n // i
            if i > n:
                break
        out = "Die Zahl {} hat folgende Primfaktoren:\n".format(eingabetext)
        if not faktoren:
            Ausgabe.insert(1.0, "Die Zahl {} ist eine Primzahl!!\n".format(eingabetext))
        else:
            for z in faktoren:
                out += str(z) + ", "
        return Ausgabe.insert(1.0, out[:-2] + "\n")


def deztohexoctbin():
    seperator = ("|,", "_", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Dezimal zu HEX, Octal, Binär]
Die eingegebenen dezimalen Ganzzahlen werden in die
entsprechenden hexadezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, "Dez: {0:} HEX:{0:X} OCT:{0:o} BIN:{0:b}\n".format(ausz))
        else:
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            Ausgabe.insert(1.0, bintxt[:-1] + "\n")
            Ausgabe.insert(1.0, "BIN:", "bu")
            Ausgabe.insert(1.0, octtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "OCT:", "bu")
            Ausgabe.insert(1.0, hextxt[:-1] + "\n")
            Ausgabe.insert(1.0, "HEX:", "bu")
            Ausgabe.insert(1.0, deztxt[:-1] + "\n")
            Ausgabe.insert(1.0, "DEZ:", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")


def hextodezoctbin():
    seperator = ("|,", "_", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Hexadezimal zu Dezimal, Octal, Binär]
Die eingegebenen hexadezimalen Zahlen werden in die
entsprechenden dezimalen, octalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 16)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, "HEX:{0:X} Dez: {0:} OCT:{0:o} BIN:{0:b}\n".format(ausz))
        else:
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 16)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            Ausgabe.insert(1.0, bintxt[:-1] + "\n")
            Ausgabe.insert(1.0, "BIN:", "bu")
            Ausgabe.insert(1.0, octtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "OCT:", "bu")
            Ausgabe.insert(1.0, deztxt[:-1] + "\n")
            Ausgabe.insert(1.0, "DEZ:", "bu")
            Ausgabe.insert(1.0, hextxt[:-1] + "\n")
            Ausgabe.insert(1.0, "HEX:", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")


def octtohexdezbin():
    seperator = ("|,", "_", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Octal zu HEX, Dezimal, Binär]
Die eingegebenen octalen Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und binären
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 8)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, "OCT:{0:o} HEX:{0:X} Dez: {0:} BIN:{0:b}\n".format(ausz))
        else:
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 8)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            Ausgabe.insert(1.0, bintxt[:-1] + "\n")
            Ausgabe.insert(1.0, "BIN:", "bu")
            Ausgabe.insert(1.0, deztxt[:-1] + "\n")
            Ausgabe.insert(1.0, "DEZ:", "bu")
            Ausgabe.insert(1.0, hextxt[:-1] + "\n")
            Ausgabe.insert(1.0, "HEX:", "bu")
            Ausgabe.insert(1.0, octtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "OCT:", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")


def bintohexdezoct():
    seperator = ("|,", "_", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Binär zu HEX, Dezimal, Octal]
Die eingegebenen binären Zahlen werden in die
entsprechenden hexadezimalen, dezimalen und octalen
Zahlen umgerechnet.
Als Trennungszeichen zwischen den Zahlen sind
folgende Zeichen erlaubt: | , _ / ; , und 
Leerzeichen. Bei Verwendung von Leerzeichen
sollten möglichst nur 1 Leerzeichen zwischen
den Zahlen verwendet werden (überzählige
Leerzeichen werden sonst als nicht erkannte
Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext, 2)
            except ValueError:
                Ausgabe.insert(1.0, "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n",
                               "re")
            else:
                Ausgabe.insert(1.0, "BIN:{0:b} HEX:{0:X} Dez: {0:} OCT:{0:o}\n".format(ausz))
        else:
            txt = eingabetext.split(se)
            deztxt, hextxt, octtxt, bintxt, ignor = "", "", "", "", ""
            for z in txt:
                try:
                    az = int(z, 2)
                except ValueError:
                    ignor = ignor + str(z) + " "
                else:
                    deztxt = deztxt + str(az) + "/"
                    hextxt = hextxt + "{:X}".format(az) + "/"
                    octtxt = octtxt + "{:o}".format(az) + "/"
                    bintxt = bintxt + "{:b}".format(az) + "/"
            Ausgabe.insert(1.0, octtxt[:-1] + "\n")
            Ausgabe.insert(1.0, "OCT:", "bu")
            Ausgabe.insert(1.0, deztxt[:-1] + "\n")
            Ausgabe.insert(1.0, "DEZ:", "bu")
            Ausgabe.insert(1.0, hextxt[:-1] + "\n")
            Ausgabe.insert(1.0, "HEX:", "bu")
            Ausgabe.insert(1.0, bintxt[:-1] + "\n")
            Ausgabe.insert(1.0, "BIN:", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:", "re")


def abctotomtom():
    alphabet = {"a": "/ ", "b": "// ", "c": "/// ", "d": "//// ", "e": "/\\ ", "f": "//\\ ", "g": "///\\ ",
                "h": "/\\\\ ",
                "i": "/\\\\\\ ", "j": "\\/ ", "k": "\\\\/ ", "l": "\\\\\\/ ", "m": "\\// ", "n": "\\/// ", "o": "/\\/ ",
                "p": "//\\/ ",
                "q": "/\\\\/ ", "r": "/\\// ", "s": "\\/\\ ", "t": "\\\\/\\ ", "u": "\\//\\ ", "v": "\\/\\\\ ",
                "w": "//\\\\ ",
                "x": "\\\\// ", "y": "\\/\\/ ", "z": "/\\/\\ "
                }  # jweils doppelte backslashs da python sonst als versucht Escapecodes draus zu machen \\ = \
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Tomtom]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die 
Buchstaben A-Z.""" + "\n\n")
    else:
        atxt = ""
        ignor = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "  "
            elif b.lower() not in alphabet:
                ignor = ignor + b + " "
            else:
                atxt = atxt + alphabet[b.lower()]
        Ausgabe.insert(1.0, atxt + "\n")
        Ausgabe.insert(1.0, "kodierter Text:", "bu")
        if ignor != "":
            Ausgabe.insert(1.0, ignor + "\n")
            Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")


def tomtomtoabc():
    alphabet = {'/': 'A', '//': 'B', '///': 'C', '////': 'D', '/\\': 'E', '//\\': 'F', '///\\': 'G', '/\\\\': 'H',
                '/\\\\\\': 'I', '\\/': 'J',
                '\\\\/': 'K', '\\\\\\/': 'L', '\\//': 'M', '\\///': 'N', '/\\/': 'O', '//\\/': 'P', '/\\\\/': 'Q',
                '/\\//': 'R', '\\/\\': 'S',
                '\\\\/\\': 'T', '\\//\\': 'U', '\\/\\\\': 'V', '//\\\\': 'W', '\\\\//': 'X', '\\/\\/': 'Y',
                '/\\/\\': 'Z'
                }  # jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Tomtom zu Text]
Beim Tomtom Code werden die einzelnen Buchstaben durch
Kombinationen von / und \\ dargestellt. Zwischen den
einzelnen Buchstaben steht ein Leerzeichen zwischen Worten
zwei Leerzeichen. Kodiert werden, können nur die 
Buchstaben A-Z.""" + "\n\n")
    else:
        tomtom = eingabetext.replace("  ", " _ ")
        tomtom = tomtom.split()
        atxt = ""
        for sign in tomtom:
            if sign == "_":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + "#"
            else:
                atxt = atxt + alphabet[sign]
        Ausgabe.insert(1.0, atxt + "\n")


def texttoslashpipe():
    alphabet = {"a": "| ", "b": "|\\ ", "c": "|| ", "d": "|/ ", "e": "\\ ", "f": "||\\ ", "g": "||| ", "h": "\\\\ ",
                "i": "/ ", "j": "|\\\\ ", "k": "//|| ", "l": "|\\/ ", "m": "|\\| ", "n": "|/| ", "o": "||/| ",
                "p": "|\\|\\ ",
                "q": "/\\ ", "r": "\\/ ", "s": "/| ", "t": "|// ", "u": "// ", "v": "||\\\\ ", "w": "\\/|| ",
                "x": "||/ ", "y": "|||\\ ", "z": "|||| "
                }  # jweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Text zu Slash and Pipe]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird. 
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
    else:
        atxt = ""
        ignor = ""
        for b in eingabetext:
            if b == " ":
                atxt = atxt + "  "
            elif b.lower() not in alphabet:
                ignor = ignor + b + " "
            else:
                atxt = atxt + alphabet[b.lower()]
        Ausgabe.insert(1.0, atxt + "\n")
        Ausgabe.insert(1.0, "kodierter Text:", "bu")
        if ignor != "":
            Ausgabe.insert(1.0, ignor + "\n")
            Ausgabe.insert(1.0, "ignorierte Zeichen:", "re")


def slashpipetotext():
    alphabet = {'|': 'A', '|\\': 'B', '||': 'C', '|/': 'D', '\\': 'E', '||\\': 'F', '|||': 'G', '\\\\': 'H', '/': 'I',
                '|\\\\': 'J', '//||': 'K', '|\\/': 'L', '|\\|': 'M', '|/|': 'N', '||/|': 'O', '|\\|\\': 'P', '/\\': 'Q',
                '\\/': 'R',
                '/|': 'S', '|//': 'T', '//': 'U', '||\\\\': 'V', '\\/||': 'W', '||/': 'X', '|||\\': 'Y', '||||': 'Z'}
    # jeweils doppelte backslashs da python sonst versucht Escapecodes draus zu machen \\ = \
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Slash and Pipe zu Text]
Vergleichbar mit dem Tomtom-Code nur das hier für die
Buchstabenkodierung auch der | mit eingesetzt wird. 
Zwischen den einzelnen Buchstaben steht ein Leerzeichen
zwischen Worten zwei Leerzeichen.
Kodiert werden, können nur die Buchstaben A-Z.""" + "\n\n")
    else:
        tomtom = eingabetext.replace("  ", " _ ")
        tomtom = tomtom.split()
        atxt = ""
        for sign in tomtom:
            if sign == "_":
                atxt = atxt + " "
            elif sign not in alphabet:
                atxt = atxt + "#"
            else:
                atxt = atxt + alphabet[sign]
        Ausgabe.insert(1.0, atxt + "\n")


def periodensystem():
    seperator = ("|,", "_", ".", "-", "/", ";", ",")
    pse = {1: "H", 2: "He", 3: "Li", 4: "Be", 5: "B", 6: "C", 7: "N", 8: "O", 9: "F", 10: "Ne", 11: "Na", 12: "Mg",
           13: "Al",
           14: "Si", 15: "P", 16: "S", 17: "Cl", 18: "Ar", 19: "K", 20: "Ca", 21: "Sc", 22: "Ti", 23: "V", 24: "Cr",
           25: "Mn",
           26: "Fe", 27: "Co", 28: "Ni", 29: "Cu", 30: "Zn", 31: "Ga", 32: "Ge", 33: "As", 34: "Se", 35: "Br", 36: "Kr",
           37: "Rb", 38: "Sr", 39: "Y", 40: "Zr", 41: "Nb", 42: "Mo", 43: "Tc", 44: "Ru", 45: "Rh", 46: "Pd", 47: "Ag",
           48: "Cd", 49: "In", 50: "Sn", 51: "Sb", 52: "Te", 53: "I", 54: "Xe", 55: "Cs", 56: "Ba", 57: "La", 58: "Ce",
           59: "Pr", 60: "Nd", 61: "Pm", 62: "Sm", 63: "Eu", 64: "Gd", 65: "Tb", 66: "Dy", 67: "Ho", 68: "Er", 69: "Tm",
           70: "Yb", 71: "Lu", 72: "Hf", 73: "Ta", 74: "W", 75: "Re", 76: "Os", 77: "Ir", 78: "Pt", 79: "Au", 80: "Hg",
           81: "Tl", 82: "Pb", 83: "Bi", 84: "Po", 85: "At", 86: "Rn", 87: "Fr", 88: "Ra", 89: "Ac", 90: "Th", 91: "Pa",
           92: "U", 93: "Np", 94: "Pu", 95: "Am", 96: "Cm", 97: "Bk", 98: "Cf", 99: "Es", 100: "Fm", 101: "Md",
           102: "No",
           103: "Lr", 104: "Rf", 105: "Db", 106: "Sg", 107: "Bh", 108: "Hs", 109: "Mt", 110: "Ds", 111: "Rg", 112: "Cn",
           113: "Nh", 114: "Fl", 115: "Mc", 116: "Lv", 117: "Ts", 118: "Og"}
    um_pse = {v: k for k, v in pse.items()}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Periodensystem: Ordnungszahl<->Symbol]
Eingegebenen Ordnungszahlen 1-118 aus dem Periodensystem der
Elemente werden in die ihnen zugehörigen Elementsymbole umgewandelt
und anschließend als Text ausgegeben, außerdem erscheint noch eine
Ausgabe bei welcher nur die Anfangsbuchstaben der Symbole ausgegeben
werden.
Werden in der Eingabe Symbole (z.B. N, He) erkannt werde diese
zusammen mit ihren Ordnungszahlen ausgegeben.
Als Trennungszeichen zwischen den Zahlen und/oder Symbolen sind
folgende Zeichen erlaubt: | , _ . - / ; , und Leerzeichen. 
Bei Verwendung von Leerzeichen sollten möglichst nur 1 Leerzeichen
zwischen den Zahlen verwendet werden (überzählige Leerzeichen werden
sonst als nicht erkannte Zeichen behandelt).""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            try:
                ausz = int(eingabetext)
            except ValueError:
                if eingabetext in um_pse:
                    Ausgabe.insert(1.0, str(um_pse[eingabetext]) + "\n")
                else:
                    Ausgabe.insert(1.0, "Keine gültige Eingabe erkannt!\n", "re")
            else:
                Ausgabe.insert(1.0, pse[ausz] + "\n")
        else:
            txt = eingabetext.split(se)
            atxt = ""
            atxt2 = ""
            atxt3 = ""
            ignor = ""
            for z in txt:
                try:
                    az = int(z)
                except ValueError:
                    if z in um_pse:
                        atxt3 += z + ":" + str(um_pse[z]) + " "
                    else:
                        ignor = ignor + z + " "
                else:
                    if az in pse:
                        atxt = atxt + pse[az]
                        atxt2 = atxt2 + pse[az][0]
                    else:
                        ignor = ignor + z + " "
            if atxt3 != "":
                Ausgabe.insert(1.0, " " + atxt3 + "\n")
                Ausgabe.insert(1.0, "Symbol:Ordnungszahl:", "bu")
            if atxt2 != "":
                Ausgabe.insert(1.0, " " + atxt2 + "\n")
                Ausgabe.insert(1.0, "Nur Anfangsbuchstaben:", "bu")
            if atxt != "":
                Ausgabe.insert(1.0, " " + atxt + "\n")
                Ausgabe.insert(1.0, "Symbole:", "bu")
            if ignor != "":
                Ausgabe.insert(1.0, ignor + "\n")
                Ausgabe.insert(1.0, "Achtung nicht erkannte Zeichen:\n", "re")


def brainfuck_interpreter():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Brainfuckinterpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Brainfuck gehört zu den sogenannten esoterischen
Programmiersprachen. Der Programmcode setzt sich 
hier aus den 8 Zeichen ><+-.,[]' zusammen.
Diese Funktion führt einen derartigen Programmcode
aus, und gibt das Ergebnis aus, welches bei Geocaches
meist eine kurze Nachricht oder die Koordinaten sind.
Für eine umgekehrte Umwandlung von Text in Brainfuckcode
gibt es im Internet genügend Möglichkeiten zu finden.
Folgender Code wäre z.B. "Hello World!" in Brainfuck:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.
>.+++.------.--------.>+.>.""" + "\n\n")
    else:
        # ein kleiner feiner Code von https://gist.github.com/kates/986792
        c = [0] * 300000
        p = 0
        loop = []
        rv = []
        ts = list(eingabetext)
        li = len(ts)
        i = 0
        while i < li:
            t = ts[i]
            if t == ">":
                p += 1
            elif t == "<":
                p -= 1
            elif t == "+":
                c[p] += 1
            elif t == "-":
                c[p] -= 1
            elif t == ".":
                rv.append(chr(c[p]))
            elif t == ",":
                pass
            elif t == "[":
                if c[p] == 0:
                    while ts[i] != "]":
                        i += 1
                    loop.pop()
                else:
                    loop.append(i - 1)
            elif t == "]":
                i = loop[-1]
            i += 1
        Ausgabe.insert(1.0, "".join(rv) + "\n")


def ook_interpreter():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Ook-Interpreter]
!!!!!ACHTUNG DIESE FUNKTION KANN DAS PROGRAMM ZUM ABSTURZ BRINGEN!!!!!
Ook ist eine Abwandlung von Brainfuck wobei die 
8 Zeichen von Brainfuck hier durch eine Kombination
von je zwei der folgenden 3 Satzzeichen .!? ersetzt
werden. Dabei wird dann je das Wort Ook vor die Satzzeichen
geschrieben. z.B.: Ook! Ook? Ook. Ook!
Da Ook auch durch andere Wörter ersetzt oder auch
ganz ohne Wörter (ShortOok) auftaucht ignoriert diese
Funktion alle anderen Zeichen außer .!? bevor versucht wird
den Code auszuführen.""" + "\n\n")
    else:
        ookzeichen = [".", "!", "?"]
        ooktext = ""
        for z in eingabetext:  # erstmal Short-Ook draus machen
            if z in ookzeichen:
                ooktext = ooktext + z
        ookbf = {"..": "+", "!!": "-", ".?": ">", "?.": "<", "!?": "[", "?!": "]", "!.": ".", ".!": ","}
        bftext = ""
        for o in range(0, len(ooktext), 2):  # jetzt in Brainfuck umwandeln
            ooz = ooktext[o:o + 2]
            if ooz in ookbf:
                bftext = bftext + ookbf[ooz]
        c = [0] * 300000
        p = 0
        loop = []
        rv = []
        ts = list(bftext)
        li = len(ts)
        i = 0
        while i < li:
            t = ts[i]
            if t == ">":
                p += 1
            elif t == "<":
                p -= 1
            elif t == "+":
                c[p] += 1
            elif t == "-":
                c[p] -= 1
            elif t == ".":
                rv.append(chr(c[p]))
            elif t == ",":
                pass
            elif t == "[":
                if c[p] == 0:
                    while ts[i] != "]":
                        i += 1
                    loop.pop()
                else:
                    loop.append(i - 1)
            elif t == "]":
                i = loop[-1]
            i += 1
        Ausgabe.insert(1.0, "".join(rv) + "\n")


def naknaktotext():
    nakwb = {"Nak": "0", "Naknak": "6", "nanak": "B", "Nanak": "1", "Naknaknak": "7", "naknak": "C", "Nananak": "2",
             "Nak.": "8", "nak!": "D", "Nanananak": "3", "Naknak.": "9", "nak.": "E", "Nak?": "4", "Naknaknaknak": "A",
             "naknaknak": "F", "nak?": "5"}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [NakNak to Text]
Nak-Nak / Entensprache / Duck Speak ist eine Spaßsprache,
welche vom Owner der Website schnatterente.net entwickelt 
wurde.
Diese Funktion übersetzt das Geschnatter in verständliche
Buchstaben/Zeichen.
!!Bitte unbedingt die Groß- und Kleinschreibung beibehalten!!
Wer diesen Quatsch unbedingt umgekehrt übersetzten will,
findet auf hier den passenden Übersetzer:
http://uebersetzer.schnatterente.net""" + "\n\n")
    else:
        txt = eingabetext.split()
        utxt = ""
        z = 1
        for nak in txt:
            if nak in nakwb and z == 1:
                utxt = utxt + "%" + nakwb[nak]
                z += 1
            elif nak in nakwb:
                utxt = utxt + nakwb[nak]
                z = 1
        atxt = urllib_parse_unquote(utxt)
        Ausgabe.insert(1.0, atxt + "\n")
        Ausgabe.insert(1.0, "dekodiertes Geschnatter:", "bu")


def navajototext():
    nabc = {"WOL-LA-CHEE": "A", "BE-LA-SANA": "A", "TSE-NILL": "A", "NA-HASH-CHID": "B", "SHUSH": "B", "TOISH-JEH": "B",
            "MOASI": "C", "TLA-GIN": "C", "BA-GOSHI": "C", "BE": "D", "CHINDI": "D", "LHA-CHA-EH": "D", "AH-JAH": "E",
            "DZEH": "E", "AH-NAH": "E", "CHUO": "F", "TSA-E-DONIN-EE": "F", "MA-E": "F", "AH-TAD": "G", "KLIZZIE": "G",
            "JEHA": "G", "TSE-GAH": "H", "CHA": "H", "LIN": "H", "TKIN": "I", "YEH-HES": "I", "A-CHI": "I",
            "TKELE-CHO-G": "J", "TKELE-CHO-GI": "J", "AH-YA-TSINNE": "J", "YIL-DOI": "J", "JAD-HO-LONI": "K",
            "BA-AH-NE-DI-TININ": "K", "KLIZZIE-YAZZIE": "K", "DIBEH-YAZZIE": "L", "AH-JAD": "L", "NASH-DOIE-TSO": "L",
            "TSIN-TLITI": "M", "BE-TAS-TNI": "M", "NA-AS-TSO-SI": "M", "TSAH": "N", "A-CHIN": "N", "NESH-CHEE": "N",
            "A-KHA": "O", "TLO-CHIN": "O", "NE-AHS-JAH": "O", "NE-ASH-JAH": "O", "CLA-GI-AIH": "P", "BI-SO-DIH": "P",
            "BI-SODIH": "P", "NE-ZHONI": "P", "CA-YEILTH": "Q", "GAH": "R", "DAH-NES-TSA": "R", "AH-LOSZ": "R",
            "DIBEH": "S", "KLESH": "S", "D-AH": "T", "A-WOH": "T", "THAN-ZIE": "T", "SHI-DA": "U", "NO-DA-IH": "U",
            "A-KEH-DI-GLINI": "V", "GLOE-IH": "W", "AL-NA-AS-DZOH": "X", "AL-AN-AS-DZOH": "X", "TSAH-AS-ZIH": "Y",
            "BESH-DO-TLIZ": "Z", "BESH-DO-GLIZ": "Z", "BE-TKAH": " "}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Navajo-ABC to Text]
Die Sprache der Navajo-Indianer wurde im zweiten Weltkrieg für
den verschlüßelten Funkverkehr eingesetzt. Vorteile waren, daß
nahezu niemand außer Navajo-Volk die Sprache verstand und es keine
schriftlichen Aufzeichnungen über die Sprache gab. Das Alphabet 
und die Codewörter wurden dabei von den Codesprechern (natürlich
Navajo's) auswendig gelernt.
Die Dekodierfunktion hier übersetzt das Codealphabet (A-Z), bei welchem es
auch so ist, daß unterschiedliche Worte für den selben Buchstaben stehen,
in normalen Text. Leider existieren leicht unterschiedliche Alphabete was
die Wörter bzw. deren Schreibweise angeht im Netz, mit welchen codiert wird,
weshalb ich hier nur die Dekodierung anbiete.
weitere Codewörter und Erklärungen gibt es z.B. hier: 
https://ww2db.com/other.php?other_id=29
http://math.ucsd.edu/~crypto/Projects/RobertoSandoval/NavajoWindtalkers.pdf""" + "\n\n")
    else:
        txt = eingabetext.split()
        atxt = ""
        for wort in txt:
            w = wort.upper()
            if w in nabc:
                atxt = atxt + nabc[w]
        Ausgabe.insert(1.0, atxt + "\n")
        Ausgabe.insert(1.0, "dekodierter Text:", "bu")


def pi_suche():
    hilfetext = """HILFE: [PI Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von PI (3.141592653589793238462643...) zu ermitteln.

Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen 
wird die Datei pi.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl PI mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit 
dem Tool y-cruncher (http://numberworld.org/y-cruncher/) 
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und pi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            piread = open("./data/pi.txt", "r")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            pistr = ""
            for zeile in piread:
                pistr = pistr + zeile.rstrip()
            piread.close()
            pilen = len(pistr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
            else:
                pos = pistr.find(eingabetext)
                if pos == -1:
                    Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(pilen), "re")
                else:
                    Ausgabe.insert(1.0,
                                   "20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, pistr[pos:pos + 20]))
                    Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
                        eingabetext.rstrip(), pos - 1))
                if pilen >= zahlx > 0:
                    Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle: "
                                        "{}...\n\n".format(zahlx, pistr[zahlx + 1:zahlx + 21]))
                    Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, pistr[zahlx + 1]))
                else:
                    Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n\n".format(pilen),
                                   "re")
                Ausgabe.insert(1.0, "PI (Kreiszahl)\n\n", "gr")


def anagramm_suche_de():
    hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict um
zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörtebuch vorkommen.
Die Datei german.dic muß sich dafür im Unterverzeichnis "data"
befinden.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/german.dic", "r",
                          encoding="iso-8859-15")  # german.dic von https://sourceforge.net/projects/germandict/
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            eingabezaehl = wortzaehl(eingabetext)
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if eingabetext.upper() == zeile.upper():
                    continue
                if len(eingabetext) != len(zeile):
                    continue
                if eingabezaehl == wortzaehl(zeile):
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")


def wortsuche_de():
    hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i**  -> Geocaching
ge*ca**i**  -> Geocaching
T*****dose  -> Tupperdose, Tabaksdose
Da diese Funktion die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict benutzt
muß sich natürlich die Datei german.dic im Unterverzeichnis "data"
befinden.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if len(eingabetext) != len(zeile):
                    continue
                fehler = 0
                for c in range(len(eingabetext)):
                    if eingabetext[c] == "*":
                        continue
                    if eingabetext[c].upper() != zeile[c].upper():
                        fehler += 1
                if fehler == 0:
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")


def wortsuche_en():
    hilfetext = """HILFE: [Wortsuche mit Wörterbuch]
Wer kennt es nicht? Man sucht ein Wort mit einer bestimmten
Anzahl an Buchstaben und weiß aber z.B. nur den Anfangsbuchstaben
und die letzten 3 Buchstaben. Hierbei soll diese Funktion helfen.
Unbekannte Buchstaben werden dabei einfach durch * ersetzt.
Klein-/Großschreibung in der Eingabe wird dabei ignoriert.
Beispiel:
Ge*ca**i**  -> geocaching
ge*ca**i**  -> geocaching
say*s       -> say's (Die Wortliste kennt viele Wörter mit Apostroph)
coordinat** -> coordinator, coordinates, coordinated

Da diese Funktion die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist benutzt,
muß sich natürlich die Datei en_US-large.txt im Unterverzeichnis "data"
befinden.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if len(eingabetext) != len(zeile):
                    continue
                fehler = 0
                for c in range(len(eingabetext)):
                    if eingabetext[c] == "*":
                        continue
                    if eingabetext[c].upper() != zeile[c].upper():
                        fehler += 1
                if fehler == 0:
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "im Wörterbuch gefundene passende Wörter:\n", "bu")


def anagramm_suche_en():
    hilfetext = """HILFE: [Anagrammsuche mit Wörterbuch EN]
Diese Funktion benutzt die englische Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist 
um zu überprüfen ob sich unter Verwendung aller eingegebenen
Buchstaben Wörter bilden lassen, welche im Wörterbuch vorkommen.
Die Datei en_US-large.txt muß sich dafür im Unterverzeichnis
"data" befinden. Dieses Wörterbuch kennt übrigens auch viele
Wörter mit Apostroph wie z.B. "say's".
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            eingabezaehl = wortzaehl(eingabetext)
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                if eingabetext.upper() == zeile.upper():
                    continue
                if len(eingabetext) != len(zeile):
                    continue
                if eingabezaehl == wortzaehl(zeile):
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "gefundene Anagramme:\n", "bu")


def remorse_de():
    hilfetext = """HILFE: [RE-Morse DE]
Es gibt ja so Leute, die finden es lustig einen Morsecode
so aufzuschreiben, daß zwar Wort für Wort getrennt wird,
aber ansonsten einfach mal die Leerzeichen weggelassen werden.
Bei genau solchen fiesen Gemeinheiten hilft diese Funktion.
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 100 MB großes remorse-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 20% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des remorse-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/morse-de.dic", "r",
                          encoding="iso-8859-15")  # german.dic von https://sourceforge.net/projects/germandict/
        except FileNotFoundError:
            try:
                testfile = open("./data/german.dic", "r")
                testfile.close()
                if eingabetext == "GENERATE":
                    remorse_generate_morsede()
                    Ausgabe.insert(1.0,
                                   "/data/remorse-de wurde erzeugt und \nwird ab dem nächsten Aufruf "
                                   "der Funktion benutzt.\n", "gr")
                else:
                    Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
                    Ausgabe.insert(1.0,
                                   "Um das ca. 100 MB große morse-de.dic einmalig aus\ndem german.dic zu "
                                   "erzeugen bitte das Wort: GENERATE\n", "gr")
                    Ausgabe.insert(1.0, "das dauert zwar ca. 5x so lange, aber geht auch.\n", "gr")
                    Ausgabe.insert(1.0,
                                   "Da das Morsewörter /data/morse-de.dic nicht vorhanden ist,\n"
                                   "wurde /data/german.dic für die Suche benutzt\n", "gr")
                    remorse_germandic()
                return
            except FileNotFoundError:
                Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/morse-de.dic gefunden werden!\n", "re")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mline = zeile.split(",")
                if eingabetext == mline[0]:
                    Ausgabe.insert(1.0, mline[1] + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")


def remorse_germandic():
    alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
                'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
                'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
                'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
                '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
                '8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
                'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
                '?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
                '.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
                '(': '-.--.', "'": '.----.', 'SS': '...--..'}
    ualphabet = {v: k for k, v in alphabet.items()}
    ualphabet["...--.."] = "ß"
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
    Ausgabe.insert(1.0, "\n")
    for zeile in wbfile:
        zeile = zeile.strip(" \t\n\r")
        mzeile = ""
        try:
            for char in zeile:
                mzeile += alphabet[char.upper()]
        except KeyError:
            continue
        if eingabetext == mzeile:
            Ausgabe.insert(1.0, zeile + "\n")
    wbfile.close()
    if eingabetext in ualphabet:
        Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
    Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")


def remorse_generate_morsede():
    alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
                'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
                'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
                'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
                '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
                '8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
                'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
                '?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
                '.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
                '(': '-.--.', "'": '.----.', 'SS': '...--..'}
    ofile = open("./data/morse-de.dic", "a", encoding="iso-8859-15")
    ofile.write("-----,0\n.----,1\n..---,2\n...--,3\n....-,4\n.....,5\n-....,6\n--...,7\n---..,8\n----.,9\n")
    ofile.write(".-,A\n-...,B\n-.-.,C\n-..,D\n.,E\n..-.,F\n--.,G\n....,H\n..,I\n.---,J\n-.-,K\n.-..,L\n--,M\n")
    ofile.write("-.,N\n---,O\n.--.,P\n--.-,Q\n.-.,R\n...,S\n-,T\n..-,U\n...-,V\n.--,W\n-..-,X\n-.--,Y\n--..,Z\n")
    ofile.write("--.--,Ñ\n..-..,É\n.-..-,È\n.--.-,À\n..--,Ü\n---.,Ö\n.-.-,Ä\n..--.-,_\n.--.-.,@\n..--..,?\n-...-,=\n")
    ofile.write("-.-.-.,;\n---...,:\n-..-.,/\n.-.-.-,.\n-....-,-\n.-.-.,+\n-.--.-,)\n-.--.,(\n.----.,'\n...--..,ß\n")
    file = open("./data/german.dic", "r", encoding="iso-8859-15")
    for zeile in file:
        omsg = ""
        zeile = zeile.rstrip()
        try:
            for char in zeile:
                omsg = omsg + alphabet[char.upper()]
        except TypeError:
            continue
        else:
            ofile.write(omsg + "," + zeile + "\n")
    file.close()
    ofile.close()


def remorse_en():
    hilfetext = """HILFE: [RE-Morse EN]
Es gibt ja so Leute, die finden es lustig einen
Morsecode so aufzuschreiben, daß zwar Wort für
Wort getrennt wird, aber ansonsten einfach mal
die Leerzeichen weggelassen werden. Bei genau
solchen fiesen Gemeinheiten hilft diese Funktion.
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist 
wird überprüft, für welches Wort der eingegebene Morsecode
stehen könnte. Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
    alphabet = {'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.',
                'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.',
                'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-',
                'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----',
                '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...',
                '8': '---..', '9': '----.', '0': '-----', 'Ñ': '--.--', 'É': '..-..', 'È': '.-..-',
                'À': '.--.-', 'Ü': '..--', 'Ö': '---.', 'Ä': '.-.-', '_': '..--.-', '@': '.--.-.',
                '?': '..--..', '=': '-...-', ';': '-.-.-.', ':': '---...', '/': '-..-.',
                '.': '.-.-.-', '-': '-....-', ',': '--..--', '+': '.-.-.', ')': '-.--.-',
                '(': '-.--.', "'": '.----.', 'SS': '...--..'}
    ualphabet = {v: k for k, v in alphabet.items()}
    ualphabet["...--.."] = "ß"
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mzeile = ""
                try:
                    for char in zeile:
                        mzeile += alphabet[char.upper()]
                except KeyError:
                    continue
                if eingabetext == mzeile:
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            if eingabetext in ualphabet:
                Ausgabe.insert(1.0, ualphabet[eingabetext] + "\n")
            Ausgabe.insert(1.0, "der eingegebene Morsecode kann für folgendes stehen:\n", "bu")


def t9_de():
    hilfetext = """HILFE: [T9-DE]
Diese Funktion benutzt die deutsche Wörterbuchdatei german.dic
vom Project https://sourceforge.net/projects/germandict .
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.

Bsp. 56673462836 liefert das Wort Koordinaten

Da eine Abfrage relativ lange dauert gibt es die Möglichkeit
aus dem german.dic ein ca. 60 MB großes t9-de.dic bauen
zu lassen, welches ab der nächsten Abfrage dann genutzt wird
und wodurch dann nur noch ca. 15% der Zeit pro Abfrage benötigt
wird. Um die Erstellung des t9-de.dic zu starten muß
das Wort GENERATE (Großschreibung beachten!) ins Eingabefeld
eingetragen werden und der Funktionsknopf betätigt werden.
Damit alles funktioniert, muß sich die Datei german.dic
im Unterverzeichnis "data" befinden.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/t9-de.dic", "r", encoding="iso-8859-15")
        except FileNotFoundError:
            try:
                testfile = open("./data/german.dic", "r")
                testfile.close()
                if eingabetext == "GENERATE":
                    t9_generate_t9de()
                    Ausgabe.insert(1.0,
                                   "/data/t9-de.dic wurde erzeugt und \n"
                                   "wird ab dem nächsten Aufruf der Funktion benutzt.\n", "gr")
                else:
                    Ausgabe.insert(1.0, "ins Eingabefeld eingeben und die Funktion starten.\n", "gr")
                    Ausgabe.insert(1.0,
                                   "Um das ca. 60 MB große t9-de.dic einmalig aus\n"
                                   "dem german.dic zu erzeugen bitte das Wort: GENERATE\n", "gr")
                    Ausgabe.insert(1.0, "das dauert zwar ca. 7x so lange, aber geht auch.\n", "gr")
                    Ausgabe.insert(1.0,
                                   "Da das T9-Wörterbuch /data/t9-de.dic nicht vorhanden ist,\n"
                                   "wurde /data/german.dic für die Suche benutzt\n", "gr")
                    t9_germandic()
                return
            except FileNotFoundError:
                Ausgabe.insert(1.0, "Es konnte weder /data/german.dic noch /data/t9-de.dic gefunden werden!\n", "re")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mline = zeile.split(",")
                if eingabetext == mline[0]:
                    Ausgabe.insert(1.0, mline[1] + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")


def t9_germandic():
    alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
                'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
                'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
                'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
                '3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
                '0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
                'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
                '-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
    Ausgabe.insert(1.0, "\n")
    for zeile in wbfile:
        zeile = zeile.strip(" \t\n\r")
        mzeile = ""
        try:
            for char in zeile:
                mzeile += alphabet[char.upper()]
        except KeyError:
            continue
        if eingabetext == mzeile:
            Ausgabe.insert(1.0, zeile + "\n")
    wbfile.close()
    Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")


def t9_generate_t9de():
    alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
                'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
                'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
                'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
                '3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
                '0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
                'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
                '-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
    ofile = open("./data/t9-de.dic", "a", encoding="iso-8859-15")
    file = open("./data/german.dic", "r", encoding="iso-8859-15")
    for zeile in file:
        omsg = ""
        zeile = zeile.rstrip()
        try:
            for char in zeile:
                omsg = omsg + alphabet[char.upper()]
        except KeyError:
            continue
        else:
            ofile.write(omsg + "," + zeile + "\n")
    file.close()
    ofile.close()


def t9_en():
    hilfetext = """HILFE: [T9 EN]
Mit Hilfe der englischen Wörterliste en_US-large.txt
vom Project https://sourceforge.net/projects/wordlist 
ermittelt diese Funktion alle im Wörterbuch enthaltenen
Wörter die zu der eingegebenen T9-kodierten Ziffernfolge
passen und gibt diese aus.

Bsp. 26673462837 liefert das Wort coordinates

Die Datei en_US-large.txt muß sich dafür
im Unterverzeichnis "data" befinden.
"""
    alphabet = {'A': '2', 'B': '2', 'C': '2', 'D': '3', 'E': '3', 'F': '3', 'G': '4',
                'H': '4', 'I': '4', 'J': '5', 'K': '5', 'L': '5', 'M': '6', 'N': '6',
                'O': '6', 'P': '7', 'Q': '7', 'R': '7', 'S': '7', 'T': '8', 'U': '8',
                'V': '8', 'W': '9', 'X': '9', 'Y': '9', 'Z': '9', '1': '1', '2': '2',
                '3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
                '0': '0', 'Ñ': '6', 'É': '3', 'È': '3', 'À': '2', 'Ü': '8', 'Ö': '6',
                'Ä': '2', '@': '1', '?': '1', '=': '0', ':': '1', '/': '1', '.': '1',
                '-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            Ausgabe.insert(1.0, "\n")
            for zeile in wbfile:
                zeile = zeile.strip(" \t\n\r")
                mzeile = ""
                try:
                    for char in zeile:
                        mzeile += alphabet[char.upper()]
                except KeyError:
                    continue
                if eingabetext == mzeile:
                    Ausgabe.insert(1.0, zeile + "\n")
            wbfile.close()
            Ausgabe.insert(1.0, "der eingegebene T9-Code kann für folgendes stehen:\n", "bu")


def vigenere():
    hilfetext = """HILFE: [Vigenere-Chiffre]
Die Eingabe eines Schlüsselwortes ist hier erforderlich!!!
Die Vigenere-Chiffre baut auf dem Prinzip der Cesar-Chiffre
auf, wobei hier die Verschiebung jedes einzelnen Buchstaben
durch die Buchstabenwerte eines Schlüsselwortes definiert 
werden. Da der zu verschlüsselnde Text im allgemeinen
länger als das Schlüsselwort ist, wird das Schlüsselwort immer
wieder wiederholt. Ist der Schlüssel mindestens genauso lang wie
der Klartext entspricht dies dann dem One-Time-Pad-Chiffre.
Der eingegebene Text wird hier mit dem eingegebenen Schlüsselwort
kodiert und dekodiert ausgegeben und zwar sowohl in der
Variante, daß Sonderzeichen Schlüsselbuchstaben verbrauchen
als auch nicht.
"""
    bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12, 'M': 13,
          'N': 14,
          'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25, 'Z': 26}
    ubw = {v: k for k, v in bw.items()}
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "" or pw == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        for b in pw:
            if b.upper() not in bw:
                Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
                return
        pwl = len(pw)
        encoded_text = ""
        encoded_text_s = ""  # wenn Leer und Sonderzeichen Schlüsselbuchstaben verbrauchen
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                encoded_text += text[i]
                auslz += 1
                encoded_text_s += text[i]
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[pw[(i - auslz) % pwl].upper()]
                b2s = bw[pw[i % pwl].upper()]
                ba = (b1 + b2 - 1) % 26
                bas = (b1 + b2s - 1) % 26
                if ba == 0:
                    ba = 26
                if bas == 0:
                    bas = 26
                if text[i] == text[i].upper():
                    encoded_text += ubw[ba]
                    encoded_text_s += ubw[bas]
                else:
                    encoded_text += ubw[ba].lower()
                    encoded_text_s += ubw[bas].lower()
        decoded_text = ""
        decoded_text_s = ""
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                decoded_text += text[i]
                auslz += 1
                decoded_text_s += text[i]
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[pw[(i - auslz) % pwl].upper()]
                b2s = bw[pw[i % pwl].upper()]
                ba = (b1 - b2 + 1) % 26
                bas = (b1 - b2s + 1) % 26
                if ba == 0:
                    ba = 26
                if bas == 0:
                    bas = 26
                if text[i] == text[i].upper():
                    decoded_text += ubw[ba]
                    decoded_text_s += ubw[bas]
                else:
                    decoded_text += ubw[ba].lower()
                    decoded_text_s += ubw[bas].lower()
        Ausgabe.insert(1.0, encoded_text_s + "\n")
        Ausgabe.insert(1.0, "Kodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:\n", "bu")
        Ausgabe.insert(1.0, decoded_text_s + "\n")
        Ausgabe.insert(1.0, "Dekodiert - Sonderzeichen verbrauchen Schlüsselbuchstaben:\n", "bu")
        Ausgabe.insert(1.0, encoded_text + "\n")
        Ausgabe.insert(1.0, "Kodiert - normal:\n", "bu")
        Ausgabe.insert(1.0, decoded_text + "\n")
        Ausgabe.insert(1.0, "Dekodiert - normal:\n", "bu")


def wolseley():
    hilfetext = """HILFE: [Wolseley-Chiffre]
Die Eingabe eines Schlüsselwortes ist hier erforderlich!!!
Die Woseley-Chiffre arbeitet mit einem Schlüsselwort über 
welches dann ein Codequadrat/Codealphabet gebildet wird 
mit welchem dann sowohl kodiert als auch dekodiert wird.
Angefangen wird dabei mit dem jeweils ersten Vorkommen
eines Buchstaben im Schlüsselwort und danach folgen die
restlichen Buchstaben des Alphabets die nicht im 
Schlüsselwort vorkommen. Da hier nur 25 Zeichen zur
Verfügung stehen wird das J mit dem I zusammengefasst
und als I behandelt und dargestellt. Sonstige Zeichen
die nicht im Codealphabet vorhanden sind werden unverändert
ausgegeben.
Codequadrat mit Schlüsselwort: Teebaum
  1 2 3 4 5 
1 T E B A U
2 M C D F G
3 H I K L N
4 O P Q R S
5 V W X Y Z
Bei der Chiffrierung/Dechiffrierung wird im Text nun der
erste Buchstabe mit dem  letzten getauscht, der 2. mit dem
Vorletzten, usw.
also aus T wird Z und umgekehrt,E<->Y, B<->X, A<->W  usw..
nur ein K bleibt ein K
"""
    abc = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird als i chiffriert
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "" or pw == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        for b in pw:
            if b.upper() not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
                Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
                return
        text = text.upper()
        pw = pw.upper()
        if "J" in text:
            text = text.replace("J", "I")
        if "J" in pw:
            pw = pw.replace("J", "I")
        calpha = ""
        for b in pw:
            if b not in calpha:
                calpha += b
        for b in abc:
            if b not in calpha:
                calpha += b
        cabc = {calpha[12]: calpha[12]}
        c1 = calpha[:12]
        c2 = calpha[13:]
        c2 = c2[::-1]
        for i in range(12):
            cabc[c1[i]] = c2[i]
        ucabc = {v: k for k, v in cabc.items()}
        cabc.update(ucabc)
        atxt = ""
        for b in text:
            if b in cabc:
                atxt += cabc[b]
            else:
                atxt += b
        Ausgabe.insert(1.0, atxt + "\n")


def atbash():
    hilfetext = """HILFE: [Atbash-Chiffre]
Atbash ist eine einfache Ersetzungschiffre die für
das hebräische Alphabet entwickelt wurde, welche
später auf das lateinische Alphabet übertragen wurde.
Dabei wird dem normalen Alphabet ein rückwärtsgelesenes
Alphabet gegenüber gestellt. A wird zu Z, B zu Y usw.
Kodierung und Dekodierung erfolgt über die selbe Funktion.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        uabc = abc[::-1]
        cabc = {}
        for i in range(26):
            cabc[abc[i]] = uabc[i]
        atxt = ""
        for b in text:
            if b.upper() in cabc:
                if b == b.upper():
                    atxt += cabc[b]
                else:
                    atxt += cabc[b.upper()].lower()
            else:
                atxt += b
        Ausgabe.insert(1.0, atxt + "\n")


def monoalphasubstitution():
    hilfetext = """HILFE: [Monoalphabetische Substitutions-Chiffre]
Bei der monoalphabetischen Substitution wird jedem Buchstaben des
Alphabet dem Buchstaben eines Schlüsselalphabets zugeordnet:
Bsp. Klartextalphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ
    Schlüsselalphabet: DSBJFALKNVPOQXYWCEGHIMRTUZ
Spezialformen dieser Chiffre sind Atbash, Cesar, Rot13
Die Funktion hier arbeitet so, daß entweder ein komplettes
Schlüsselalphabet oder ein Schlüsselwort verwendet werden kann.
Wird ein Schlüsselwort genutzt wird der Rest des Schlüsselalphabet
automatisch aufgefüllt.
Aus dem Schlüsselwort GutenMorgenLiebeSonne wird dabei dann das
Schlüsselalphabet: GUTENMORLIBSACDFHJKPQVWXYZ
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "" or pw == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        for b in pw:
            if b.upper() not in abc:
                Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
                return
        cabc = ""
        for b in pw.upper() + abc:
            if b not in cabc:
                cabc += b
        cab = {}
        for i in range(26):
            cab[abc[i]] = cabc[i]
        ucab = {v: k for k, v in cab.items()}
        encoded_txt = ""
        for b in text:
            if b.upper() in cab:
                if b == b.upper():
                    encoded_txt += cab[b]
                else:
                    encoded_txt += cab[b.upper()].lower()
            else:
                encoded_txt += b
        decoded_txt = ""
        for b in text:
            if b.upper() in ucab:
                if b == b.upper():
                    decoded_txt += ucab[b]
                else:
                    decoded_txt += ucab[b.upper()].lower()
            else:
                decoded_txt += b
        if len(pw) < len(abc):
            Ausgabe.insert(1.0, "Schlüsselalphabet wurde wie folgt aufgefüllt: " + cabc + "\n", "gr")
        Ausgabe.insert(1.0, encoded_txt + "\n")
        Ausgabe.insert(1.0, "Kodiert:\n", "bu")
        Ausgabe.insert(1.0, decoded_txt + "\n")
        Ausgabe.insert(1.0, "Dekodiert:\n", "bu")


def autokey():
    hilfetext = """HILFE: [Autokey-Chiffre]
Die Autokey-Chiffre arbeitet nach dem selben
Prinzip wie Vignere-Chiffre mit dem Unterschied,
daß hier am Ende des Schlüsselwortes nicht wieder
und wieder das Schlüsselwort angehängt wird,
sondern der Klartext an das Schlüsselwort
angehangen wird. 
Der eingegebene Text wird hier mit dem eingegebenen
Schlüsselwort kodiert und dekodiert ausgegeben.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "" or pw == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        bw = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 10, 'K': 11, 'L': 12,
              'M': 13, 'N': 14,
              'O': 15, 'P': 16, 'Q': 17, 'R': 18, 'S': 19, 'T': 20, 'U': 21, 'V': 22, 'W': 23, 'X': 24, 'Y': 25,
              'Z': 26}
        ubw = {v: k for k, v in bw.items()}
        p_we = ""
        p_wd = ""
        for b in pw:
            if b.upper() not in bw:
                Ausgabe.insert(1.0, "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!\n", "re")
                return
            else:
                p_we += b.upper()  # Sonderzeichen aus PW entfernen und
                p_wd += b.upper()
        if len(p_we) < len(text):
            for b in text:
                if b.upper() in bw:
                    p_we += b.upper()
        encoded_text = ""
        auslz = 0  # auslasszähler zählt zeichen die im text nicht codiert wurden
        for i in range(len(text)):
            if text[i].upper() not in bw:
                encoded_text += text[i]
                auslz += 1
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[p_we[(i - auslz)]]
                ba = (b1 + b2 - 1) % 26
                if ba == 0:
                    ba = 26
                if text[i] == text[i].upper():
                    encoded_text += ubw[ba]
                else:
                    encoded_text += ubw[ba].lower()
        decoded_text = ""
        auslz = 0
        for i in range(len(text)):
            if text[i].upper() not in bw:
                decoded_text += text[i]
                auslz += 1
            else:
                b1 = bw[text[i].upper()]
                b2 = bw[p_wd[(i - auslz)].upper()]
                ba = (b1 - b2 + 1) % 26
                if ba == 0:
                    ba = 26
                p_wd += ubw[ba]
                if text[i] == text[i].upper():
                    decoded_text += ubw[ba]
                else:
                    decoded_text += ubw[ba].lower()
        Ausgabe.insert(1.0, encoded_text + "\n")
        Ausgabe.insert(1.0, "Kodiert:\n", "bu")
        Ausgabe.insert(1.0, decoded_text + "\n")
        Ausgabe.insert(1.0, "Dekodiert:\n", "bu")


def polybios_encode():
    hilfetext = """HILFE: [Polybios-Chiffre kodieren]
Die 5x5 Polybios-Chiffre kodiert Buchstaben zu zweistelligen
Zahlen dazu wird das Schlüsselalphabet in ein 5x5-Quadrat
eingetragen. Die Buchstaben werden dann sozusagen zu ihren
entsprechenden "Koordinaten" kodiert. Im unten gezeigten
Quadrat wird so aus A 11, aus B 12, aus Q 41, usw.  
Da in ein 5x5 Quadrat nur 25 Buchstaben passen wird
typischer Weise J und I zusammengefasst,
(alternativ auch U und V), sollen auch Ziffern kodiert
werden wird mit einem 6x6-Quadrat gearbeitet, bei welchem
dann für das komplette Alphabet und die Ziffern 0-9 Platz ist.
  1 2 3 4 5
1 A B C D E
2 F G H I K
3 L M N O P
4 Q R S T U
5 V W X Y Z
Kommt für die Chiffre ein Passwort zum Einsatz wird das 
Code-Quadrat so abgeändert wie es in der Hilfe zur
Woseley-Chiffre beschrieben ist.
Die Funktion ist so gestaltet, daß alle nicht im jeweiligen
Codealphabet vorhandenen Zeichen herausgefiltert werden.
Zur Information wird für jede Polybios-Variante auch noch
einmal der verwendete Klartext und das verwendete Passwort
ausgegeben wird.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ"  # v wird durch u ersetzt
        qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
               53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
        alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        text = text.upper()
        textij = text.replace("J", "I")
        textuv = text.replace("V", "U")
        pw = pw.upper()
        p_wi = pw.replace("J", "I")
        p_wu = pw.replace("V", "U")
        passw5ij = ""
        for i in p_wi:
            if i in alpha5ij:
                passw5ij += i
        passw5uv = ""
        for i in p_wu:
            if i in alpha5uv:
                passw5uv += i
        passw6 = ""
        for i in p_wi:
            if i in alpha6:
                passw6 += i
        text5ij = ""
        for i in textij:
            if i in alpha5ij or i == " ":
                text5ij += i
        text5uv = ""
        for i in textuv:
            if i in alpha5uv or i == " ":
                text5uv += i
        text6 = ""
        for i in text:
            if i in alpha6 or i == " ":
                text6 += i
        pw5ij = ""
        for b in p_wi + alpha5ij:
            if b in alpha5ij and b not in pw5ij:
                pw5ij += b
        pw5uv = ""
        for b in p_wu + alpha5uv:
            if b in alpha5uv and b not in pw5uv:
                pw5uv += b
        pw6 = ""
        for b in pw + alpha6:
            if b in alpha6 and b not in pw6:
                pw6 += b
        wb5ij = {" ": " "}
        for i in range(25):
            wb5ij[pw5ij[i]] = str(qz5[i])
        wb5uv = {" ": " "}
        for i in range(25):
            wb5uv[pw5uv[i]] = str(qz5[i])
        wb6 = {" ": " "}
        for i in range(36):
            wb6[pw6[i]] = str(qz6[i])
        ctext5ij = ""
        for b in text5ij:
            ctext5ij += wb5ij[b]
        ctext5uv = ""
        for b in text5uv:
            ctext5uv += wb5uv[b]
        ctext6 = ""
        for b in text6:
            ctext6 += wb6[b]
        Ausgabe.insert(1.0, ctext6 + "\n")
        Ausgabe.insert(1.0, "Passwort: " + passw6 + "\n", "gr")
        Ausgabe.insert(1.0, "Klartext: " + text6 + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 6x6\n", "bu")
        Ausgabe.insert(1.0, ctext5uv + "\n\n")
        Ausgabe.insert(1.0, "Passwort: " + passw5uv + "\n", "gr")
        Ausgabe.insert(1.0, "Klartext: " + text5uv + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 5x5 (v=u)\n", "bu")
        Ausgabe.insert(1.0, ctext5ij + "\n\n")
        Ausgabe.insert(1.0, "Passwort: " + passw5ij + "\n", "gr")
        Ausgabe.insert(1.0, "Klartext: " + text5ij + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 5x5 (j=i)\n", "bu")


def polybios_decode():
    hilfetext = """HILFE: [Polybios-Chiffre dekodieren]
Die 5x5 Polybios-Chiffre kodiert Buchstaben zu zweistelligen
Zahlen dazu wird das Schlüsselalphabet in ein 5x5-Quadrat
eingetragen. Die Buchstaben werden dann sozusagen zu ihren
entsprechenden "Koordinaten" kodiert. Im unten gezeigten
Quadrat wird so aus A 11, aus B 12, aus Q 41, usw.  
Da in ein 5x5 Quadrat nur 25 Buchstaben passen wird
typischer Weise J und I zusammengefasst,
(alternativ auch U und V), sollen auch Ziffern kodiert
werden wird mit einem 6x6-Quadrat gearbeitet, bei welchem
dann für das komplette Alphabet und die Ziffern 0-9 Platz ist.
  1 2 3 4 5
1 A B C D E
2 F G H I K
3 L M N O P
4 Q R S T U
5 V W X Y Z
Kommt für die Chiffre ein Passwort zum Einsatz wird das 
Code-Quadrat so abgeändert wie es in der Hilfe zur
Woseley-Chiffre beschrieben ist.
Die Funktion ist so gestaltet, daß alle nicht im jeweiligen
Codealphabet vorhandenen Zeichen herausgefiltert werden.
Zur Information wird für jede Polybios-Variante auch noch
einmal das verwendete Passwort ausgegeben wird.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha5ij = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha5uv = "ABCDEFGHIJKLMNOPQRSTUWXYZ"  # v wird durch u ersetzt
        qz6 = [11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52,
               53, 54, 55, 56, 61, 62, 63, 64, 65, 66]
        alpha6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        pw = pw.upper()
        p_wi = pw.replace("J", "I")
        p_wu = pw.replace("V", "U")
        passw5ij = ""
        for i in p_wi:
            if i in alpha5ij:
                passw5ij += i
        passw5uv = ""
        for i in p_wu:
            if i in alpha5uv:
                passw5uv += i
        passw6 = ""
        for i in p_wi:
            if i in alpha6:
                passw6 += i
        pw5ij = ""
        for b in p_wi + alpha5ij:
            if b in alpha5ij and b not in pw5ij:
                pw5ij += b
        pw5uv = ""
        for b in p_wu + alpha5uv:
            if b in alpha5uv and b not in pw5uv:
                pw5uv += b
        pw6 = ""
        for b in pw + alpha6:
            if b in alpha6 and b not in pw6:
                pw6 += b
        wb5ij = {" ": " "}
        for i in range(25):
            wb5ij[str(qz5[i])] = pw5ij[i]
        wb5uv = {" ": " "}
        for i in range(25):
            wb5uv[str(qz5[i])] = pw5uv[i]
        wb6 = {" ": " "}
        for i in range(36):
            wb6[str(qz6[i])] = pw6[i]
        text = text.split()
        ctext5ij = ""
        ctext5uv = ""
        ctext6 = ""
        for wort in text:
            for i in range(0, len(wort), 2):
                cc = wort[i:i + 2]
                if cc in wb5ij:
                    ctext5ij += wb5ij[cc]
                if cc in wb5uv:
                    ctext5uv += wb5uv[cc]
                if cc in wb6:
                    ctext6 += wb6[cc]
            ctext5ij += " "
            ctext5uv += " "
            ctext6 += " "
        Ausgabe.insert(1.0, ctext6 + "\n")
        Ausgabe.insert(1.0, "Passwort: " + passw6 + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 6x6\n", "bu")
        Ausgabe.insert(1.0, ctext5uv + "\n\n")
        Ausgabe.insert(1.0, "Passwort: " + passw5uv + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 5x5 (v=u)\n", "bu")
        Ausgabe.insert(1.0, ctext5ij + "\n\n")
        Ausgabe.insert(1.0, "Passwort: " + passw5ij + "\n", "gr")
        Ausgabe.insert(1.0, "Polybios 5x5 (j=i)\n", "bu")


def klopfcode_encode():
    hilfetext = """HILFE: [Klopfcode kodieren]
Der Klopfcode ist im Prinzip eine Polybios Chiffre 
mit einem festen Schlüsselquadrat bei welchem nicht
I und J sondern C und K zusammengefasst werden.
siehe hier:
  1 2 3 4 5
1 A B C D E
2 F G H I J
3 L M N O P
4 Q R S T U
5 V W X Y Z
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        qz5 = [11, 12, 13, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha = "ABCDEFGHIJLMNOPQRSTUVWXYZ"  # k wird durch c ersetzt
        text = text.upper()
        text = text.replace("K", "C")
        text5 = ""
        for i in text:
            if i in alpha or i == " ":
                text5 += i
        wb5 = {" ": " "}
        for i in range(25):
            wb5[alpha[i]] = str(qz5[i])
        ctext = ""
        for b in text5:
            ctext += wb5[b]
        Ausgabe.insert(1.0, ctext + "\n")
        Ausgabe.insert(1.0, "Klartext: " + text5 + "\n", "gr")


def klopfcode_decode():
    hilfetext = """HILFE: [Klopfcode dekodieren]
Der Klopfcode ist im Prinzip eine Polybios Chiffre 
mit einem festen Schlüsselquadrat bei welchem nicht
I und J sondern C und K zusammengefasst werden.
siehe hier:
  1 2 3 4 5
1 A B C D E
2 F G H I J
3 L M N O P
4 Q R S T U
5 V W X Y Z
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        qz5 = [11, 12, 14, 15, 21, 22, 23, 24, 25, 31, 32, 33, 34, 35, 41, 42, 43, 44, 45, 51, 52, 53, 54, 55]
        alpha = "ABDEFGHIJLMNOPQRSTUVWXYZ"  # k wird durch c ersetzt
        wb = {" ": " ", "13": "[C/K]"}
        for i in range(24):
            wb[str(qz5[i])] = alpha[i]
        text = text.split()
        ctext = ""
        for wort in text:
            for i in range(0, len(wort), 2):
                cc = wort[i:i + 2]
                if cc in wb:
                    ctext += wb[cc]
            ctext += " "
        Ausgabe.insert(1.0, ctext + "\n")
        Ausgabe.insert(1.0, "Klopfcode dekodiert:\n", "bu")


def maptiles_kachelkoordinaten():
    hilfetext = """HILFE: [Maptiles / Kachelkoordinaten]
Bei vielen Online-Kartendiensten wie Openstreetmap oder Google-Maps erfolgt die
Kartendarstellung über vorberechnete "Kachel"-Grafikdateien, welche ein 
Adressierungssystem benötigen damit je nach Koordinate und Zoomstufe auch der
richtige Kartenausschnitt dargestellt und klar ist welche Kacheln daneben
darzustellen ist wird.Bei OSM ist eine solche Kachel eine PNG-Grafik mit 256x256
Pixeln und je nach Zoomstufe ist eine unterschiedliche Anzahl solcher 
Kacheln/Tiles notwendig um die ganze Welt abzubilden. Da je Zoomstufe sich die
Anzahl der benötigten Kacheln vervierfacht ist bei den meisten Diensten bei
Zoomlevel 18 Schluß, OSM geht bis Zoomlevel 19.
Um die einzelnen Kacheln beim tilemap-Server abzufragen braucht man die
Zoomstufe, einen X und einen Y-Wert wobei dies alles ganzzahlige Werte sind.
Aufgerufen von den Servern werden die Kacheln dann nach dem Muster:
"http://servername/Zoom/X/Y.png" Den Fernsehturm mit Zoomstufe 18 findet man
z.B. bei Openstreetmap hier:https://tile.openstreetmap.org/18/140836/85970.png

Die Funktion arbeitet hier auf die Art und Weise, daß man 2 durch ein 
Freizeichen getrennte Zahlen eingibt. Handelt es sich bei den angegebenen Zahlen
um "Kommazahlen" welche allerdings mit Punkt anzugeben sind 
(Bsp: 52.520803 13.4088653 ) geht die Funktion davon aus, daß es sich um 
Koordinaten in Dezimalgrad handelt und sofern es gültige Koordinaten sind 
erfolgt eine Ausgabe der X und Y Werte für die Zoomstufen und 1-30.
(Positive Zahlen stehen für Nord und Ost, negative für Süd und West)

Handelt es sich bei den beiden Zahlen um Ganzzahlen wird davon ausgegangen, daß
es sich um X und Y Werte handelt und es werde für alle Zoomstufen von 1-30
Koordinaten in Dezimalminuten und Dezimalgrad ausgegeben, sofern dies sinnvolle
Koordinaten ergibt.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        text = text.split()
        if "." in text[0] and len(text) == 2:
            for zoom in range(30, 0, -1):
                try:
                    la = float(text[0])
                    lo = float(text[1])
                    if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
                        x, y = dec_to_maptiles(la, lo, zoom)
                        Ausgabe.insert(1.0, "Zoom:{:>2}  X:{:<10} Y:{}\n".format(zoom, x, y))
                except ValueError:
                    pass
            Ausgabe.insert(1.0, "DEC -> Maptiles\n", "bu")
        elif len(text) == 2:
            for zoom in range(30, 0, -1):
                try:
                    la, lo = maptiles_to_dec(int(text[0]), int(text[1]), zoom)
                    if not la < -180 and not la > 180 and not lo < -180 and not lo > 180:
                        Ausgabe.insert(1.0, "Zoom:{:>2} DEG: {:<23} DEC: {} {}\n".format(zoom, dec_to_deg(la, lo),
                                                                                         round(la, 5), round(lo, 5)))
                except ValueError:
                    pass
            Ausgabe.insert(1.0, "Maptiles->DEG,DEC\n", "bu")
        else:
            Ausgabe.insert(1.0, "Zahlen konnten nicht ermittelt werden!\n", "re")


def quadtreekoordinaten():
    hilfetext = """HILFE: [Quadtree-/Quadkeykoordinaten]
Diese Koordinatenkodierung spielt in der alltäglichen Praxis eigentlich
kaum noch ein Rolle, außer scheinbar bei bing-maps und beim Geocaching.
Sie dient ähnlich wie das Maptiles-System dazu Grafikdateien für
unterschiedliche Zoomstufen einer Karte zu adressieren.
Die Länge der Zahl entspricht hier zugleich auch dem Detailgrad bzw.
der Zoomstufe. Es finden nur die Zahlen 0,1,2 und 3 Verwendung, wobei
die 0 den Nordwestlichen Quadranten, 1 den Nordöstlichen, 2 SW und 3 SO.
Ein kleines Beispiel: 230 würde bedeuten es geht im südwestlichen 
Quadranten (2) um den südöstlichen Quadranten(3) und in diesem wiederum
um den nordwestlichen Quadranten.
Je länger also diese Zahlenreihe aus 0,1,2 und 3 wird um so genauer wird
ein bestimmter Ort angegeben.
Weitere Infos gibt es unter folgendem Link zu finden:
https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system

Die Funktion ermittelt aus einer Quadtreekoordinate die Maptileskoordinaten
und die WGS-Koordinaten.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        tilex = 0
        tiley = 0
        quadkey = text
        fehler = 0
        zoom = len(quadkey)
        for i in range(zoom, 0, -1):
            mask = 1 << (i - 1)
            if quadkey[zoom - i] == "0":
                continue
            if quadkey[zoom - i] == "1":
                tilex |= mask
                continue
            if quadkey[zoom - i] == "2":
                tiley |= mask
                continue
            if quadkey[zoom - i] == "3":
                tilex |= mask
                tiley |= mask
                continue
            else:
                fehler += 1
        la, lo = maptiles_to_dec(tilex, tiley, zoom)
        if fehler == 0:
            Ausgabe.insert(1.0, "DEG: {}\n".format(dec_to_deg(la, lo)))
            Ausgabe.insert(1.0, "DEC: {} {}\n".format(round(la, 5), round(lo, 5)))
            Ausgabe.insert(1.0, "Maptiles: X:{} Y:{} Zoom:{}\n".format(tilex, tiley, zoom))
        else:
            Ausgabe.insert(1.0,
                           "Es konnte keine gültige Quadtree-Koordinate erkannt werden.\n"
                           "(eine Zahl die nur die Ziffern 0,1,2,3 enthält)\n")


def chronogramm():
    hilfetext = """HILFE: [Chronogramm/ römische Ziffern zählen]
Ein Chronogramm (oder Eteostichon) ist ein Satzteil, ein Satz, ein Sinnspruch
oder eine Inschrift, meist ein Vers in lateinischer Sprache, in dem diejenigen
Buchstaben, die auch als römische Zahlzeichen gelesen werden können 
(I, V, X, L, C, D, M), in ihrer Summe die Jahreszahl des Ereignisses angeben,
auf das sich der Text bezieht. Entscheidend ist allein die Summe der
Zahlenwertbuchstaben, die sonst bei römischen Zahlen übliche Subtraktion
kleinerer Zahlenwerte von folgenden größeren erfolgt nicht.
Die Zahlbuchstaben sind meist hervorgehoben, etwa durch Großschreibung oder
Verdickung der Buchstaben bzw. durch farbliche Abhebung mittels Rötung oder
Vergoldung. Eine Besonderheit bilden Krypto(chrono)gramme, bei denen die
Zahlbuchstaben nicht gekennzeichnet sind und "verborgen" bleiben.

Bei der einfachen Analyse werden hier die Buchstaben I(1),V(5),X(10),L(50),
C(100), D(500), M(1000) berücksichtigt und addiert, bei der erweiterten
Analyse wird zunächst einmal berücksichtigt, daß im Lateinischen Alphabet
der Buchstabe J als I und der Buchstabe U als V geschrieben wird. Außerdem
erfolgt wird in der extremen Variante auch noch W=10(V+V) und Y=2(I+I)
berücksichtigt. Desweiteren wird auch für jeden relevanten Buchstaben
einzeln noch einmal die Anzahl und Summe angezeigt.
Eine Unterscheidung zwischen Klein- und Großschreibung findet nicht statt.
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        text = text.upper()
        i, v, x, ll, c, d, m, y, w, u, j = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        for r_chr in text:
            if r_chr == "I":
                i += 1
            if r_chr == "V":
                v += 1
            if r_chr == "X":
                x += 1
            if r_chr == "L":
                ll += 1
            if r_chr == "C":
                c += 1
            if r_chr == "D":
                d += 1
            if r_chr == "M":
                m += 1
            if r_chr == "U":
                u += 1
            if r_chr == "J":
                j += 1
            if r_chr == "Y":
                y += 1
            if r_chr == "W":
                w += 1
        sum_einfach = i + (v * 5) + (x * 10) + (ll * 50) + (c * 100) + (d * 500) + (m * 1000)
        sum_erweitert = sum_einfach + (u * 5) + j
        sum_extrem = sum_erweitert + (y * 2) + (w * 10)
        Ausgabe.insert(1.0, "Summe extrem(inkl.J,U,Y,W): {}\n".format(sum_extrem))
        Ausgabe.insert(1.0, "Summe erweitert(inkl. I,U): {}\n".format(sum_erweitert))
        Ausgabe.insert(1.0, "Summe einfach(I,V,X,L,C,D,M): {}\n".format(sum_einfach))
        Ausgabe.insert(1.0, "W(V+V=10):{:5}x \tSumme W: {}\n".format(w, w * 10), "gr")
        Ausgabe.insert(1.0, " Y(I+I=2):{:5}x \tSumme Y: {}\n".format(y, y * 2), "gr")
        Ausgabe.insert(1.0, "   U(V=5):{:5}x \tSumme U: {}\n".format(u, u * 5), "gr")
        Ausgabe.insert(1.0, "   J(I=1):{:5}x \tSumme U: {}\n".format(j, j), "gr")
        Ausgabe.insert(1.0, "  M(1000):{:5}x \tSumme M: {}\n".format(m, m * 1000), "gr")
        Ausgabe.insert(1.0, "   D(500):{:5}x \tSumme D: {}\n".format(d, d * 500), "gr")
        Ausgabe.insert(1.0, "   C(100):{:5}x \tSumme C: {}\n".format(c, c * 100), "gr")
        Ausgabe.insert(1.0, "    L(50):{:5}x \tSumme L: {}\n".format(ll, ll * 50), "gr")
        Ausgabe.insert(1.0, "    X(10):{:5}x \tSumme X: {}\n".format(x, x * 10), "gr")
        Ausgabe.insert(1.0, "     V(5):{:5}x \tSumme V: {}\n".format(v, v * 5), "gr")
        Ausgabe.insert(1.0, "     I(1):{:5}x \tSumme I: {}\n".format(i, i), "gr")


def adfgx_kodieren():
    hilfetext = """HILFE: [ADFGX kodieren]
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen 
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei 
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden. 
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
 5 1 4 6 2 3    in der Breite des Passwort Zeilenweise darunter geschrieben,
 T E S T E R    nun werden diese Spalten dem Passwort entsprechend 
 F A F X G G    alphabetisch sortiert und dann von oben nach unten abgelesen.
 D F F A F X    Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
 A F A A F X    zweite E, dann R usw. was dann als kodierten Text, welcher
 F A G D        typischer Weise in 5er-Blöcken ausgegeben wird folgendes
                ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A. 
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
              "GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
        alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
        text = text.upper()
        text = text.replace("J", "I")
        pw = pw.upper()
        pw = pw.replace("J", "I")
        pw = pw.split(",")
        if len(pw) != 2:
            Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
            return
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        pw1az = ""
        for b in pw[0] + alpha_az:
            if b in alpha_az and b not in pw1az:
                pw1az += b
        pw1za = ""
        for b in pw[0] + alpha_za:
            if b in alpha_za and b not in pw1za:
                pw1za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az:
                pw2 += i
        klartext = ""
        for i in text:
            if i in alpha_az:
                klartext += i
        w_baz = {}
        for i in range(25):
            w_baz[pw1az[i]] = rn[i]
        w_bza = {}
        for i in range(25):
            w_bza[pw1za[i]] = rn[i]
        ctext1az = ""
        for b in klartext:
            ctext1az += w_baz[b]
        print(ctext1az)
        ctext1za = ""
        for b in klartext:
            ctext1za += w_bza[b]
        ctext2az = []
        for i in range(len(pw2)):
            ctext2az.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1az)):
            ctext2az[i % len(pw2)].append(ctext1az[i])
        ctext2az.sort()
        ausgabe_az = ""
        z = 1
        for i in ctext2az:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_az += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_az += i[j + 1]
                    z += 1
        ctext2za = []
        for i in range(len(pw2)):
            ctext2za.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1za)):
            ctext2za[i % len(pw2)].append(ctext1za[i])
        ctext2za.sort()
        ausgabe_za = ""
        z = 1
        for i in ctext2za:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_za += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_za += i[j + 1]
                    z += 1
        Ausgabe.insert(1.0, ausgabe_za + "\n")
        Ausgabe.insert(1.0, "kodiert mit Variante Z-A:\n")
        Ausgabe.insert(1.0, ausgabe_az + "\n")
        Ausgabe.insert(1.0, "kodiert mit Variante A-Z:\n")
        Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
        Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")


def adfgx_dekodieren():
    hilfetext = """HILFE: [ADFGX dekodieren]
Die ADFGX-Chiffre arbeitet mit zwei Passwörtern, wobei jedes für je einen 
Kodierungsschritt verwendet wird. Das erste wird benutzt um eine Variation
der Polybios-Kodierung mit einem 5x5 Quadrat und J=I durchzuführen bei 
welcher die Zahlen 1-5 durch die Buchstaben ADFGX ersetzt werden. 
Mit dem Text "Ein Beispiel",dem Passwort "PASSWORT" und einem
mit A->Z aufgefülltem Schlüsselquadrat ergibt der erste Schritt z.B. die
Zeichenfolge: "FA FX GG DF FA FX AF AA FX FA GD". Nun kommt das zweite Passwort
zum Einsatz als Beispiel hier:"Tester". Zunächst einmal wird die Zeichenfolge
 5 1 4 6 2 3    in der Breite des Passwort Zeilenweise darunter geschrieben,
 T E S T E R    nun werden diese Spalten dem Passwort entsprechend 
 F A F X G G    alphabetisch sortiert und dann von oben nach unten abgelesen.
 D F F A F X    Im Beispiel fängt es also mit der Spalte 1 dem E an dann das
 A F A A F X    zweite E, dann R usw. was dann als kodierten Text, welcher
 F A G D        typischer Weise in 5er-Blöcken ausgegeben wird folgendes
                ergibt: AFFAG FFGXX FFAGF DAFXA AD ergibt.
Die beiden Varianten, welche ausgegeben werden, unterscheiden sich nur
darin, wie das Schlüsselquadrat im ersten Kodierungsschritt aufgefüllt
wird. Entweder in alphabetischer Reihenfolge A->Z oder umgekehrt Z->A. 
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        rn = ["AA", "AD", "AF", "AG", "AX", "DA", "DD", "DF", "DG", "DX", "FA", "FD", "FF", "FG", "FX", "GA", "GD",
              "GF", "GG", "GX", "XA", "XD", "XF", "XG", "XX"]
        alpha_az = "ABCDEFGHIKLMNOPQRSTUVWXYZ"  # j wird durch i ersetzt
        alpha_za = "ZYXWVUTSRQPONMLKIHGFEDCBA"
        text = text.upper()
        text = text.replace("J", "I")
        pw = pw.upper()
        pw = pw.replace("J", "I")
        pw = pw.split(",")
        if len(pw) != 2:
            Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
            return
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        pw1az = ""
        for b in pw[0] + alpha_az:
            if b in alpha_az and b not in pw1az:
                pw1az += b
        pw1za = ""
        for b in pw[0] + alpha_za:
            if b in alpha_za and b not in pw1za:
                pw1za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az:
                pw2 += i
        ctext = ""
        for i in text:
            if i in alpha_az:
                ctext += i
        w_baz = {}
        for i in range(25):
            w_baz[rn[i]] = pw1az[i]
        w_bza = {}
        for i in range(25):
            w_bza[rn[i]] = pw1za[i]
        ret = ['_'] * len(ctext)
        lt, lp = len(ctext), len(pw2)
        t1 = [(pw2[i], i) for i in range(len(pw2))]
        ind = [q[1] for q in sorted(t1)]
        upto = 0
        for i in range(len(pw2)):
            tic = int(lt / lp)
            if ind[i] < lt % lp:
                tic += 1
            ret[ind[i]::lp] = ctext[upto:upto + tic]
            upto += tic
        ctext = ''.join(ret)
        klartext_az = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_baz:
                klartext_az += w_baz[bi]
        klartext_za = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_bza:
                klartext_za += w_bza[bi]
        Ausgabe.insert(1.0, klartext_za + "\n")
        Ausgabe.insert(1.0, "dekodiert mit Variante Z-A:\n")
        Ausgabe.insert(1.0, klartext_az + "\n")
        Ausgabe.insert(1.0, "dekodiert mit Variante A-Z:\n")
        Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
        Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")


def adfgvx_kodieren():
    hilfetext = """HILFE: [ADFGVX kodieren]
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
wird (A->Z + 0->9 oder 9->0 + Z->A). 
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
              "FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
              "XV", "XX"]
        alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
        text = text.upper()
        pw = pw.upper()
        pw = pw.split(",")
        if len(pw) != 2:
            Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
            return
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        pw1az09 = ""
        for b in pw[0] + alpha_az09:
            if b in alpha_az09 and b not in pw1az09:
                pw1az09 += b
        pw190za = ""
        for b in pw[0] + alpha_90za:
            if b in alpha_90za and b not in pw190za:
                pw190za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az09:
                pw2 += i
        klartext = ""
        for i in text:
            if i in alpha_az09:
                klartext += i
        w_baz09 = {}
        for i in range(36):
            w_baz09[pw1az09[i]] = rn[i]
        wb90za = {}
        for i in range(36):
            wb90za[pw190za[i]] = rn[i]
        ctext1az09 = ""
        for b in klartext:
            ctext1az09 += w_baz09[b]
        ctext190za = ""
        for b in klartext:
            ctext190za += wb90za[b]
        ctext2az09 = []
        for i in range(len(pw2)):
            ctext2az09.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext1az09)):
            ctext2az09[i % len(pw2)].append(ctext1az09[i])
        ctext2az09.sort()
        ausgabe_az09 = ""
        z = 1
        for i in ctext2az09:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_az09 += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_az09 += i[j + 1]
                    z += 1
        ctext290za = []
        for i in range(len(pw2)):
            ctext290za.append([pw2[i] + str(i + 10)])
        for i in range(len(ctext190za)):
            ctext290za[i % len(pw2)].append(ctext190za[i])
        ctext290za.sort()
        ausgabe_90za = ""
        z = 1
        for i in ctext290za:
            for j in range(len(i) - 1):
                if z == 5:
                    ausgabe_90za += i[j + 1] + " "
                    z = 1
                else:
                    ausgabe_90za += i[j + 1]
                    z += 1
        Ausgabe.insert(1.0, ausgabe_90za + "\n")
        Ausgabe.insert(1.0, "kodiert mit Variante 9-0,Z-A:\n")
        Ausgabe.insert(1.0, ausgabe_az09 + "\n")
        Ausgabe.insert(1.0, "kodiert mit Variante A-Z,0-9:\n")
        Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
        Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")


def adfgvx_dekodieren():
    hilfetext = """HILFE: [ADFGVX dekodieren]
Die ADFGVX-Chiffre erweitert das 5x5-Schlüsselquadrat der ADFGX-Chiffre
ersten Kodierungsschritt auf 6x6 so, daß das komplette Alphabet und die
Zahlen 0-9 verwendet werden können. Die beiden ausgegebenen Varianten
unterscheiden sich in der Variante wie das Schlüsselquadrat aufgefüllt
wird (A->Z + 0->9 oder 9->0 + Z->A). 
"""
    
    eingabetext = Eingabe.get(1.0, END)
    text = eingabetext.rstrip()
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if text == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        rn = ["AA", "AD", "AF", "AG", "AV", "AX", "DA", "DD", "DF", "DG", "DV", "DX", "FA", "FD", "FF", "FG", "FV",
              "FX", "GA", "GD", "GF", "GG", "GV", "GX", "VA", "VD", "VF", "VG", "VV", "VX", "XA", "XD", "XF", "XG",
              "XV", "XX"]
        alpha_az09 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
        alpha_90za = "9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA"
        text = text.upper()
        pw = pw.upper()
        pw = pw.split(",")
        if len(pw) != 2:
            Ausgabe.insert(1.0, "Es es werden genau zwei durch Komma getrennte Passwörter benötigt!\n", "re")
            return
        pw[0] = pw[0].strip()
        pw[1] = pw[1].strip()
        pw1az09 = ""
        for b in pw[0] + alpha_az09:
            if b in alpha_az09 and b not in pw1az09:
                pw1az09 += b
        pw190za = ""
        for b in pw[0] + alpha_90za:
            if b in alpha_90za and b not in pw190za:
                pw190za += b
        pw2 = ""
        for i in pw[1]:
            if i in alpha_az09:
                pw2 += i
        ctext = ""
        for i in text:
            if i in alpha_az09:
                ctext += i
        w_baz09 = {}
        for i in range(36):
            w_baz09[rn[i]] = pw1az09[i]
        wb90za = {}
        for i in range(36):
            wb90za[rn[i]] = pw190za[i]
        ret = ['_'] * len(ctext)
        lt, lp = len(ctext), len(pw2)
        t1 = [(pw2[i], i) for i in range(len(pw2))]
        ind = [q[1] for q in sorted(t1)]
        upto = 0
        for i in range(len(pw2)):
            tic = int(lt / lp)
            if ind[i] < lt % lp:
                tic += 1
            ret[ind[i]::lp] = ctext[upto:upto + tic]
            upto += tic
        ctext = ''.join(ret)
        klartext_az09 = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in w_baz09:
                klartext_az09 += w_baz09[bi]
        klartext_90za = ""
        for i in range(0, len(ctext), 2):
            bi = ctext[i:i + 2]
            if bi in wb90za:
                klartext_90za += wb90za[bi]
        Ausgabe.insert(1.0, klartext_90za + "\n")
        Ausgabe.insert(1.0, "dekodiert mit Variante 0-0,Z-A:\n")
        Ausgabe.insert(1.0, klartext_az09 + "\n")
        Ausgabe.insert(1.0, "dekodiert mit Variante A-Z,0-9:\n")
        Ausgabe.insert(1.0, "Passwort 2: {}\n".format(pw2), "gr")
        Ausgabe.insert(1.0, "Passwort 1: {}\n".format(pw[0]), "gr")


def zahlen_roemisch_arabisch_umwandeln():
    hilfetext = """HILFE: [Römische in Arabische Zahlen umwandeln und umgekehrt]
Es werden römische Zahlen in arabische umgewandelt und umgekehrt, die Funktion
arbeitet dabei bei der Umwandlung von arabisch zu römisch mit Werten bis
maximal 500000. Es werden folgende Zeichen verwendet: I=1, V=5, X=10, L=50,
C=100, D=500, M=1000, \u2181=5000, \u2182=10000, \u2187=50000, \u2188=100000
Etwas Vorsicht sollte bei einer Umwandlung von römischen in arabische Zahlen
geboten sein, wenn mit untypischen Schreibweisen gearbeitet wird bei welchen
mehr als ein Zeichen von dem nachfolgenden Zeichen abgezogen werden soll.
Die eigentlich inkorrekte Schreibweise IIX für die Zahl 8 wird hier die Zahl
10 als Ergebnis haben (+1-1+10), dafür wird aber allerdings die ebenfalls
falsche Schreibweise IM genauso als 999 wie die korrekte Schreibweise CMXCIX
erkannt.
"""
    rza = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000, '\u2181': 5000, '\u2182': 10000,
           '\u2187': 50000, '\u2188': 100000}
    azr = [(100000, '\u2188'), (90000, '\u2182\u2188'), (50000, '\u2187'), (40000, '\u2182\u2187'),
           (10000, '\u2182'), (9000, 'M\u2182'), (5000, '\u2181'), (4000, 'M\u2181'), (1000, 'M'), (900, 'CM'),
           (500, 'D'),
           (400, 'CD'), (100, 'C'), (90, 'XC'), (50, 'L'), (40, 'XL'), (10, 'X'), (9, 'IX'), (5, 'V'), (4, 'IV'),
           (1, 'I')]
    
    eingabetext = Eingabe.get(1.0, END)
    rz = eingabetext.rstrip()
    if rz == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        rz = rz.upper()
        try:
            az = 0
            for i in range(len(rz)):
                if i == len(rz) - 1:
                    az += rza[rz[i]]
                    Ausgabe.insert(1.0, "{} = {}\n".format(rz, az))
                else:
                    if rza[rz[i]] < rza[rz[i + 1]]:
                        az -= rza[rz[i]]
                    else:
                        az += rza[rz[i]]
        except KeyError:
            try:
                zahl = int(rz)
                if zahl > 500000:
                    Ausgabe.insert(1.0, "arabische Zahlen größer als 500000 mag ich nicht in römische Zahlen!\n", "re")
                    return
                rom = ""
                for az, romz in azr:
                    count = zahl // az
                    zahl -= az * count
                    rom += romz * count
                Ausgabe.insert(1.0, "{} = {}\n".format(rz, rom))
            except ValueError:
                Ausgabe.insert(1.0, "Es konnte keine römische oder arabische Zahl erkannt werden!\n", "re")


def euler_suche():
    hilfetext = """HILFE: [Eulersche Zahl - Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von e (2.71828182845904523.....) zu ermitteln.

Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen 
wird die Datei e.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl e mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit 
dem Tool y-cruncher (http://numberworld.org/y-cruncher/) 
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und e.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            eread = open("./data/e.txt", "r")
        except FileNotFoundError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            estr = ""
            for zeile in eread:
                estr = estr + zeile.rstrip()
            eread.close()
            elen = len(estr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
            else:
                pos = estr.find(eingabetext)
                if pos == -1:
                    Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(elen), "re")
                else:
                    Ausgabe.insert(1.0,
                                   "20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, estr[pos:pos + 20]))
                    Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
                        eingabetext.rstrip(), pos - 1))
                if elen >= zahlx > 0:
                    Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle:"
                                        " {}...\n\n".format(zahlx, estr[zahlx + 1:zahlx + 21]))
                    Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, estr[zahlx + 1]))
                else:
                    Ausgabe.insert(1.0, "Die verwendete e.txt kennt leider nur {} Nachkommstellen.\n\n".format(elen),
                                   "re")
                Ausgabe.insert(1.0, "e (Eulersche Zahl)\n\n", "gr")


def goldener_schnitt_suche():
    hilfetext = """HILFE: [phi(Goldener Schnitt) Nachkommastellensuche]
Für die eingegebene Zahl/Zahlenreihe X wird versucht die
entsprechende X. Nachkommastelle auszugeben und das erst
Vorkommen der Zahlenreihe X innerhalb der Nachkommastellen
von phi (1.6180339887498948482045...) zu ermitteln.

Da es deutlich schnneller geht mit einer vorgefertigten
Datei zu suchen als die Nachkommastellen zu berechnen 
wird die Datei phi.txt im Unterverzeichnis "data" benötigt.
Diese Datei enthält die Zahl phi mit den ersten 10 Millionen
Nachkommastellen. Wer mehr Stellen braucht, kann sich mit 
dem Tool y-cruncher (http://numberworld.org/y-cruncher/) 
auch eine Datei mit deutlich mehr Nachkommastellen erstellen
und phi.txt damit ersetzen. (Bei 1 Millarde Stellen ist
die Datei dann allerdings schon knapp 1 GB groß und
die Abfrage dauert auch etwas länger)
"""
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, hilfetext + "\n")
    else:
        try:
            phiread = open("./data/phi.txt", "r")
        except ValueError:
            Ausgabe.insert(1.0, hilfetext + "\n")
        else:
            phistr = ""
            for zeile in phiread:
                phistr = phistr + zeile.rstrip()
            phiread.close()
            philen = len(phistr) - 2
            try:
                zahlx = int(eingabetext)
            except ValueError:
                Ausgabe.insert(1.0, "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!\n", "re")
            else:
                pos = phistr.find(eingabetext)
                if pos == -1:
                    Ausgabe.insert(1.0, "Zahlenreihe in {} Nachkommastellen nicht zu finden.\n\n".format(philen), "re")
                else:
                    Ausgabe.insert(1.0,
                                   "20 Stellen ab {}. Nachkommstelle: {}...\n\n".format(pos - 1, phistr[pos:pos + 20]))
                    Ausgabe.insert(1.0, 'erstes Vorkommen von Zahlenfolge "{}" ab {}. Nachkommastelle\n'.format(
                        eingabetext.rstrip(), pos - 1))
                if philen >= zahlx > 0:
                    Ausgabe.insert(1.0, "20 Stellen ab {}. Nachkommstelle:"
                                        " {}...\n\n".format(zahlx, phistr[zahlx + 1:zahlx + 21]))
                    Ausgabe.insert(1.0, "Die {}. Nachkommstelle: lautet {}\n".format(zahlx, phistr[zahlx + 1]))
                else:
                    Ausgabe.insert(1.0, "Die verwendete pi.txt kennt leider nur {} Nachkommstellen.\n".format(philen),
                                   "re")
                Ausgabe.insert(1.0, "Phi (Goldener Schnitt)\n\n", "gr")


def url_decode():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [URL-decode]
Nachdem Groundspeak nun inzwischen sämtliche Bilddateien
über einen Proxy umleitet bevor sie im Listing erscheinen
wird es manchmal schwer die ursprüngliche URL und/oder
den Dateinamen des Bildes noch lesen zu können.
Die URL hat dort nun jeweils folgendes Muster:
https://imgproxy.geocaching.com/......?url=.....
wobei nach dem ?url= dann die ursprüngliche Bild-URL
folgt, allerdings wird dabei dann aus 
http:// folgendes http%3A%2F%2F und um genau dieses
wieder normal lesbar zu machen dient diese Funktion\n\n""")
    else:
        atxt = urllib_parse_unquote(eingabetext)
        Ausgabe.insert(1.0, atxt + "\n")
        Ausgabe.insert(1.0, "dekodierte URL:\n", "bu")


def reversewig():
    seperator = ("|,", "_", "/", ";", ",")
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Reverse Wherigo zu Koordinaten]
Mit dem Reverse Wherigo hat -Waldmeister- eigentlich eine coole Sache
erfunden. Man hat anfangs keine Koordinaten sondern nur 3 Zahlen, welche
man nach Start des Wherigo-Cartridges eingibt und dann erfährt man wie weit
der Cache entfernt ist. Nun kann man immer wieder von unterschiedlichen
Positionen aus diese Entfernungsfragen durchführen und sich damit dem
Cache nähern. Je weniger Abfragen man braucht umso besser.
Leider gibt es inzwischen genügend Tools die genau wie diese Funktion
hier aus den 3 Zahlen direkt die Finalkoordinaten ermitteln können.
Leider??? Ja leider denn das führt auch dazu, das es inzwischen so extrem
viele dieser Reverse-Wherigos gibt wo sich die Owner anscheinend auch
denken "Die spielt doch sowieso keiner mehr normal..." anders kann ich
mir ganze Trails mit Reverse-Wherigos nicht erklären.

Um die Funktion zu nutzen braucht man nur die 3 Zahlen durch ein entsprechendes
Trennzeichen: | , _ / ; , oder Leerzeichen eingeben und auf den Knopp klicken
und bekommt Koordinaten. 

""" + "\n\n")
    else:
        se = ""
        for s in seperator:
            if s in eingabetext:
                se = s
        if se == "" and " " in eingabetext:
            se = " "
        if se == "":
            Ausgabe.insert(1.0, "Keine gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!\n", "re")
        else:
            txt = eingabetext.split(se)
            if len(txt) == 3:
                error = 0
                for z in txt:
                    try:
                        int(z)
                    except ValueError:
                        Ausgabe.insert(1.0, "Bitte die Eingabezahlen überprüfen\n", "re")
                        error += 1
                if error == 0:
                    final = rwig_to_coords(txt[0], txt[1], txt[2])
                    Ausgabe.insert(1.0, "DEG: " + dec_to_deg(final[0], final[1]) + "\n")
                    Ausgabe.insert(1.0, "DEC: " + str(final[0]) + " " + str(final[1]) + "\n")
                    Ausgabe.insert(1.0, "WIG: " + txt[0] + ", " + txt[1] + ", " + txt[2] + "\n")

            else:
                Ausgabe.insert(1.0, "Es wurden nicht 3 Zahlen erkannt.\n", "re")


def base64_ascii():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.rstrip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [Base64 <-> ASCII]
Base64 ist ein Kodierungsverfahren, welches dazu verwendet wird
um beliebige Binärdaten nur Hilfe einer Zeichenkette aus A-Z,
a-z, 0-9, +, / sowie am Ende = übertragen zu können. Ein Einsatzzweck
dafür ist z.B. wenn bei EMails Dateianhänge verwendet werden, dort
werden nahezu alle Dateiformate base64-kodiert übertragen.
Auch bei dem einem oder anderen Mystery sind mir solche kodierten
Zeichenketten schon begegnet. Wenn am Ende einer Zeichenkette ein
oder zwei "="-Zeichen stehen ist die Wahrscheinlichkeit recht groß,
das hier base64 verwendet wurde. Das "="-Zeichen dient hier nämlich
als "Lückenfüller" am Ende.
Die Funktion hier versucht zunächst eine Dekodierung Base64->ASCII
gelingt dies nicht, erscheint ein Hinweis und der eingegeben Text
wird dann Base64-kodiert ausgegeben. 
""" + "\n\n")
    else:
        try:
            ascii_string = binascii.a2b_base64(eingabetext).decode()
            Ausgabe.insert(1.0, ascii_string + "\n")
            Ausgabe.insert(1.0, "Base64 -> ASCII:\n", "bu")
        except ValueError:
            base64_string = binascii.b2a_base64(eingabetext.encode())
            Ausgabe.insert(1.0, base64_string.decode() + "\n")
            Ausgabe.insert(1.0, "ASCII -> Base64:\n", "bu")
            Ausgabe.insert(1.0, "Umwandlung Base64 -> ASCII war nicht möglich.\n", "re")


def rail_encrypt(plain_text: str, rails: int):
    arr = [["" for _ in range(len(plain_text))] for _ in range(rails)]
    r = 0
    z = 0
    plus = True
    for b in plain_text:
        arr[r][z] = b
        z += 1
        if r + 1 == rails and plus:
            plus = False
            r -= 1
        elif r - 1 < 0 and not plus:
            plus = True
            r += 1
        elif plus:
            r += 1
        else:
            r -= 1
    out = ""
    for i in range(rails):
        for j in range(len(plain_text)):
            out += arr[i][j]
    return out


def jaegerzaun_encrypt():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.strip().replace("\n", " ")
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [encrypt Jägerzaun]
Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt)
Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster
in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist
schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1
weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw.
Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben.
Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich
vielen Zeilen arbeitet welche im Schlüsselfeld anzugeben ist.

Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen
mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.  
    """ + "\n\n")
    elif pw == "" or not pw.isdigit():
        Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re")
    else:
        try:
            if int(pw) < 2:
                raise ValueError("Zahl zu klein")
            Ausgabe.insert(1.0, rail_encrypt(eingabetext.replace(" ", ""), int(pw)) + "\n")
            Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
            Ausgabe.insert(1.0, rail_encrypt(eingabetext, int(pw)) + "\n")
            Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
        except ValueError:
            Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")


def rail_decrypt(cipher: str, rails: int):
    arr = [["_" for _ in range(len(cipher))] for _ in range(rails)]
    # cipher ins array reinbasteln
    x, y = 0, 0
    first_x = True
    for b in cipher:
        if x >= len(cipher) and y < rails:
            y += 1
            x = y
            first_x = True
        arr[y][x] = b
        if y == 0 or (first_x and y != rails - 1):
            x = x + (rails - y - 1) * 2
            first_x = False
        elif y == rails - 1 or first_x is False:
            x = x + (y * 2)
            first_x = True
    # dekodierten Text aus array holen
    out = ""
    x, y = 0, 0
    down = True
    for _ in range(len(cipher)):
        out += arr[y][x]
        x += 1
        if down and y + 1 == rails:
            down = False
            y -= 1
        elif down:
            y += 1
        elif down is False and y == 0:
            down = True
            y += 1
        elif down is False:
            y -= 1
    return out


def jaegerzaun_decrypt():
    
    eingabetext = Eingabe.get(1.0, END)
    eingabetext = eingabetext.strip().replace("\n", " ")
    pw = PW_Eingabe.get()
    pw = pw.strip()
    if eingabetext == "":
        Ausgabe.insert(1.0, """HILFE: [decrypt Jägerzaun]
Jägerzaun (auch Railfence oder ZigZag-Chiffre genannt)
Bei dieser Chiffre wird kodiert, indem man einen Text im Zickzackmuster
in ein Feld aus z.B. 3 Zeilen und so vielen Spalten wie der Text lang ist
schreibt. Man beginnt in Spalte 1 - Zeile 1, dann geht es in Spalte 2 - Zeile 1
weiter danach Spalte 3 - Zeile 3, dann Spalte 4 - Zeile 2, Spalte 5 - Zeile 1 usw.
Danach werden die Buchstaben einfach Zeile für Zeile hintereinander geschrieben.
Unterschiedliche Varianten entstehen einfach dadurch, dass man mit unterschiedlich
vielen Zeilen arbeitet welche im Schlüsselfeld angegeben werden kann.

Die Funktion erzeugt hierbei einmal eine Ausgabe bei welcher auch Leerzeichen
mitgeschrieben werden und eine Ausgabe wo zuvor die Leerzeichen entfernt werden.  

Wird im Schlüsselfeld keine Zahl angegeben erfolgt automatisch die Dekodierung
für alle Zeilenanzahlen von 2-12.""" + "\n\n")
    elif pw == "":
        for i in range(12, 1, -1):
            Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext.replace(" ", ""), i)}\n')
        Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
        for i in range(12, 1, -1):
            Ausgabe.insert(1.0, f'{i:02} - {rail_decrypt(eingabetext, i)}\n')
        Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
    elif not pw.isdigit():
        Ausgabe.insert(1.0, "Bitte eine Zahl im Schlüsselfeld eingeben!!\n", "re")
    else:
        try:
            if int(pw) < 2:
                raise ValueError("Zahl zu klein")
            Ausgabe.insert(1.0, rail_decrypt(eingabetext.replace(" ", ""), int(pw)) + "\n")
            Ausgabe.insert(1.0, "ohne Leerzeichen\n", "bu")
            Ausgabe.insert(1.0, rail_decrypt(eingabetext, int(pw)) + "\n")
            Ausgabe.insert(1.0, "inkl. Leerzeichen\n", "bu")
        except ValueError:
            Ausgabe.insert(1.0, "Schlüsselzahl fehlerhaft oder kleiner als 2.\n", "re")