import { GroupId, GoalEvent, Match, MatchStatus, Team } from "./types";
import { TEAM_LOCALIZATION } from "./team-mappings";
import { R32, LATER_ROUNDS, resolveAnnexC, qualifiedThirdGroups } from "./bracket";
import { computeGroupTables, computeThirdPlaceTable } from "./standings";
import { FIFA_GROUP_MAP, FIFA_STAGE_MAP } from "./fifa-constants";

// ----------------------------------------------------------------------------
// Caching: In-Memory-Cache mit TTL + stale-while-revalidate.
// Bei abgelaufenem Cache wird der alte Wert sofort zurückgegeben und die
// Erneuerung im Hintergrund angestoßen (keine Wartezeit für den Nutzer).
// ----------------------------------------------------------------------------
interface CacheEntry<T> { value: T; expires: number; refreshing?: boolean; }
const cache = new Map<string, CacheEntry<unknown>>();

// Subscription-System: Benachrichtigt Listener (z.B. API-Routen) bei
// erfolgreichem Hintergrund-Refresh, sodass das Frontend nach dem
// nächsten Poll die aktuellen Daten erhält.
type CacheListener = (value: unknown) => void;
const cacheSubscriptions = new Map<string, Set<CacheListener>>();

function notifyCacheListeners(key: string, value: unknown): void {
  const subs = cacheSubscriptions.get(key);
  if (!subs) return;
  for (const cb of subs) {
    try { cb(value); } catch { /* silent */ }
  }
}

export function onCacheRefresh<T>(key: string, cb: (value: T) => void): () => void {
  if (!cacheSubscriptions.has(key)) cacheSubscriptions.set(key, new Set());
  const set = cacheSubscriptions.get(key)!;
  const wrapped = cb as CacheListener;
  set.add(wrapped);
  return () => { set.delete(wrapped); if (set.size === 0) cacheSubscriptions.delete(key); };
}

export async function cached<T>(key: string, ttlMs: number, fn: () => Promise<T>): Promise<T> {
  const hit = cache.get(key) as CacheEntry<T> | undefined;
  const now = Date.now();

  // Frischer Cache → direkt zurück
  if (hit && hit.expires > now) return hit.value;

  // Abgelaufen, aber vorhanden → sofort alten Wert liefern, im Hintergrund erneuern
  if (hit) {
    if (!hit.refreshing) {
      hit.refreshing = true;
      fn()
        .then((value) => {
          cache.set(key, { value, expires: Date.now() + ttlMs });
          notifyCacheListeners(key, value);
        })
        .catch((err) => { console.error(`[cache] Hintergrund-Refresh fehlgeschlagen (${key}):`, err); })
        .finally(() => { const e = cache.get(key) as CacheEntry<T> | undefined; if (e) e.refreshing = false; });
    }
    return hit.value;
  }

  // Kaltstart: kein Cache → synchron laden
  const value = await fn();
  cache.set(key, { value, expires: now + ttlMs });
  return value;
}

// ----------------------------------------------------------------------------
// Polymarket Gamma API: Wahrscheinlichkeiten pro Spiel (Series soccer-fifwc)
// ----------------------------------------------------------------------------
const PM_BASE = "https://gamma-api.polymarket.com";
const PM_SERIES = "11433"; // WM 2026 Serie

interface PmEvent {
  id: string;
  slug: string;
  title: string;
  markets?: PmMarket[];
}

interface PmMarket {
  slug: string;
  groupItemTitle: string;
  outcomes: string;        // JSON-String ["Yes","No"]
  outcomePrices: string;   // JSON-String ["0.385","0.615"]
  sportsMarketType?: string;
  closed: boolean;
}

export interface ParsedOdds {
  slug: string;
  homeCode: string;
  awayCode: string;
  homeName: string;
  awayName: string;
  pHome: number;
  pDraw: number;
  pAway: number;
  startTime: string | null;
}

// Normalisiert Teamcodes zwischen Polymarket-Slug und Feed (3-Buchstaben).
// Bekannte Abweichungen: kr/kor (Südkorea), nld/ned (Niederlande), cdr/cod (DR Kongo).
const CODE_NORM: Record<string, string> = {
  kor: "kr",
  nld: "ned",
  cdr: "cod",
  cvi: "cpv",
  rsa: "rsa", // ok
  swe: "swe", // ok
};

function normCode(c: string): string {
  return (CODE_NORM[c] ?? c).toLowerCase();
}

function safeParse<T>(s: string, fallback: T): T {
  try { return JSON.parse(s) as T; } catch { return fallback; }
}

