# bp = Basispunkte
bp = 60
# kf= Korrekturfaktor
kf = 20
# uef = Unentschiedenfaktor
uef = 0.05
# Unentschieden Ja/Nein
ue = False
# efV= Elofaktor Verlierer
efV = 0
# efS= Elofaktor Sieger
efS = 0
# eloS= Elo Sieger
eloS = 0
# eloV= Elo Verlierer
eloV = 0
# sPV= Strafpunkte Verlierer
sPV = 0
# sPS= Strafpunkte Sieger
sPS = 0
# mp= Multiplikator
mp = 0
# mpC= Multiplikator Caps
mpC = 0
# eloDiff= Elo Differenz
eloDiff = 0
# eloDiffC= Elo Differenz Caps
eloDiffC = 0
# zwPV = Zwischenpunkte Verlierer
zwPV = 0
# zwPS = Zwischenpunkte Sieger
zwPS = 0
# Endpunkte Sieger
endpunkteS = 0
# Endpunkte Verlierer
endpunkteV = 0


# testinput für die Eloberechnung
eloS = input("Bitte geben Sie die Elo des Siegers ein: ")
eloS = int(eloS)
eloV = input("Bitte geben Sie die Elo des Verlierers ein: ")
eloV = int(eloV)
sPS = input("Bitte geben Sie die Strafpunkte des Siegers ein: ")
sPS = int(sPS)
sPV = input("Bitte geben Sie die Strafpunkte des Verlierers ein: ")
sPV = int(sPV)
ue = input("Unentschieden Ja/Nein: ")
while (ue != "Ja" and ue != "Nein"):
    ue = input("Unentschieden Ja/Nein: ")


# Berechnung des Elofaktors Sieger
# Der Elofaktor Sieger ist abhängig von der Elo des Siegers.
# Je höher die Elo, desto geringer der Elofaktor.
def elofaktorSieger(eloS):
    if eloS > 2000:
        efS = 0.75
    elif eloS < 2000 and eloS > 1500:
        efS = 0.8
    elif eloS <= 1500 and eloS > 1250:
        efS = 0.85
    elif eloS <= 1250 and eloS > 1000:
        efS = 0.9
    elif eloS <= 1000 and eloS > 750:
        efS = 1
    elif eloS <= 750 and eloS > 500:
        efS = 1
    else:
        efS = 1
    return efS


# Berechnung des Elofaktors Verlierer
# Der Elofaktor Verlierer ist abhängig von der Elo des Verlierers.
# Je höher die Elo, desto geringer der Elofaktor.
def elofaktorVerlierer(eloV):
    if eloV > 2000:
        efV = 0.75
    elif eloV < 2000 and eloV > 1500:
        efV = 0.8
    elif eloV <= 1500 and eloV > 1250:
        efV = 0.85
    elif eloV <= 1250 and eloV > 1000:
        efV = 0.9
    elif eloV <= 1000 and eloV > 750:
        efV = 1
    elif eloV <= 750 and eloV > 500:
        efV = 1
    else:
        efV = 1
    return efV


# Variablen für die Elofaktoren, wert zuweisen
efS = elofaktorSieger(eloS)
efV = elofaktorVerlierer(eloV)


# Berechnung der EloDifferenz
# Die EloDifferenz ist die Differenz zwischen der Elo des Siegers
# und der Elo des Verlierers.
def eloDifferenz(eloS, eloV):
    eloDiff = (eloS - eloV)
    return eloDiff


def eloDifferenzCaps(eloS, eloV):
    return eloDiff * -1


# Variablen für die Elo Differenz, wert zuweisen
eloDiff = eloDifferenz(eloS, eloV)
eloDiffC = eloDifferenzCaps(eloS, eloV)


# Berechnung des Multiplikators
# Der Multiplikator ist abhängig von der Elo Differenz.
def multiplikator(eloDiff):
    return 1-eloDiff/2000


# Berechnung des Multiplikators Caps
# Der Multiplikator Caps ist abhängig von der Elo Differenz.
def multiplikatorCaps(eloDiffC):
    return 1-eloDiffC/2000


# Variablen für die Multiplikatoren, werte zuweisen
mp = multiplikator(eloDiff)
mpC = multiplikatorCaps(eloDiffC)


