from __future__ import print_function
import sys
import re
import os.path as p

print(" ____                   __     ___        ____ _               _             ")
print("|  _ \ ___ _ __   ___   \ \   / (_)____  / ___| |__   ___  ___| | _____ _ __ ")
print("| |_) / _ \ '_ \ / _ \   \ \ / /| |_  / | |   | '_ \ / _ \/ __| |/ / _ \ '__|")
print("|  _ <  __/ |_) | (_) |   \ V / | |/ /  | |___| | | |  __/ (__|   <  __/ |   ")
print("|_| \_\___| .__/ \___/     \_/  |_/___|  \____|_| |_|\___|\___|_|\_\___|_|   ")
print("          |_|                                                                ")


such_quelle = "#@quelle:"       #
such_ziel = "#@ziel:"           #
such_modul = "#@modul:"         #

allezeilen = []                 # Das Skript wird zeilenwiese in diese Liste geschrieben, eine Zeile gleich ein Element der Liste
kommentarzeilen = []            # Ein Teil der nicht benoetigten Zeilen kommt in diese Liste
codezeilen = []                 # Zeilen mit Code kommen in diese Liste
perm_file_suffix = ['.ksh']     # Liste der gueltigen Dateiendungen

# Aufruf ohne Parameter abfangen
try:
    sourcefile = sys.argv[1]        # Schreibe den 1.Parameter <Dateiname> in eine Variable
    # print(sourcefile)               # Ausgabe dateiname
except IndexError:
    print()
    print("Missing Parameter: Filename")
    print()
    sys.exit(0)

file_suffix = p.splitext(sourcefile)[1]                 # Dateiendung ermitteln
if file_suffix not in perm_file_suffix:                 # In Liste Ja/Nein
    print("")                                           # Gib eine leere Zeile aus
    print("Only Kornshell scripts can be processed.")   # Gib diese Meldung aus
    print("")                                           # Gib eine leere Zeile aus
    sys.exit(0)                                         # Beende das Programm


# Funktion zum Oeffnen einer Datei mit Pruefung
def get(name):
    try:
        # return open(name, "r", encoding='ISO-8859-1')                          # oeffne die Datei zum Lesen <r>
        return open(name, "r")                          # oeffne die Datei zum Lesen <r>
    # except FileNotFoundError:                         # Bei einem Fehler ... Python3
    except IOError:                                     # Bei einem Fehler ... Python2
        print("")                                       # Gib eine leere Zeile aus
        print("The File ", name, "doesn't exists!")     # Gib diese Meldung aus
        print("")                                       # Gib eine leere Zeile aus
        sys.exit(0)                                     # Beende das Programm
    return None


# Funktion zum Erstellen einer Tabellenliste aus den RepoViz Informationen
def erstelle_liste(datei, typ):                 # 2 Parameter
    laenge = len(typ)                           # bestimme die Laenge
    tabellenliste = []                          # erstelle leere Liste
    fobj_in = get(datei)                        # uebergebe den Dateinamen an die Funktion
    for line in fobj_in:                        # gehe zeilenwiese durch die Quelldatei
        if line[0:laenge] == typ:               # Erstelle Liste mit den Quelltabellen
            zeile = (line[laenge:])
            if zeile[-2] == ",":                # ist ein Komma am Zeilenende
                zeile = zeile[0:-2]             # entferne Komma am Zeilenende
            liste = zeile.split(",")            # Teile die Zeile am Komma auf und speichere die Elemente in einer Liste
            for item in liste:                          # gehe durch die Liste
                tabellenliste.append(item.strip())      # entferne Leerzeichen und fuege die Elemente der Liste <tabellenliste> hinzu
    fobj_in.close()                                     # schliesse Quelldatei
    return(tabellenliste)                               # gebe die fertige Liste <tabellenliste> zurueck


def trennzeile(typ):                                    # Funktion zum Ausgeben einer 80 Zeichen breiten Trennzeile.
    return(print(typ * 80))                             # Das Trennzeichen ist variabel und wird der Funktion als Parameter uebergeben.


modulliste = erstelle_liste(sourcefile, such_modul)     # Erstelle Liste mit den Modulen
quelleliste = erstelle_liste(sourcefile, such_quelle)   # Erstelle Liste mit den Quellen
zielliste = erstelle_liste(sourcefile, such_ziel)       # Erstelle Liste mit den Zielen

datei = get(sourcefile)                     # Oeffnen der Datei mit einer Funktion, die auch prueft ob die Datei existiert
allezeilen = datei.readlines()              # Lesen aller Zeilen in eine Liste
datei.close()                               # Schliessen der Datei

