from data import data_api

# Faktor für die Punkte Inflation. Um diesen Wert verliert der Verlierer weniger Punkte als der Sieger bekommt. Über Kurz oder Lang werden
# die meisten Spieler über 1000MMR sein. Sprich: Neueinsteiger, oder leute die weniger spielen sind eher im unteren Ende als in der Mitte.
point_inflation = 0.7   # => entspricht % !    z.B. 0.7 = 70%

def calc_mmr_change(systemname, winner_id, looser_id, winner_points, looser_points, match_is_draw):

    point_inflation = 0.7   # Verlierer verliert nur 70% der Punkte
    K_FACTOR = 35        # Die "Border" (Maximalpunkte) die ein Sieg gibt.

    def get_rust_dampener(days_ago):
        """Berechnet den Dämpfungsfaktor basierend auf den vergangen Tagen."""
        if days_ago <= 30:
            return 1.0  # Volle Punkte
        elif days_ago > 90:
            return 0.1  # Maximal eingerostet (nur 10% der Punkteänderung)
        else:
            # Lineare Rampe von 0.8 (bei Tag 31) runter auf 0.1 (bei Tag 90)
            # Formel: Startwert - (Differenz * Prozentualer Weg)
            factor = 0.8 - 0.7 * ((days_ago - 30) / 60)
            return round(factor, 2)


    def calc_mmr_change(systemname, winner_id, looser_id, winner_points, looser_points, match_is_draw, rules):
        gamesystem_id = data_api.get_gamesystem_id_by_name(systemname)

        # 1. Die aktuellen MMR-Punkte holen
        w_stat = data_api.get_player_statistics_for_system(winner_id, gamesystem_id)
        l_stat = data_api.get_player_statistics_for_system(looser_id, gamesystem_id)

        w_mmr = w_stat['mmr']
        l_mmr = l_stat['mmr']


        # 2. Die fließende Elo-Mathematik (Ersetzt die JSON Datei)
        # Berechnet die Siegwahrscheinlichkeit des Gewinners (Wert zwischen 0.0 und 1.0)
        expected_win = 1 / (1 + 10 ** ((l_mmr - w_mmr) / 400))

        if match_is_draw:
            # Bei einem Draw (0.5) gewinnt der Schwächere leicht Punkte, der Stärkere verliert leicht.
            base_change = K_FACTOR * (0.5 - expected_win)
        else:
            # Sieg (1.0). Gewinnt der Favorit, gibt es wenig Punkte. Gewinnt der Underdog, gibt es viele!
            base_change = K_FACTOR * (1.0 - expected_win)

        # 3. Den "Rostigkeits-Dämpfer" anwenden
        w_days = data_api.get_days_since_last_system_game(winner_id, gamesystem_id)
        l_days = data_api.get_days_since_last_system_game(looser_id, gamesystem_id)



        # 4. Deine Sonderregeln (Slaanesh & Khorne) addieren
        sla_points = slaanesh_delight(winner_points, looser_points, rules)
        w_mmr_change += sla_points

        # Auch der Verlierer bekommt Slaanesh Punkte addiert, wenn es die Regel so sagt
        l_mmr_change += sla_points 

        winner_final = int(w_mmr_change + wrath_of_khorne(winner_id))

        # 5. Verlierer-Punkte abziehen und Inflation (0.7) anwenden
        if match_is_draw:
            looser_final = int(-w_mmr_change) # Bei Draw spiegeln wir es einfach (ohne Inflation)
        else:
            looser_base = int(l_mmr_change + wrath_of_khorne(looser_id))
            looser_final = -int(looser_base * point_inflation)

        return winner_final, looser_final




# -----------------
khorne_days = 16
khorne_bonus = 8
# -----------------
def wrath_of_khorne(player_id):
    last_played = data_api.get_days_since_last_game(player_id)["days_ago"]
    if last_played <= khorne_days:
        return khorne_bonus
    else:
        return 0


def slaanesh_delight(winner_points, looser_points, rules):
    print()


def tzeentch_scemes():
    print("k")

def nurgles_entropy():
    print("k")