// Holt alle WM-Spiele über den Series-Endpoint mit Pagination.
// Parst pro Event die drei Moneyline-Märkte (Heim/Draw/Auswärts).
export async function fetchOdds(): Promise<ParsedOdds[]> {
  return cached("pm:odds", 300_000, async () => {
    const allEvents: PmEvent[] = [];
    for (let offset = 0; ; offset += 100) {
      const url = `${PM_BASE}/events?series_id=${PM_SERIES}&active=true&closed=false&limit=100&offset=${offset}`;
      const res = await fetch(url, {
        cache: "no-store",
        headers: { "User-Agent": "wm2026-board/1.0" },
      });
      if (!res.ok) throw new Error(`polymarket ${res.status}`);
      const page = (await res.json()) as PmEvent[];
      allEvents.push(...page);
      if (page.length < 100) break;
    }

    const parsed: ParsedOdds[] = [];

    for (const ev of allEvents) {
      // Slug: fifwc-{home}-{away}-{yyyy}-{mm}-{dd}
      const slugParts = ev.slug.replace("fifwc-", "").split("-");
      if (slugParts.length < 5) continue;
      const homeCode = normCode(slugParts[0]);
      const awayCode = normCode(slugParts[1]);

      let pHome = 0, pDraw = 0, pAway = 0;
      let homeName = "", awayName = "";
      let marketGameStartTime: string | null = null;

      for (const mk of ev.markets ?? []) {
        if (mk.sportsMarketType && mk.sportsMarketType !== "moneyline") continue;
        if (mk.closed) continue;
        if (!marketGameStartTime) marketGameStartTime = (mk as any).gameStartTime ?? null;
        const prices = safeParse<string[]>(mk.outcomePrices, []).map(Number);
        if (prices.length < 2) continue;
        const yes = prices[0]; // erster Preis = "Yes"-Wahrscheinlichkeit

        const gti = mk.groupItemTitle.toLowerCase();
        if (mk.slug.endsWith("-draw") || gti.startsWith("draw")) {
          pDraw = yes;
        } else {
          // Heuristik: match gegen groupItemTitle (Teamname)
          // Prüfe ob der Titel den Home-Code oder Away-Code enthält
          // Besser: erster Markt = Home, dritter = Away; Draw in der Mitte.
          // Da die Reihenfolge nicht garantiert ist: über slug-Suffix matchen.
          if (mk.slug.endsWith("-" + slugParts[0].toLowerCase())) {
            pHome = yes;
            homeName = mk.groupItemTitle;
          } else if (mk.slug.endsWith("-" + slugParts[1].toLowerCase())) {
            pAway = yes;
            awayName = mk.groupItemTitle;
          }
        }
      }

      if (pHome > 0 || pDraw > 0 || pAway > 0) {
        const startTime = marketGameStartTime ?? (ev as any).gameStartTime ?? (ev as any).endDate ?? (ev as any).startDate;
        parsed.push({ slug: ev.slug, homeCode, awayCode, homeName, awayName, pHome, pDraw, pAway, startTime });
      }
    }

    console.log("[polymarket] spiele:", parsed.length);
    return parsed;
  });
}

// Normalisiert Teamnamen für Matching (lowercase, diakritische Zeichen, aliase).
function normName(n: string): string {
  return n
    .toLowerCase()
    .normalize("NFD").replace(/[\u0300-\u036f]/g, "") // diakritische Zeichen entfernen
    .replace(/[^a-z0-9 ]/g, "")
    .replace(/\s+/g, " ")
    .trim();
}

