from data import data_api
from wood import logger

# 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.


def calc_base_change(elo_factor, match_is_draw, K_FACTOR):
    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 - elo_factor)/2)
    else:
        # Sieg (1.0). Gewinnt der Favorit, gibt es wenig Punkte. Gewinnt der Underdog, gibt es viele!
        base_change = K_FACTOR * (1.0 - elo_factor)

    return base_change


def calc_elo_factor(winner_id, looser_id, system_name):
    w_stats = data_api.get_player_statistics(winner_id)
    l_stats = data_api.get_player_statistics(looser_id)

    # Passendes System aus der Liste herausfiltern
    w_stat = next((s for s in w_stats if s['gamesystem_name'] == system_name), None)
    l_stat = next((s for s in l_stats if s['gamesystem_name'] == system_name), None)

    w_mmr = w_stat['mmr'] if w_stat and w_stat['mmr'] is not None else 1000
    l_mmr = l_stat['mmr'] if l_stat and l_stat['mmr'] is not None else 1000

    return (1 / (1 + 10 ** ((l_mmr - w_mmr) / 400)))



def calc_rust_factor(winner_id, looser_id, gamesystem_id):

    # 3. Den "Rostigkeits-Dämpfer" errechnen.
    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)

    # Der größeren der beiden Werte wird verwendet.
    days_ago = max(w_days, l_days)

    """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 wrath_of_khorne(player_id, system_id):
    # -----------------
    khorne_days = 16
    khorne_bonus = 8
    # -----------------

    last_played = int(data_api.get_days_since_last_system_game(player_id, system_id))
    if last_played <= khorne_days:
        return khorne_bonus
    else:
        return 0

def slaanesh_delight():
    return 0


def tzeentch_schemes(system_id, winner_score, looser_score):
    sys_data = data_api.get_gamesystem_data(system_id)
    max_score = sys_data["max_score"]

    diff_normalized = (winner_score - looser_score) / max_score  # 0.0 – 1.0
    threshold = 0.1  # Bonus startet erst ab 10% Vorsprung

    bonus = int(max(0, diff_normalized - threshold) * 10)  # Ergibt 0–9
    bonus = min(bonus, 9)  # Sicherheits-Cap

    return bonus