# Versuch die Kommentarzeilen loszuwerden
for zeile in allezeilen:                    # gehe durch die <allezeilen>
    if zeile.strip()[0:8] == '#@modul:':    # Damit diese Zeile auch geprueft wird !!
        codezeilen.append(zeile.strip())    # entferne Leerzeichen und fuege die Elemente der Liste <codezeilen> hinzu
    # Alle Zeilen die nicht betrachtet werden, kommen in diese Liste. Mir ist bis jetzt keine andere Loesung eingefallen.
    if zeile.strip()[0:1] == '#' \
            or zeile.strip()[0:2] == '--' \
            or zeile.strip()[0:4] == 'j000' \
            or zeile.strip()[0:7] == 'SQLFILE' \
            or zeile.strip()[0:8] == 'fmeldung' \
            or zeile.strip()[0:5] == 'ALTER' \
            or zeile.strip()[0:10] == 'f_truncate' \
            or zeile.strip()[0:2] == 'fi' \
            or zeile.strip()[0:2] == 'if' \
            or zeile.strip()[0:10] == 'f_runstats':
        kommentarzeilen.append(zeile.strip())   # entferne Leerzeichen und fuege die Elemente der Liste <kommentarzeilen> hinzu
    else:                                       # Die Codezeilen und ein paar mehr.
        codezeilen.append(zeile.strip())        # entferne Leerzeichen und fuege die Elemente der Liste <codezeilen> hinzu


trennzeile("+")
print("Sorted output of RepoViz information.")
print("")
ausgabe = "{:10}{:}"                                    # Definition AusgabeFormat 1.Feld begrenzt auf 10 Zeichen, das 2.Feld unbegrenzt
quelleliste.sort()                                      # Sortiere Liste <quelleliste>
zielliste.sort()                                        # Sortiere Liste <zielliste>
print(ausgabe.format(such_modul, modulliste))           # Ausgabe <modulliste>
print(ausgabe.format(such_quelle, quelleliste))         # Ausgabe <quelleliste>
print(ausgabe.format(such_ziel, zielliste))             # Ausgabe <zielliste>

# Vergleiche sourcefile mit modulliste hier einfuegen
# Eventuell anpassen, es steht nur der Skriptname in den RepoVizInfos
trennzeile("~")
trennzeile("")
print("Comparison of given script name with RepoVizInformation")
for item in modulliste:
    trennzeile("")
    trennzeile("~")
    if item == p.basename(sourcefile):
        print("Script", p.basename(sourcefile), "is in the RepoViz information!")
    else:
        print("Script", p.basename(sourcefile), "is missing in the RepoViz information!")

# Suche Objekte anhand der RepoVizInformationen
trennzeile("~")

print("")
print("Create a list of tables from the existing code: list <allezeilen>")
# Der Code steht schon in der Liste <codezeilen>
neue_liste = []
# for line in codezeilen:
for line in allezeilen:
    regex = re.compile(r"(?:\$SCHEMA\.|\${SCHEMA}\.).*?\s")
    sql = re.findall(regex, line.upper())         # Suche nach $SCHEMA. oder ${SCHEMA}.
    if len(sql) != 0:
        tabname = sql[0].split(".")[1].strip()                      # der Name wird ...
        if tabname.strip()[0:1] != '$':
            tabname = re.sub("\\W", "", tabname)
            if tabname not in neue_liste and tabname[0:4] != "TMP_":    # Es werden nur Tabellen hinzugefuegt die noch nicht in der
                                                                        # Ergebnisliste sind und nicht mit TMP_ beginnen.
                neue_liste.append(tabname.strip())

print("The list contains:", len(neue_liste), "entries")
trennzeile("~")


# Vergleich repo -> SQL
# 2 Teile
# Quelle - quelleliste
# nehme Liste "quelleliste" und suche damit in Liste "neue_liste"
# trennzeile("#")
print("Are the tables of the list", such_quelle, "included in the SQL?")
trennzeile("~")
for item in quelleliste:
    if item in neue_liste:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is available"))
    else:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is not available"))

# Quelle - zielliste
# nehme Liste "zielliste" und suche damit in Liste "neue_liste"
trennzeile("~")
print("Are the tables of the list", such_ziel, "included in the SQL?")
trennzeile("~")
for item in zielliste:
    if item in neue_liste:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is available"))
    else:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is not available"))

trennzeile("~")
print("Create unique sorted list from ", such_quelle, "and", such_ziel)
q_z_liste = []
basis_liste = quelleliste + zielliste
for tabname in basis_liste:
    if tabname not in q_z_liste:
        q_z_liste.append(tabname)
q_z_liste.sort()

trennzeile("~")

# Vergleich SQL -> repo
# Quelle - neue_liste
# nehme Liste "quelleliste" und suche damit in Liste "neue_liste"
trennzeile("~")
print("Are the tables from the SQL included in the RepoViz information?")
print("Note: I've merged <#@quelle> and <#@ziel> into one list ")
trennzeile("~")
for item in neue_liste:
    if item in q_z_liste:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is available"))
    else:
        ausgabe = "{:12}{:40}{:20}"
        print(ausgabe.format("The Table", item, "is not available"))

trennzeile("+")
print(" _____ _            _____           _ ")
print("|_   _| |__   ___  | ____|_ __   __| |")
print("  | | | '_ \ / _ \ |  _| | '_ \ / _` |")
print("  | | | | | |  __/ | |___| | | | (_| |")
print("  |_| |_| |_|\___| |_____|_| |_|\__,_|")
print("")