// Verknüpft Polymarket-Odds mit Feed-Matches über Teamnamen (primär) oder Codes.
export function attachOdds(matches: Match[], teams: Team[], odds: ParsedOdds[]): Match[] {
  // Map: Team-ID → normierter Name
  const nameById = new Map(teams.map((t) => [t.id, normName(t.name)]));
  // Map: normierter Name → Team-ID (für Lookup)
  const idByName = new Map<string, string>();
  for (const t of teams) {
    const nn = normName(t.name);
    if (!idByName.has(nn)) idByName.set(nn, t.id);
  }
  // Map: normierter Code → Team-ID
  const idByCode = new Map(teams.map((t) => [t.code.toLowerCase(), t.id]));

  // Map: Polymarket ParsedOdds → { homeTeamId, awayTeamId }
  const oddsMatch = new Map<ParsedOdds, { homeId: string; awayId: string } | null>();
  for (const o of odds) {
    const hn = normName(o.homeName);
    const an = normName(o.awayName);
    const homeId = idByName.get(hn) ?? idByCode.get(o.homeCode);
    const awayId = idByName.get(an) ?? idByCode.get(o.awayCode);
    if (homeId && awayId) {
      oddsMatch.set(o, { homeId, awayId });
    } else {
      oddsMatch.set(o, null);
    }
  }

  const attachedOdds = new Set<ParsedOdds>();

  const result = matches.map((m) => {
    if (!m.homeTeamId || !m.awayTeamId) return m;
    // Suche in oddsMatch nach einer Kombination die beide Team-IDs matcht
    for (const [o, ids] of oddsMatch) {
      if (!ids) continue;
      // Beide Richtungen prüfen
      if ((ids.homeId === m.homeTeamId && ids.awayId === m.awayTeamId) ||
          (ids.homeId === m.awayTeamId && ids.awayId === m.homeTeamId)) {
        const swapped = ids.homeId === m.awayTeamId;
        attachedOdds.add(o);
        return {
          ...m,
          prob: {
            home: swapped ? o.pAway : o.pHome,
            draw: o.pDraw,
            away: swapped ? o.pHome : o.pAway,
          },
        };
      }
    }
    return m;
  });

  return result;
}

// ----------------------------------------------------------------------------
// KO-Odds-Fallback: löst R32-Paarungen auf und verknüpft Polymarket-Events
// mit K.o.-Feed-Matches, die noch keine Team-IDs im Feed haben.
// ----------------------------------------------------------------------------

// Löst für jeden R32-Slot (73-88) die aktuellen Team-Paarungen auf Basis der
// Gruppentabellen und Annex-C-Zuordnung. Gibt eine Map matchNumber → Paarung
// zurück, NUR wenn beide Team-IDs eindeutig bekannt sind (kein Raten).
function resolveR32Pairings(matches: Match[], teams: Team[]): Map<number, { homeTeamId: string; awayTeamId: string }> {
  const tables = computeGroupTables(teams, matches);
  const thirds = computeThirdPlaceTable(tables);
  const qGroups = qualifiedThirdGroups(thirds);
  const annex = qGroups.length === 8 ? resolveAnnexC(qGroups) : null;

  const pairings = new Map<number, { homeTeamId: string; awayTeamId: string }>();

  for (const slot of R32) {
    const homeGroup = slot.home.type === "W" ? slot.home.group : undefined;
    const awayGroup = slot.away.type === "W" ? slot.away.group : undefined;
    const wg = (homeGroup ?? awayGroup) as GroupId | undefined;

    let hid: string | null = null;
    if (slot.home.type === "W" && slot.home.group) {
      hid = tables.find(t => t.group === slot.home.group)?.rows.find(r => r.rank === 1)?.teamId ?? null;
    } else if (slot.home.type === "R" && slot.home.group) {
      hid = tables.find(t => t.group === slot.home.group)?.rows.find(r => r.rank === 2)?.teamId ?? null;
    } else if (slot.home.type === "3" && annex && wg) {
      const tg = annex[wg];
      if (tg) hid = thirds.find(r => r.group === tg && r.qualifies)?.teamId ?? null;
    }

    let aid: string | null = null;
    if (slot.away.type === "W" && slot.away.group) {
      aid = tables.find(t => t.group === slot.away.group)?.rows.find(r => r.rank === 1)?.teamId ?? null;
    } else if (slot.away.type === "R" && slot.away.group) {
      aid = tables.find(t => t.group === slot.away.group)?.rows.find(r => r.rank === 2)?.teamId ?? null;
    } else if (slot.away.type === "3" && annex && wg) {
      const tg = annex[wg];
      if (tg) aid = thirds.find(r => r.group === tg && r.qualifies)?.teamId ?? null;
    }

    if (hid && aid) {
      pairings.set(slot.matchNumber, { homeTeamId: hid, awayTeamId: aid });
    }
  }

  return pairings;
}

// Extrahiert das Datum (YYYY-MM-DD) aus einem Polymarket-Slug.
// Slug-Format: fifwc-{home}-{away}-{yyyy}-{mm}-{dd}
function slugToDate(slug: string): string | null {
  const parts = slug.split("-");
  if (parts.length < 3) return null;
  const y = parts[parts.length - 3];
  const m = parts[parts.length - 2];
  const d = parts[parts.length - 1];
  if (/^\d{4}$/.test(y) && /^\d{2}$/.test(m) && /^\d{2}$/.test(d)) {
    return `${y}-${m}-${d}`;
  }
  return null;
}