# Berechnung der Grundpunkte Sieger
# Die Grundpunkte Sieger sind abhängig von den Basispunkten,
# dem Korrekturfaktor und dem Multiplikator.
def grundPunkteS(bp, kf, mp, ue):
    temp = bp*mp-kf
    return round(temp, 0)


# Berechnung der Grundpunkte Verlierer
# Die Grundpunkte Verlierer sind abhängig von den Basispunkten,
# dem Korrekturfaktor und dem Multiplikator.
def grundPunkteV(bp, kf, mp, ue):
    temp = (bp*mp-kf)*-1
    return round(temp, 0)


# Berechnung der Grundpunkte Caps
def grundPunkteCaps(bp, kf, mpC):
    temp = bp*mpC-kf
    return round(temp, 0)


# berechneteten Grundpunkte Variablen zuweisen
# Sieger
gpS = grundPunkteS(bp, kf, mp, ue)
# Verlierer
gpV = grundPunkteV(bp, kf, mp, ue)
# Das Caps für den Verliererstrafpunkte
gpC = grundPunkteCaps(bp, kf, mpC)


# Berechnung des Caps für den Verlierer(für Strafpunkte)
def punktecapsVerlierer(gpC, efV):
    # czp = Maximale Zusatzpunkte durch Strafpunkte
    czp = gpC*efV*0.7
    print("GrundpunkteCaps: ", gpC)
    print("MultiplikatorCaps: ", mpC)
    print("EloFaktorVerlierer: ", efV)
    return round(czp, 0)


czp = punktecapsVerlierer(gpC, efV)
print("Maximale Zusatzpunkte durch Strafpunkte: ", czp)
print("Sieger", gpS)
print("Verlierer", gpV)


# Berechnung der Punkte für Sieger und Verlierer

# Berechnung Punkte für den Sieger
def punkteSieger(gpS, efS, uef, eloDiff):
    if ue == "Ja":
        # zwPS = Zwischenpunkte Sieger
        zwPS = round((eloDiff * uef) * efS * -1)
    else:
        zwPS = round(gpS * efS)
    print("Zwischenpunkte Sieger: ", zwPS)
    return zwPS


# Berechnung Punkte für den Verlierer
def punkteVerlierer(gpV, efV, uef, eloDiff):
    if ue == "Ja":
        # zwPV = Zwischenpunkte Verlierer
        zwPV = round((eloDiff * uef) * efV)
    else:
        zwPV = round(gpV * efV)
    print("Zwischenpunkte Verlierer: ", zwPV)
    return zwPV


# Aufrufen der Methoden zu Punkteberechnung
zwPS = punkteSieger(gpS, efS, uef, eloDiff)
zwPV = punkteVerlierer(gpV, efV, uef, eloDiff)


# Methode zu Berechnung der Strafpunkte Sieger
def strafpunkteSieger(sPS, zwPS):
    sPS = sPS * 33/100
    sPS = round(zwPS * sPS * -1, 0)

    return sPS


# Methode zu Berechnung der Strafpunkte Verlierer
def strafpunkteVerlierer(sPV, zwPV):
    sPV = sPV * 33 / 100
    sPV = round(zwPV * sPV, 0)
    print("Strafpunkte Verlierer: ", sPV)
    return sPV


# Aufrufen der Methoden zu Strafpunkteberechnung
sPS = strafpunkteSieger(sPS, zwPS)
sPV = strafpunkteVerlierer(sPV, zwPV)


# Methode zu Berechnung der Endpunkte Sieger und Verlierer
def endpunkteSieger(zwPS, sPS):
    if sPS < 0:
        endpunkteS = zwPS + sPS
    else:
        endpunkteS = zwPS
    return endpunkteS


def endpunkteVerlierer(zwPV, sPV, sPS):
    if sPV < 0:
        endpunkteV = zwPV + sPV
    else:
        endpunkteV = zwPV

    if sPS < 0:
        print("Strafpunkte Sieger1: ", sPS)
        zPV = sPS * -1
        if zPV > czp:
            endpunkteV = endpunkteV + czp
        else:
            endpunkteV = endpunkteV + zPV
    return endpunkteV


endpunkteS = endpunkteSieger(zwPS, sPS)
endpunkteV = endpunkteVerlierer(zwPV, sPV, sPS)
print("Caps", czp)
print("Endpunkte Sieger: ", endpunkteS)
print("Endpunkte Verlierer: ", endpunkteV)