# Modulimport
import matplotlib.pyplot as plt
from math import floor


# Diese Funktion startet die Eingabe der Rahmenbedingungen:
# Länge des Trägers[m], Ordinate[m], Kraft[kN].
def start(L, lasten):

    # Loop, um die Länge des Trägers zu erhalten
    while True:
        # Eingabe der Länge des Trägers
        input_ = input('Länge des Trägers [m]: ')

        # Sicherstellen, dass die eingegebene Länge eine gültige Zahl ist,
        # indem in eine Gleitkommazahl konvertiert wird.
        # Schlägt als ValueError fehl, wenn bspw. ein String eingegeben wurde.
        try:
            L = float(input_)
        except ValueError:
            print('Der eingegebene Wert ist ungültig, bitte wiederholen')
            continue    # der Befehl continue springt wieder zum Anfang.

        # Überprüft auf negative Länge oder 0
        if (L <= 0):
            print('Ohnen \'nen Träger können wir uns das hier sparen.')
            continue
        else:
            break

    # Abfrage der Einzellasten.
    print(('Gib beliebig viele Einzellasten in der Form '
           '\"Ordinate [m], Kraft [kN]\" ein, beende mit leerer Eingabe:'))

    # Endlose Schleife
    while True:
        # Erfragt neue Kraft, löscht sofort Leerzeichen

        input_ = input(f'Kraft {len(lasten) + 1} [m, kN]: ')

        if input_ == "":
            break
        else:
            input_ = input_.strip('')

        # Erstellt ein Tupel 'last' bestehend aus den variablen 'ordinate' und
        # 'kraft', indem es den String 'input_' am ',' teilt.
        # Verursacht Fehlermeldung, wenn nicht genaue zwei Elemente entstehen.
        # In dem Fall kann die Eingabe wiederholt werden.
        try:
            last = (ordinate, kraft) = input_.split(',')
        except ValueError:
            try:
                if ordinate is None or kraft is None:
                    break
                else:
                    print('Eingabe konnte nicht erkannt werden, '
                          'bitte wiederholen.')
                    continue
            except:
                print('Eingabe konnte nicht erkannt werden, '
                      'bitte wiederholen.')
                continue

        # Sicherstellen, dass die eingegebenen Lasten auch Zahlen sind,
        # el = ein Element des Tupels
        # float(el) versucht das jeweilige Element in ein Float umzuwandeln.
        # Wenn dies nicht gelingt, tritt die Exception ein, und die Eingabe
        # kann wiederholt werden.
        try:
            tuple(float(el) for el in last)
        except ValueError:
            print('Eine Eingabe war keine Zahl, bitte wiederholen.')
            continue

        # Sicherstellen, dass die Eingegebene ordinate nicht außerhalb des
        # Trägers liegt
        if (float(ordinate) > L):
            print('Ordinate außerhalb des Trägers, bitte wiederholen.')
            continue

        # Wenn negative Kräfte erlaubt sind, auskommentieren.
        # Überprüft die Eingabe auf negative Kräfte, 0 ist okay
        if (float(kraft) < 0):
            print('Negative Kräfte sind nicht erlaubt, bitte wiederholen.')
            continue

        # Alles gut, wird der Liste 'lasten' als Float hinzugefügt
        lasten.append(tuple([float(i) for i in last]))
    lasten.sort(key=(lambda m: m[0]))

    print('Eingabe abgeschlossen')
    return L, lasten

# Diese Funktion berechnet die Auflagerkräfte.
def Auflagerkräfte(L, lasten):

    # Auflagerkräfte A und B initialisiert als float
    A, B = 0.0, 0.0

    # Berechnet die Auflagerkräfte A und B, indem die Belastung durch jede
    # Einzellast auf die jeweiligen Lager summiert wird
    for l in lasten:
        A += l[1] * (1 - l[0] / L)
        B += l[1] * (l[0] / L)

    return A, B

# Diese Funktion berechnet den Querkraftverlauf.
def Querkraftverlauf(L, lasten, A, B):

    # Initialisiert die Liste mit dem ersten Punkt im Auflager A
    # an Länge 0
    verlauf = [(0, A)]

    # Iteriert durch den Index der Liste lasten
    for i in range(1, len(lasten) + 1):
        # Try-Except loop, um den IndexError zu behandeln,
        # der Eintritt, wenn die Schleife am letzten Index ankommt.
        try:
            Q = verlauf[i - 1][1] - lasten[i - 1][1]
            verlauf.append((lasten[i-1][0], Q))
        except IndexError:
            verlauf.append((L, B))
            break
    verlauf.append((L, 0))

    return verlauf