// Zweiter Durchlauf für attachOdds: ordnet Polymarket-Events K.o.-Feed-Matches
// zu, die (noch) keine Team-IDs im Feed haben. Arbeitet direkt auf den
// aufgelösten R32-Paarungen (resolveR32Pairings). Identifiziert das Ziel-
// Feed-Match über die Slot-matchNumber (Stufe 1) oder Datums-Lookup aus dem
// Slug (Stufe 2) — KEINE chronologische Nummernvergabe.
// Mutiert matches in-place, setzt nur bei Matches OHNE bestehende prob.
export function attachKOOdds(matches: Match[], teams: Team[], odds: ParsedOdds[]): Match[] {
  const pairings = resolveR32Pairings(matches, teams);
  if (pairings.size === 0) return matches;

  const idByName = new Map<string, string>();
  for (const t of teams) {
    const nn = normName(t.name);
    if (!idByName.has(nn)) idByName.set(nn, t.id);
  }
  const idByCode = new Map(teams.map((t) => [t.code.toLowerCase(), t.id]));

  for (const [matchNum, pairing] of pairings) {
    if (!pairing.homeTeamId || !pairing.awayTeamId) continue;

    // Finde Polymarket-Event für dieses Team-Paar
    let matchedEvent: ParsedOdds | null = null;
    for (const o of odds) {
      const hn = normName(o.homeName);
      const an = normName(o.awayName);
      const homeId = idByName.get(hn) ?? idByCode.get(o.homeCode);
      const awayId = idByName.get(an) ?? idByCode.get(o.awayCode);
      if (!homeId || !awayId) continue;
      if ((homeId === pairing.homeTeamId && awayId === pairing.awayTeamId) ||
          (homeId === pairing.awayTeamId && awayId === pairing.homeTeamId)) {
        matchedEvent = o;
        break;
      }
    }

    if (!matchedEvent) continue;

    // Ziel-Feed-Match identifizieren
    let targetMatch: Match | undefined;

    // Stufe 1: bereits nummeriertes R32-Match (via assignKONumbersBySlots Pass 1)
    targetMatch = matches.find(m =>
      m.stage === "R32" && m.group == null && m.matchNumber === matchNum,
    );

    // Stufe 2: Datums-Lookup aus Polymarket-Slug für unnummerierte Matches
    if (!targetMatch) {
      const slugDate = slugToDate(matchedEvent.slug);
      if (slugDate) {
        const candidates = matches.filter(m =>
          m.stage === "R32" && m.group == null && m.matchNumber === 0 &&
          m.utcDate.slice(0, 10) === slugDate,
        );

        if (candidates.length === 1) {
          targetMatch = candidates[0];
          targetMatch.matchNumber = matchNum;
        } else if (candidates.length > 1) {
          // Tie-breaker: falls Polymarket-Event eine Startzeit hat, nächstgelegenes Feed-Match
          if (matchedEvent.startTime) {
            const eventTime = new Date(matchedEvent.startTime).getTime();
            let best: Match | undefined;
            let bestDiff = Infinity;
            for (const c of candidates) {
              const diff = Math.abs(new Date(c.utcDate).getTime() - eventTime);
              if (diff < bestDiff) { bestDiff = diff; best = c; }
            }
            // Nur zuordnen, wenn Zeitdifferenz plausibel (<4h)
            if (best && bestDiff < 4 * 60 * 60 * 1000) {
              targetMatch = best;
              targetMatch.matchNumber = matchNum;
            }
          }
        }
      }
    }

    if (!targetMatch) continue;

    // prob nicht überschreiben, falls schon gesetzt
    if (targetMatch.prob) continue;

    const homeIdFromEvent = idByName.get(normName(matchedEvent.homeName)) ??
      idByCode.get(matchedEvent.homeCode);
    const swapped = homeIdFromEvent === pairing.awayTeamId;

    targetMatch.prob = {
      home: swapped ? matchedEvent.pAway : matchedEvent.pHome,
      draw: matchedEvent.pDraw,
      away: swapped ? matchedEvent.pHome : matchedEvent.pAway,
    };
  }

  return matches;
}

// ----------------------------------------------------------------------------
// FIFA-API: Live-Scores, Elfmeterschießen, Spielminute
// ----------------------------------------------------------------------------
const FIFA_BASE = "https://api.fifa.com/api/v3";
const FIFA_SEASON = "285023";

// FIFA-Code → App-Code (nur Abweichungen; sonst identisch)
const FIFA_CODE_OVERRIDE: Record<string, string> = {
  CRO: "HRV",  // Kroatien
  POR: "PRT",  // Portugal
  SUI: "CHE",  // Schweiz
};
function fifaCodeToAppCode(fifaCode: string): string {
  return FIFA_CODE_OVERRIDE[fifaCode] ?? fifaCode;
}

