wm-projekt/lib/resolve-bracket.ts

import { GroupId, GroupTable, Match, Team, ThirdPlaceRow } from "@/lib/types";
import {
  R32, LATER_ROUNDS, R32Match, BracketSlot,
  ThirdAssignment, slotLabel,
} from "@/lib/bracket";

// Eine Gruppe gilt als abgeschlossen, wenn alle ihre Gruppenspiele beendet sind
// (regulär 6 Spiele pro Vierergruppe). Erst dann sind Platzierungen fix.
function groupFinished(group: GroupId, matches: Match[]): boolean {
  const groupMatches = matches.filter((m) => m.group === group);
  if (groupMatches.length === 0) return false;
  return groupMatches.every((m) => m.status === "FINISHED");
}

// Ein aufgelöster Teilnehmer einer K.o.-Begegnung.
export interface ResolvedSide {
  teamId: string | null;   // null = noch Platzhalter
  label: string;           // Anzeige (Teamname oder "Sieger E" etc.)
  code: string;
  score: number | null;
  isWinner: boolean;
  provisional: boolean;    // true = nur auf Basis aktueller Tabelle, noch nicht fix
}

export interface ResolvedTie {
  matchNumber: number;
  stage: string;
  home: ResolvedSide;
  away: ResolvedSide;
  status: string;
  prob?: { home: number; draw: number | null; away: number } | null;
}

// Findet das tatsächliche Spiel (aus dem Feed) zu einer FIFA-Match-Nummer.
function feedMatch(matches: Match[], num: number): Match | undefined {
  return matches.find((m) => m.matchNumber === num && m.group == null);
}

// Bestimmt den Sieger eines abgeschlossenen Spiels (Feed) als Team-ID.
function winnerOf(m: Match | undefined): string | null {
  if (!m || m.status !== "FINISHED") return null;
  if (m.homeScore == null || m.awayScore == null) return null;
  if (m.homeScore > m.awayScore) return m.homeTeamId;
  if (m.awayScore > m.homeScore) return m.awayTeamId;
  return null; // Unentschieden -> Elfmeter; Feed liefert i.d.R. Sieger separat
}
function loserOf(m: Match | undefined): string | null {
  if (!m || m.status !== "FINISHED") return null;
  if (m.homeScore == null || m.awayScore == null) return null;
  if (m.homeScore > m.awayScore) return m.awayTeamId;
  if (m.awayScore > m.homeScore) return m.homeTeamId;
  return null;
}

// Löst einen R32-Slot (W/R/3) zu einer Team-ID auf, sofern bereits bekannt.
// provisional = true, solange die zugrunde liegende Gruppe/Zuordnung nicht fix ist.
function resolveR32Slot(
  slot: BracketSlot,
  winnerGroup: GroupId | undefined,
  tables: GroupTable[],
  assignment: ThirdAssignment | null,
  thirds: ThirdPlaceRow[],
  matches: Match[],
  annexResolved: boolean,
): { teamId: string | null; provisional: boolean } {
  const table = (g: GroupId) => tables.find((t) => t.group === g);
  if (slot.type === "W") {
    const t = table(slot.group!);
    const teamId = t?.rows.find((r) => r.rank === 1)?.teamId ?? null;
    return { teamId, provisional: !groupFinished(slot.group!, matches) };
  }
  if (slot.type === "R") {
    const t = table(slot.group!);
    const teamId = t?.rows.find((r) => r.rank === 2)?.teamId ?? null;
    return { teamId, provisional: !groupFinished(slot.group!, matches) };
  }
  // 3. Platz: braucht Annex-C-Zuordnung + den Gruppensieger dieses Spiels
  if (slot.type === "3" && assignment && winnerGroup) {
    const thirdGroup = assignment[winnerGroup];
    if (thirdGroup) {
      const row = thirds.find((r) => r.group === thirdGroup && r.qualifies);
      // Fix nur, wenn Annex C aufgelöst UND die Quellgruppe abgeschlossen ist.
      const fix = annexResolved && groupFinished(thirdGroup, matches);
      return { teamId: row?.teamId ?? null, provisional: !fix };
    }
  }
  return { teamId: null, provisional: true };
}