# Diese Funktion berechnet den Biegemomentenverlauf
def Momentverlauf(L, lasten, A, B, Q):

    # der Verlauf des Biegemoments initialisiert mit erster Last
    verlauf = [
        (0, 0),
        (lasten[0][0], Q[0][1] * lasten[0][0])
        ]

    # iteriert durch alle lasten und errechnet das Biegemoment
    for i in range(2, len(lasten) + 1):
        try:
            M = Q[i-1][1] * (lasten[i-1][0]-lasten[i-2][0]) + verlauf[i-1][1]
            verlauf.append((lasten[i-1][0], M))
        except IndexError:
            M = Q[i-1][1] * (L - lasten[i-1][0]) + verlauf[i-1][1]
            verlauf.append((lasten[i-1][0], M))
    # Das letzte Biegemoment auf Auflager B ist in unserer Konfig. immer 0
    verlauf.append((L, 0))

    return verlauf

# Diese Funktion zeichnet eine Tabelle in das Konsolenfenster
def printList(list_, headers=["x", "y"], dec=3):

    # Berechnet die längste Zahl, um die Breite der Spalte zu errechnen
    width = len(str(max([round(y, dec) for (x, y) in list_])))

    # Erstellt die Kopfzeile mit den Überschriften aus headers
    h1 = (" " * 2 + headers[0].ljust(width + 2) + "|" +
          " " * 2 + headers[1].ljust(width + 2))
    h2 = ("-" * floor(len(h1)/2)) + "+" + "-" * floor(len(h1)/2)

    # Erstellt den Rest der Tabelle Zeile für Zeile
    table = "\n".join([h1, h2]) + "\n"
    for (x, y) in list_:
        table += (" " * 2 + str(x).ljust(width + 2) + "|" +
                  " " * (1 if y < 0 else 2) + str(round(y, dec)).ljust(width) + "\n")

    # Und ab in die Konsole damit
    print(table)


# Länge des Trägers und Liste der Einzellasten
L = 0
lasten = []

# Eingabe der Parameter.
L, lasten = start(L, lasten)

# Berechnung der Auflagerkräfte A und B
A, B = Auflagerkräfte(L, lasten)
print(('Auflagerkräfte: \n'
        'A: ' + str(round(A, 3)) + " kN \n"
        'B: ' + str(round(B, 3)) + " kN \n"))

# Berechnung des Querkraftverlaufs Q
print("Querkraft:")
Q = Querkraftverlauf(L, lasten, A, B)
printList(Q, ["L [m]", "Q [kN]"], 3)

# Berechnung des Momentverlaufs M
print("Biegemoment:")
M = Momentverlauf(L, lasten, A, B, Q)
printList(M, ["L [m]", "M [kNm]"], 3)

# Maximales Biegemoment errechnet anhand einer lambda-Funktion,
# die das zweite Element des Tupels vergleicht
M_max = max(M, key=(lambda m: m[1]))
print("Max. Biegemoment: " + str(round(M_max[1], 3)) + " kNm bei " +
          str(M_max[0]) + " m")

# Gerade für den Träger
Tx, Ty = [0, L], [0, 0]

# Formt die Tupel (Px, Py) in jeweils eine Liste für die
# x- und y-Komponente um
Q = [(0, 0)] + Q
Qx, Qy = [list(t) for t in zip(*Q)]
Mx, My = [list(t) for t in zip(*M)]

# Plottet den Träger
plt.plot(Tx, Ty)

# Plottet das Biegemoment mit Beschriftung
plt.plot(Mx, My, label='Biegemoment')

# Plottet den Querkraftverlauf stufenförmig mit Beschriftung
plt.step(Qx, Qy, where='post', label="Querkraft")

# Spiegelt die y-Achse
plt.gca().invert_yaxis()

# Beschriftung hinzufügen
plt.title("Schnittgrößenverlauf")
plt.legend(loc="upper left")
# plt.xlabel("Bezeichnung der x-Achse")
# plt.ylabel("Bezeichnung der y-Achse")

# Zeigt das Bild an
plt.show()

print('fertig')