interface FifaTeamBlock {
  IdTeam: string;        // FIFA-Team-ID
  Abbreviation: string;  // FIFA-Code (z.B. PAR, CRO)
}

interface FifaMatch {
  MatchNumber: number;
  IdMatch?: string | null;
  IdStage?: string | null;
  Home: FifaTeamBlock | null;
  Away: FifaTeamBlock | null;
  HomeTeamScore: number | null;
  AwayTeamScore: number | null;
  HomeTeamPenaltyScore: number | null;
  AwayTeamPenaltyScore: number | null;
  MatchStatus: number; // 0=finished, 1=scheduled, else=live
  MatchTime: string | null; // z.B. "132'"
  ResultType: number | null; // 1=regular, 2=penalties
  Winner?: string | null; // Team-ID des Siegers
}

interface FifaScores {
  homeScore: number | null;
  awayScore: number | null;
  homePenalty: number | null;
  awayPenalty: number | null;
  resultType: number | null;
  status: MatchStatus;
  matchTime: string | null;
  winnerTeamId: string | null;
  idMatch: string | null;
  idStage: string | null;
}

// ----------------------------------------------------------------------------
// FIFA-API Calendar-Endpoint: Primärquelle für Spiele + Teams
// ----------------------------------------------------------------------------

interface FifaCalendarTeamBlock {
  IdTeam: string;
  Abbreviation: string;
  TeamName: Array<{ Locale: string; Description: string }>;
}

interface FifaCalendarMatch {
  IdMatch: string;
  IdStage: string;
  IdGroup: string | null;
  MatchNumber: number;
  Date: string;
  Home: FifaCalendarTeamBlock | null;
  Away: FifaCalendarTeamBlock | null;
  HomeTeamScore: number | null;
  AwayTeamScore: number | null;
  HomeTeamPenaltyScore: number | null;
  AwayTeamPenaltyScore: number | null;
  MatchStatus: number;
  MatchTime: string | null;
  ResultType: number | null;
  Winner?: string | null;
  Attendance: string | null;
  Stadium?: {
    Name: Array<{ Locale: string; Description: string }>;
    CityName: Array<{ Locale: string; Description: string }>;
  } | null;
}

// Holt alle Spiele + Teams von der FIFA-API (parallele Quelle, noch nicht aktiv).
export async function fetchMatchesAndTeamsFifa(locale: string = "de"): Promise<{ matches: Match[]; teams: Team[] }> {
  return cached(`fifa:matches:${locale}`, 60_000, async () => {
    const lang = locale === "en" ? "en" : "de";
    const url = `${FIFA_BASE}/calendar/matches?language=${lang}&count=500&idSeason=${FIFA_SEASON}`;
    const res = await fetch(url, {
      cache: "no-store",
      headers: { "User-Agent": "wm2026-board/1.0" },
    });
    if (!res.ok) throw new Error(`fifa-calendar ${res.status}`);
    const data = (await res.json()) as { Results: FifaCalendarMatch[] };
    console.log("[fifa-fetch] Kalender geladen, Result-Array Länge:", (data.Results ?? []).length);

    const teamMap = new Map<string, Team>();

    function teamFromBlock(tb: FifaCalendarTeamBlock, idGroup: string | null): Team | null {
      const id = tb.IdTeam;
      if (teamMap.has(id)) return teamMap.get(id)!;
      const code = fifaCodeToAppCode(tb.Abbreviation);
      const group = idGroup ? FIFA_GROUP_MAP[idGroup] : null;
      if (!group) return null;
      const loc = TEAM_LOCALIZATION[code.toUpperCase()];
      const name = tb.TeamName?.[0]?.Description ?? "";
      const t: Team = {
        id,
        name,
        code,
        group,
        localisedName: loc ? loc[lang === "en" ? "en" : "de"] : name,
        localisedNames: loc ? { de: loc.de, en: loc.en } : { de: name, en: name },
      };
      teamMap.set(id, t);
      return t;
    }

    function mapFifaStatus(ms: number): MatchStatus {
      switch (ms) {
        case 0: return "FINISHED";
        case 1: return "SCHEDULED";
        case 10: return "POSTPONED";
        default: return "LIVE";
      }
    }

    const matches: Match[] = (data.Results ?? []).map((fm) => {
      const group = fm.IdGroup ? FIFA_GROUP_MAP[fm.IdGroup] ?? null : null;
      let homeTeam: Team | null = null;
      let awayTeam: Team | null = null;
      if (fm.Home) homeTeam = teamFromBlock(fm.Home, fm.IdGroup);
      if (fm.Away) awayTeam = teamFromBlock(fm.Away, fm.IdGroup);
      const attendance = fm.Attendance ? parseInt(fm.Attendance, 10) || null : null;
      const minute = fm.MatchTime ? parseInt(fm.MatchTime, 10) || null : null;
      const pref = lang === "en" ? "en-GB" : "de-DE";
      const stadiumName = fm.Stadium?.Name?.find(n => n.Locale === pref)?.Description
        ?? fm.Stadium?.Name?.[0]?.Description ?? null;
      const stadiumCity = fm.Stadium?.CityName?.find(n => n.Locale === pref)?.Description
        ?? fm.Stadium?.CityName?.[0]?.Description ?? null;
      return {
        id: fm.IdMatch,
        group,
        stage: FIFA_STAGE_MAP[fm.IdStage] ?? "GROUP",
        matchNumber: fm.MatchNumber,
        utcDate: fm.Date,
        status: mapFifaStatus(fm.MatchStatus),
        minute,
        homeTeamId: fm.Home?.IdTeam ?? null,
        awayTeamId: fm.Away?.IdTeam ?? null,
        homeScore: fm.HomeTeamScore,
        awayScore: fm.AwayTeamScore,
        homePenalty: fm.HomeTeamPenaltyScore,
        awayPenalty: fm.AwayTeamPenaltyScore,
        winnerTeamId: fm.Winner ?? null,
        venue: null,
        stadiumName,
        stadiumCity,
        attendance,
      };
    });

    const teams = [...teamMap.values()];
    console.log("[fifa-fetch] Teams:", teams.length, "Matches:", matches.length);
    return { matches, teams };
  });
}

