import sqlite3
import random
from data.setup_database import DB_PATH

def change_display_name(player_id, new_name):
    connection = sqlite3.connect(DB_PATH)
    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(DB_PATH)
    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:

        # Random Silly Name Generator für neue Spieler. Damit sie angeregt werden ihren richtigen Namen einzutragen.
        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"]
            adj = random.choice(adjectives)
            noun = random.choice(nouns)
            return f"{adj} {noun}"
        
        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(DB_PATH)
    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 get_all_players_from_system(system_name):
    connection = sqlite3.connect(DB_PATH)
    connection.row_factory = sqlite3.Row
    cursor = connection.cursor()

    # ID und Namen der Spieler.
    # DISTINCT stellt sicher, dass jeder Spieler nur einmal vorkommt.
    query = """
        SELECT DISTINCT 
            p.id AS player_id, 
            p.display_name, 
            p.discord_name
        FROM players p
        JOIN player_game_statistic stat ON p.id = stat.player_id
        JOIN gamesystems sys ON stat.gamesystem_id = sys.id
        WHERE sys.name = ?
        ORDER BY p.display_name ASC
    """

    cursor.execute(query, (system_name,))
    rows = cursor.fetchall()
    connection.close()

    result = []
    for row in rows:
        result.append(dict(row))

    return result


import sqlite3
from data.setup_database import DB_PATH

def get_gamesystem_data():
    connection = sqlite3.connect(DB_PATH)

    connection.row_factory = sqlite3.Row 
    cursor = connection.cursor()

    cursor.execute("SELECT * FROM gamesystems")
    rows = cursor.fetchall()
    connection.close()

    # SQLite-Rows in normale Python-Dictionaries um
    result = []
    for row in rows:
        result.append(dict(row))

    return result

def get_player_statistics(player_id):
    connection = sqlite3.connect(DB_PATH)
    connection.row_factory = sqlite3.Row 
    cursor = connection.cursor()

    query = """
        SELECT 
            sys.id AS gamesystem_id,
            sys.name AS gamesystem_name,
            sys.*, 
            stat.mmr,
            stat.games_in_system,
            stat.points
        FROM gamesystems sys
        LEFT JOIN player_game_statistic stat 
            ON sys.id = stat.gamesystem_id AND stat.player_id = ?
    """

    cursor.execute(query, (player_id,))
    rows = cursor.fetchall()
    connection.close()

    result = []
    for row in rows:
        result.append(dict(row))

    return result


def join_league(player_id, gamesystem_id):
    connection = sqlite3.connect(DB_PATH)
    cursor = connection.cursor()

    # Wir fügen nur die beiden IDs ein, der Rest wird von den DEFAULT-Werten der DB erledigt
    query = """
        INSERT INTO player_game_statistic (player_id, gamesystem_id) 
        VALUES (?, ?)
    """

    cursor.execute(query, (player_id, gamesystem_id))
    connection.commit()

    connection.close()


def get_recent_matches_for_player(player_id):
    connection = sqlite3.connect(DB_PATH)
    connection.row_factory = sqlite3.Row 
    cursor = connection.cursor()

    query = """
        SELECT 
            m.id AS match_id,
            sys.name AS gamesystem_name,
            m.player1_id,
            p1.display_name AS p1_display,
            p1.discord_name AS p1_discord,
            m.score_player1,
            m.player2_id,
            p2.display_name AS p2_display,
            p2.discord_name AS p2_discord,
            m.score_player2,
            m.played_at
        FROM matches m
        JOIN gamesystems sys ON m.gamesystem_id = sys.id
        JOIN players p1 ON m.player1_id = p1.id
        JOIN players p2 ON m.player2_id = p2.id
        WHERE m.player1_id = ? OR m.player2_id = ?
        ORDER BY m.played_at DESC
        LIMIT 10
    """

    cursor.execute(query, (player_id, player_id))
    rows = cursor.fetchall()
    connection.close()

    result = []
    for row in rows:
        result.append(dict(row))

    return result


def add_new_match(system_name, player1_id, player2_id, score_p1, score_p2):
    connection = sqlite3.connect(DB_PATH)
    cursor = connection.cursor()

    # 1. Wir suchen die interne ID des Spielsystems anhand des Namens (z.B. "Warhammer 40k" -> 1)
    cursor.execute("SELECT id FROM gamesystems WHERE name = ?", (system_name,))
    sys_row = cursor.fetchone()

    # Sicherheitscheck (sollte eigentlich nie passieren)
    if not sys_row:
        connection.close()
        return False 

    sys_id = sys_row[0]

    # 2. Das Match eintragen! (Datum 'played_at' macht SQLite durch DEFAULT CURRENT_TIMESTAMP automatisch)
    query = """
        INSERT INTO matches (gamesystem_id, player1_id, player2_id, score_player1, score_player2)
        VALUES (?, ?, ?, ?, ?)
    """

    cursor.execute(query, (sys_id, player1_id, player2_id, score_p1, score_p2))

    connection.commit()
    connection.close()

    return True