from .models import Tournament, Match


class SwissSystemService:
    """
    Zentrales Service für Turnierberechnungen im Schweizer System.
    Verantwortlich für Ranglisten, Wertung und Paarungen.
    """

    @staticmethod
    def get_standings(tournament_id):
        """
        Berechnet die aktuelle Rangliste eines Turniers.

        Kriterien (in Reihenfolge):
        1. Anzahl gewonnener Punkte (Win=1, Draw=0.5)
        2. Buchholz-Wertung (Summe der Punktzahlen der Gegner)
        """
        try:
            tournament = Tournament.objects.get(id=tournament_id)
        except Tournament.DoesNotExist:
            return []

        # Alle Spieler in diesem Turnier abrufen
        players_dict = {}

        # 1. Basis-Daten für alle Spieler initialisieren
        for reg in tournament.registrations.all():
            players_dict[reg.player.id] = {
                'id': reg.player.id,
                'name': f"{reg.player.first_name} {reg.player.last_name}",
                'club': reg.player.club,
                'points': 0.0,
                'matches_played': 0,
                'opponents_points': [] # Um Buchholz zu berechnen
            }

        # 2. Alle abgeschlossenen Spiele durchgehen und Punkte zuteilen
        completed_matches = Match.objects.filter(
            round_detail__tournament=tournament,
            result__in=[Match.ResultStatus.WHITE_WIN, Match.ResultStatus.BLACK_WIN, Match.ResultStatus.DRAW]
        )

        for match in completed_matches:
            if match.result == Match.ResultStatus.DRAW:
                p_white = players_dict.get(match.player_white.id)
                p_black = players_dict.get(match.player_black.id)

                # Punkte addieren (0.5 für Unentschieden)
                if p_white:
                    p_white['points'] += 0.5
                    p_white['matches_played'] += 1
                if p_black:
                    p_black['points'] += 0.5
                    p_black['matches_played'] += 1

            elif match.result == Match.ResultStatus.WHITE_WIN:
                p_white = players_dict.get(match.player_white.id)
                if p_white:
                    p_white['points'] += 1.0
                    p_white['matches_played'] += 1

            elif match.result == Match.ResultStatus.BLACK_WIN:
                p_black = players_dict.get(match.player_black.id)
                if p_black:
                    p_black['points'] += 1.0
                    p_black['matches_played'] += 1

            # Buchholz-Hilfe: Merken, gegen wen gespielt wurde (ID des Gegners)
            if match.player_white.id in players_dict:
                players_dict[match.player_white.id]['opponents_points'].append(match.player_black.id)
            if match.player_black.id in players_dict:
                players_dict[match.player_black.id]['opponents_points'].append(match.player_white.id)

        # 3. Buchholz-Score berechnen
        # (Summe der aktuellen Punkte aller Gegner)
        for pid, data in players_dict.items():
            buchholz = 0.0
            for opp_id in data['opponents_points']:
                if opp_id in players_dict:
                    buchholz += players_dict[opp_id]['points']

            # Buchholz zum Datensatz hinzufügen (zum Anzeigen und Sortieren)
            data['buchholz'] = round(buchholz, 2)

        # 4. In eine Liste verwandeln und sortieren
        standings_list = list(players_dict.values())

        # Sortierung:
        # Primär: Punkte (absteigend), Sekundär: Buchholz (absteigend)
        standings_list.sort(key=lambda x: (x['points'], x['buchholz']), reverse=True)

        return standings_list