// Holt Live-Scores von der FIFA-API. Gibt Map MatchNumber → Scores + FIFA-ID→App-Code-Map zurück.
// Scores/Status/Penalties/Winner sind sprachunabhängig → locale-freier Cache-Key.
export async function fetchFifaScores(): Promise<{
  scores: Map<number, FifaScores>;
  fifaIdToAppCode: Map<string, string>;
}> {
  return cached("fifa:scores", 45_000, async () => {
    const url = `${FIFA_BASE}/calendar/matches?language=en&count=500&idSeason=${FIFA_SEASON}`;
    const res = await fetch(url, {
      cache: "no-store",
      headers: { "User-Agent": "wm2026-board/1.0" },
      signal: AbortSignal.timeout(5000),
    });
    if (!res.ok) throw new Error(`fifa ${res.status}`);
    const data = (await res.json()) as { Results: FifaMatch[] };
    console.log("[fifa-fetch] Scores geladen, Result-Array Länge:", (data.Results ?? []).length);
    const scores = new Map<number, FifaScores>();
    const fifaIdToAppCode = new Map<string, string>();

    for (const fm of data.Results ?? []) {
      // Team-Mapping sammeln
      for (const tb of [fm.Home, fm.Away]) {
        if (tb && !fifaIdToAppCode.has(tb.IdTeam)) {
          fifaIdToAppCode.set(tb.IdTeam, fifaCodeToAppCode(tb.Abbreviation));
        }
      }

      let status: MatchStatus;
      switch (fm.MatchStatus) {
        case 0: status = "FINISHED"; break;
        case 1: status = "SCHEDULED"; break;
        case 10: status = "POSTPONED"; break;
        default: status = "LIVE"; break;
      }
      scores.set(fm.MatchNumber, {
        homeScore: fm.HomeTeamScore,
        awayScore: fm.AwayTeamScore,
        homePenalty: fm.HomeTeamPenaltyScore,
        awayPenalty: fm.AwayTeamPenaltyScore,
        resultType: fm.ResultType,
        status,
        matchTime: fm.MatchTime,
        winnerTeamId: fm.Winner ?? null,
        idMatch: fm.IdMatch ?? null,
        idStage: fm.IdStage ?? null,
      });
    }
    console.log("[fifa-fetch] Score-Einträge:", scores.size, "Team-Mappings:", fifaIdToAppCode.size);
    return { scores, fifaIdToAppCode };
  });
}