function sideFrom(
  teamId: string | null, fallbackLabel: string,
  teams: Team[], feed: Match | undefined, which: "home" | "away",
  provisional: boolean,
): ResolvedSide {
  const team = teamId ? teams.find((t) => t.id === teamId) : undefined;
  const score = feed
    ? which === "home" ? feed.homeScore : feed.awayScore
    : null;
  const w = winnerOf(feed);
  return {
    teamId,
    label: team?.name ?? fallbackLabel,
    code: team?.code ?? "",
    score,
    isWinner: teamId != null && w === teamId,
    provisional: teamId != null && provisional,
  };
}

// Baut die komplette aufgelöste Bracket-Struktur.
export function resolveBracket(
  matches: Match[], teams: Team[], tables: GroupTable[],
  thirds: ThirdPlaceRow[], assignment: ThirdAssignment | null,
  annexResolved: boolean,
): { r32: ResolvedTie[]; later: Record<number, ResolvedTie> } {
  // Map: Match-Nummer -> Sieger-Team-ID (für Propagation in Folgerunden)
  const winners = new Map<number, string | null>();
  const losers = new Map<number, string | null>();
  // Map: Match-Nummer -> ist das Spiel beendet (Sieger fix)?
  const decided = new Map<number, boolean>();

  const r32: ResolvedTie[] = R32.map((rm: R32Match) => {
    const feed = feedMatch(matches, rm.matchNumber);
    const homeGroup = rm.home.type === "W" ? rm.home.group : undefined;
    const awayGroup = rm.away.type === "W" ? rm.away.group : undefined;
    // Für 3.-Platz-Slots: Gruppensieger ist die andere Seite (immer W)
    const winnerGroup = (homeGroup ?? awayGroup) as GroupId | undefined;

    const h = resolveR32Slot(rm.home, winnerGroup, tables, assignment, thirds, matches, annexResolved);
    const a = resolveR32Slot(rm.away, winnerGroup, tables, assignment, thirds, matches, annexResolved);
    const home = sideFrom(h.teamId, slotLabel(rm.home, assignment, winnerGroup), teams, feed, "home", h.provisional);
    const away = sideFrom(a.teamId, slotLabel(rm.away, assignment, winnerGroup), teams, feed, "away", a.provisional);

    winners.set(rm.matchNumber, winnerOf(feed));
    losers.set(rm.matchNumber, loserOf(feed));
    decided.set(rm.matchNumber, feed?.status === "FINISHED");
    return {
      matchNumber: rm.matchNumber, stage: "R32",
      home, away, status: feed?.status ?? "SCHEDULED", prob: feed?.prob,
    };
  });

  const later: Record<number, ResolvedTie> = {};
  for (const km of LATER_ROUNDS) {
    const feed = feedMatch(matches, km.matchNumber);
    const src = km.losers ? losers : winners;
    const homeId = src.get(km.fromHome) ?? null;
    const awayId = src.get(km.fromAway) ?? null;
    // Ein Folgeteam ist fix, wenn das speisende Spiel beendet ist.
    const homeProv = !(decided.get(km.fromHome) ?? false);
    const awayProv = !(decided.get(km.fromAway) ?? false);
    const homeLabel = `${km.losers ? "Verlierer" : "Sieger"} ${km.fromHome}`;
    const awayLabel = `${km.losers ? "Verlierer" : "Sieger"} ${km.fromAway}`;
    const home = sideFrom(homeId, homeLabel, teams, feed, "home", homeProv);
    const away = sideFrom(awayId, awayLabel, teams, feed, "away", awayProv);
    winners.set(km.matchNumber, winnerOf(feed));
    losers.set(km.matchNumber, loserOf(feed));
    decided.set(km.matchNumber, feed?.status === "FINISHED");
    later[km.matchNumber] = {
      matchNumber: km.matchNumber, stage: km.stage,
      home, away, status: feed?.status ?? "SCHEDULED", prob: feed?.prob,
    };
  }

  return { r32, later };
}