Liga-System/database.py

import sqlite3
import random


if __name__ == "__main__":
    init_db()

def init_db():
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()

    # Fremdschlüssel (Foreign Keys) in SQLite aktivieren
    cursor.execute('PRAGMA foreign_keys = ON;')

    # 1. Tabelle: players (Stammdaten)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS players (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            discord_id TEXT UNIQUE,
            discord_name TEXT NOT NULL,
            discord_avatar_url TEXT,
            display_name TEXT
        )
    ''')

    # 2. Tabelle: gamesystems (Globale Spielsysteme)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS gamesystems (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            min_score INTEGER DEFAULT 0,
            max_score INTEGER DEFAULT 100
        )
    ''')  

    # 3. Tabelle: player_game_statistic (Welcher Spieler hat in welchem System welche Stats?)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS player_game_statistic (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            player_id INTEGER,
            gamesystem_id INTEGER,
            mmr INTEGER DEFAULT 1000,
            games_in_system INTEGER DEFAULT 0,
            points INTEGER DEFAULT 0,
            avv_points INTEGER DEFAULT 0,
            last_played TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (player_id) REFERENCES players (id),
            FOREIGN KEY (gamesystem_id) REFERENCES gamesystems (id)
        )
    ''')

    # 4. Tabelle: matches (Wer hat wann gegen wen in welchem System gespielt?)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS matches (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            gamesystem_id INTEGER,
            player1_id INTEGER,
            score_player1 INTEGER,
            player2_id INTEGER,
            score_player2 INTEGER,
            played_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, 
            FOREIGN KEY (gamesystem_id) REFERENCES gamesystems (id),
            FOREIGN KEY (player1_id) REFERENCES players (id),
            FOREIGN KEY (player2_id) REFERENCES players (id)
        )
    ''')

    # 5. Tabelle: achievements (Der globale Katalog aller möglichen Erfolge - Stammdaten)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS achievements (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            description TEXT NOT NULL,
            icon TEXT 
        )
    ''')

    # 6. Tabelle: player_achievements (Wer hat welchen Erfolg wann bekommen? - Bewegungsdaten)
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS player_achievements (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            player_id INTEGER,
            achievement_id INTEGER,
            earned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            earned_in INTEGER,
            FOREIGN KEY (earned_in) REFERENCES gamesystems (id),
            FOREIGN KEY (player_id) REFERENCES players (id),
            FOREIGN KEY (achievement_id) REFERENCES achievements (id)
        )
    ''')

    connection.commit()
    connection.close()
    print("Standard Daten in die DB Geschrieben.")

# --------------------
# --- Start Setup der DB Daten. Damit sie nicht GANZ leer sind.
# --------------------
def seed_gamesystems():
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()
    systems = [
        ("Warhammer 40k", 0, 100),
        ("Age of Sigmar", 0, 50),
        ("Spearhead", 0, 50)
    ]

    # executemany ist eine extrem schnelle SQL For-Schleife für Inserts
    cursor.executemany("INSERT INTO gamesystems (name, min_score, max_score) VALUES (?, ?, ?)", systems)

    connection.commit()
    connection.close()
    print("Spielsysteme wurden angelegt!")

def seed_achievements():
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()

    # Unsere Start-Stückliste an Erfolgen (Name, Beschreibung, Icon)
    achievements = [
        ("Kingslayer", "Hat den Spieler auf Platz 1 besiegt!", "👑"),
        ("Unstoppable", "3 Spiele in Folge gewonnen.", "🔥"),
        ("First Blood", "Das allererste Ligaspiel absolviert.", "🩸")
    ]

    cursor.executemany("INSERT INTO achievements (name, description, icon) VALUES (?, ?, ?)", achievements)

    connection.commit()
    connection.close()
    print("Achievements wurden in den Katalog geladen!")


def change_display_name(player_id, new_name):
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()

    cursor.execute("UPDATE players SET display_name = ? WHERE id = ?", (new_name, player_id))

    connection.commit()
    connection.close()


def get_or_create_player(discord_id, discord_name, avatar_url):
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()

    # REPARIERT: Wir fragen 4 Dinge ab (id, discord_name, display_name, discord_avatar_url)
    cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,))
    player = cursor.fetchone()

    if player is None:
        
        silly_name = generate_silly_name()
        cursor.execute("INSERT INTO players (discord_id, discord_name, display_name, discord_avatar_url) VALUES (?, ?, ?, ?)", (discord_id, discord_name, silly_name, avatar_url))
        connection.commit()

        cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,))
        player = cursor.fetchone()
    else:
        # Falls sich Name oder Bild auf Discord geändert haben, machen wir ein Update
        cursor.execute("UPDATE players SET discord_name = ?, discord_avatar_url = ? WHERE discord_id = ?", (discord_name, avatar_url, discord_id))
        connection.commit()

        cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,))
        player = cursor.fetchone()

    connection.close()
    return player


def get_all_players():
    connection = sqlite3.connect("warhammer_league.db")
    cursor = connection.cursor()

    # Alle Spieler laden, absteigend sortiert nach MMR
    cursor.execute("SELECT id, name, mmr, points, games FROM players ORDER BY mmr DESC")
    players = cursor.fetchall()

    connection.close()

    # Die Daten für das Web-GUI in eine lesbare Form umwandeln (Liste von Dictionaries)
    result = []

    return result


def generate_silly_name():
    adjectives = [
        "Verwirrter", "Blinder", "Heulender", "Zorniger", "Chaos", ""
        "Verzweifelter", "Schreiender", "Stolpernder", "Schwitzender"
    ]
    nouns = [
        "Grot", "Kultist", "Servitor", "Snotling", 
        "Guardmen", "Würfellecker", "Regelvergesser", "Meta-Chaser", "Klebschnüffler"
    ]

    # random.choice() nimmt zufällig ein Element aus der Liste
    adj = random.choice(adjectives)
    noun = random.choice(nouns)

    # Verbindet beide Wörter mit einem Leerzeichen (z.B. "Verwirrter Grot")
    return f"{adj} {noun}"