// Wendet FIFA-Live-Scores auf Matches an (MatchNumber als exakter Schlüssel).
// Team-IDs sind jetzt FIFA-IDs → winnerTeamId kann direkt gesetzt werden.
export function applyFifaScores(
  matches: Match[], teams: Team[],
  fifaData: { scores: Map<number, FifaScores>; fifaIdToAppCode: Map<string, string> },
): Match[] {
  const { scores: fifaMap } = fifaData;
  if (fifaMap.size === 0) return matches;
  let applied = 0;
  const result = matches.map((m) => {
    const fs = fifaMap.get(m.matchNumber);
    if (!fs) return m;
    const r = { ...m };
    if (fs.homeScore != null) r.homeScore = fs.homeScore;
    if (fs.awayScore != null) r.awayScore = fs.awayScore;
    if (fs.homePenalty != null) r.homePenalty = fs.homePenalty;
    if (fs.awayPenalty != null) r.awayPenalty = fs.awayPenalty;
    if (fs.winnerTeamId) r.winnerTeamId = fs.winnerTeamId;
    if (fs.matchTime) {
      const min = parseInt(fs.matchTime, 10);
      if (!isNaN(min)) r.minute = min;
    }
    r.status = fs.status;
    applied++;
    return r;
  });
  if (applied > 0) console.log("[fifa] scores angewandt:", applied);
  return result;
}

// Holt Tor-Details pro Spiel vom FIFA-Detail-Endpoint.
interface FifaGoalRaw { scorer: string; minute: string; team: "home" | "away"; type: number | null; }

function locName(arr: Array<{ Locale: string; Description: string }> | undefined): string {
  if (!arr || arr.length === 0) return "";
  return (arr.find(x => x.Locale === "de-DE")
       ?? arr.find(x => x.Locale === "en-GB")
       ?? arr[0])?.Description ?? "";
}

function normMinuteStr(min: string | null | undefined): string {
  return (min ?? "").replace(/'/g, "").replace(/\s+/g, "").trim();
}

async function fetchFifaGoals(
  idStage: string, idMatch: string, locale: string = "de",
  ttlMs: number = 60_000,
): Promise<FifaGoalRaw[]> {
  return cached(`fifa:detail:${locale}:${idMatch}`, ttlMs, async () => {
    const lang = locale === "en" ? "en" : "de";
    const url = `${FIFA_BASE}/live/football/17/${FIFA_SEASON}/${idStage}/${idMatch}?language=${lang}`;
    const res = await fetch(url, {
      cache: "no-store",
      headers: { "User-Agent": "wm2026-board/1.0" },
      signal: AbortSignal.timeout(5000),
    });
    if (!res.ok) { console.warn("[fifa-detail] status", res.status, idMatch); return []; }
    const dj: any = await res.json();

    const buildPlayerMap = (teamBlock: any): Map<string, string> => {
      const map = new Map<string, string>();
      for (const p of teamBlock?.Players ?? []) {
        map.set(String(p.IdPlayer), locName(p.PlayerName) || locName(p.ShortName));
      }
      return map;
    };
    const homeBlock = dj.HomeTeam, awayBlock = dj.AwayTeam;
    const homePlayers = buildPlayerMap(homeBlock);
    const awayPlayers = buildPlayerMap(awayBlock);

    const goals: FifaGoalRaw[] = [];
    for (const [block, players, side] of [
      [homeBlock, homePlayers, "home"] as const,
      [awayBlock, awayPlayers, "away"] as const,
    ]) {
      for (const g of block?.Goals ?? []) {
        const min = normMinuteStr(g.Minute);
        if (min === "" || isNaN(parseInt(min, 10))) continue;
        goals.push({
          scorer: players.get(String(g.IdPlayer)) || "?",
          minute: normMinuteStr(g.Minute),
          team: side,
          type: g.Type ?? null,
        });
      }
    }
    goals.sort((a, b) => parseInt(a.minute, 10) - parseInt(b.minute, 10));
    return goals;
  });
}

// Lädt Tor-Details für laufende und alle beendeten Spiele mit Toren.
// Beendete Spiele werden über langlebiges Caching (24h) gespart, nicht über Ausschluss.
// Tore eines beendeten Spiels ändern sich nie mehr → einmal fetchen genügt.
export async function attachFifaGoals(
  matches: Match[],
  fifaData: { scores: Map<number, FifaScores>; fifaIdToAppCode: Map<string, string> },
  locale: string = "de",
): Promise<Match[]> {
  const targets = matches.filter(m =>
    (m.status === "LIVE" || m.status === "IN_PLAY" || m.status === "PAUSED" || m.status === "FINISHED") &&
    ((m.homeScore ?? 0) + (m.awayScore ?? 0)) > 0,
  );
  if (targets.length === 0) return matches;

  const goalsByMatchId = new Map<string, GoalEvent[]>();
  const results = await Promise.allSettled(targets.map(async (m) => {
    const fs = fifaData.scores.get(m.matchNumber);
    if (!fs?.idMatch || !fs?.idStage) return;
    const isFinished = m.status === "FINISHED";
    const ttl = isFinished ? 24 * 60 * 60 * 1000 : 60_000;
    const goals = await fetchFifaGoals(fs.idStage, fs.idMatch, locale, ttl);
    if (goals.length) goalsByMatchId.set(m.id, goals);
  }));

  const fetched = results.filter(r => r.status === "fulfilled").length;
  const failed = results.filter(r => r.status === "rejected").length;
  if (goalsByMatchId.size > 0 || failed > 0) {
    console.log("[fifa-fetch] Goals: geladen für", goalsByMatchId.size, "Matches,", fetched, "OK,", failed, "Fehler");
  }
  if (goalsByMatchId.size === 0) return matches;

  return matches.map(m => {
    const g = goalsByMatchId.get(m.id);
    return g ? { ...m, goals: g.map(({ scorer, minute, team }) => ({ scorer, minute, team })) } : m;
  });
}

// ----------------------------------------------------------------------------
// FIFA Live-Daten Pipeline: kombiniert Scores + Goals in gestufter Abfolge.
// Step 1: Scores von der FIFA-API holen (enthält idMatch/idStage-Mappings).
// Step 2: Scores auf die Matches anwenden (MatchNumber als Schlüssel).
// Step 3: Goal-Details NUR für live/beendete Matches mit Toren nachladen.
//
// Die Schritte werden sequentiell ausgeführt (kein Promise.all wie zuvor),
// damit fehlende ID-Mappings nicht zu sinnlosen Requests führen.
// Jeder Schritt loggt die Array-/Map-Länge, sodass auf der Vercel-Konsole
// sofort ersichtlich ist, ob der Upstream leer ist oder der Fehler im Mapping liegt.
// ----------------------------------------------------------------------------
export async function attachFifaLiveData(
  matches: Match[],
  teams: Team[],
  locale: string = "de",
): Promise<Match[]> {
  // --- Step 1: Scores von FIFA holen ---
  let fifaData: Awaited<ReturnType<typeof fetchFifaScores>>;
  try {
    fifaData = await fetchFifaScores();
  } catch (err) {
    console.warn("[fifa-fetch] Scores fehlgeschlagen:", err instanceof Error ? err.message : err);
    return matches;
  }

  // --- Step 2: Scores auf Matches anwenden ---
  const updated = applyFifaScores(matches, teams, fifaData);

  // --- Step 3: Goal-Details für alle Spiele mit Toren (live + beendet) ---
  // Requests werden durch differenzierte Cache-TTL gespart:
  //   beendete Spiele → 24h (Tore ändern sich nie)
  //   laufende Spiele  → 60s (neue Tore erscheinen)
  const targets = updated.filter(m => {
    const fs = fifaData.scores.get(m.matchNumber);
    return (
      (m.status === "LIVE" || m.status === "IN_PLAY" || m.status === "PAUSED" || m.status === "FINISHED") &&
      ((m.homeScore ?? 0) + (m.awayScore ?? 0)) > 0 &&
      fs?.idMatch != null &&
      fs?.idStage != null
    );
  });

  if (targets.length === 0) {
    console.log("[fifa-fetch] Pipeline: Scores aktualisiert, keine Goal-Requests nötig");
    return updated;
  }

  const goalsByMatchId = new Map<string, GoalEvent[]>();
  let fetched = 0;
  let failed = 0;

  for (const m of targets) {
    const fs = fifaData.scores.get(m.matchNumber)!;
    if (!fs.idMatch || !fs.idStage) continue;
    const isFinished = m.status === "FINISHED";
    const ttl = isFinished ? 24 * 60 * 60 * 1000 : 60_000; // beendet: 24h, live: 60s
    try {
      const goals = await fetchFifaGoals(fs.idStage, fs.idMatch, locale, ttl);
      fetched++;
      if (goals.length) goalsByMatchId.set(m.id, goals);
    } catch {
      failed++;
    }
  }

  console.log("[fifa-fetch] Pipeline: Goals für", goalsByMatchId.size, "Matches geladen (", fetched, "OK,", failed, "Fehler )");

  if (goalsByMatchId.size === 0) return updated;

  return updated.map(m => {
    const g = goalsByMatchId.get(m.id);
    return g ? { ...m, goals: g.map(({ scorer, minute, team }) => ({ scorer, minute, team })) } : m;
  });
}