---
name: schedule-analyzer
description: Analysiert Fußball-Spielpläne (JSON) auf Fairness, Verteilung, Muster und Optimierungspotenzial. Für Heim/Auswärts-Serien, Reisebelastung, Wettbewerbsgleichheit.
argument-hint: [analyse-typ] z.B. fairness, reise, muster
allowed-tools:
  - Read
  - Glob
  - Grep
  - Bash
  - WebSearch
disable-model-invocation: false
---

# Fußball-Spielplan-Analysator

Spezialisierter Skill zur tiefgehenden Analyse von Fußball-Spielplänen. Erkennt strukturelle Probleme, Fairness-Ungleichgewichte und Optimierungspotenziale.

## Wann verwenden

- Analyse von Spielplan-JSON-Dateien auf Fairness und Verteilung
- Erkennung von Heim/Auswärts-Serien und deren Auswirkungen
- Bewertung von Reisebelastung und Regenerationszeiten
- Identifikation von Scheduling-Mustern und Anomalien
- Vergleich verschiedener Spielplan-Varianten
- Vorbereitung von Optimierungs-Empfehlungen

## JSON-Datenstruktur

Erwartetes Format der Spielplan-JSON:

```json
[
  {
    "round": 1,
    "date": "2026-09-01",
    "kickoff_time": "15:30",
    "team_a": {
      "name": "FC Bayern München",
      "country": "GER"
    },
    "team_b": {
      "name": "Borussia Dortmund",
      "country": "GER"
    }
  }
]
```

**Felder:**
- `round`: Spieltag-Nummer
- `date`: Datum im ISO-Format (YYYY-MM-DD)
- `kickoff_time`: Anstoßzeit (optional, kann leer sein)
- `team_a`: Heimmannschaft mit `name` und `country`
- `team_b`: Auswärtsmannschaft mit `name` und `country`

## Analyse-Kategorien

### 1. Fairness-Analyse

Prüfe auf Ungleichgewichte:

- **Heim/Auswärts-Verhältnis**: Jedes Team sollte gleich viele Heim- wie Auswärtsspiele haben
- **Aufeinanderfolgende Heim/Auswärts-Spiele**: Serien von >2 aufeinanderfolgenden Heim- oder Auswärtsspielen sind problematisch
- **Spieltagsverteilung**: Gleiche Anzahl Spiele pro Spieltag für alle Teams
- **Wochenend- vs. Wochentagsspiele**: Faire Verteilung über die Saison

```python
# Beispiel-Metriken berechnen
def analyze_home_away_balance(schedule):
    team_stats = {}
    for game in schedule:
        home = game['team_a']['name']
        away = game['team_b']['name']

        if home not in team_stats:
            team_stats[home] = {'home': 0, 'away': 0}
        if away not in team_stats:
            team_stats[away] = {'home': 0, 'away': 0}

        team_stats[home]['home'] += 1
        team_stats[away]['away'] += 1

    return team_stats
```

### 2. Serien-Erkennung

Identifiziere kritische Muster:

- **Heim-Serien**: Mehr als 2 Heimspiele hintereinander
- **Auswärts-Serien**: Mehr als 2 Auswärtsspiele hintereinander (besonders belastend)
- **Englische Wochen**: Spiele mit <5 Tagen Abstand
- **Regenerationslücken**: Zu lange Pausen (>14 Tage) zwischen Spielen

```python
def detect_streaks(schedule, team_name):
    games = sorted([g for g in schedule
                   if g['team_a']['name'] == team_name
                   or g['team_b']['name'] == team_name],
                  key=lambda x: x['date'])

    streaks = {'home': [], 'away': []}
    current_home_streak = 0
    current_away_streak = 0

    for game in games:
        is_home = game['team_a']['name'] == team_name
        if is_home:
            current_home_streak += 1
            if current_away_streak > 0:
                streaks['away'].append(current_away_streak)
            current_away_streak = 0
        else:
            current_away_streak += 1
            if current_home_streak > 0:
                streaks['home'].append(current_home_streak)
            current_home_streak = 0

    return streaks
```

### 3. Reisebelastungs-Analyse

Für internationale Wettbewerbe oder große Ligen:

- **Gesamtreisestrecke** pro Team (erfordert Geodaten)
- **Back-to-Back Auswärtsreisen**: Zwei Auswärtsspiele nacheinander
- **Zeitzonen-Wechsel**: Bei internationalen Spielplänen
- **Geografische Cluster**: Nahe beieinander liegende Auswärtsspiele

### 4. Saisonverlaufs-Muster

- **Schwierigkeitsgrad-Verteilung**: Top-Teams gleichmäßig über die Saison verteilt?
- **Derby-Termine**: Lokale Derbys nicht zu früh/spät?
- **Saisonstart/-ende**: Keine unverhältnismäßige Häufung von schweren Spielen

## Ausgabeformat

Strukturiere die Analyse wie folgt:

```markdown
## Spielplan-Analyse: [Dateiname]

### Übersicht
- **Anzahl Spiele**: X
- **Anzahl Teams**: Y
- **Zeitraum**: DD.MM.YYYY - DD.MM.YYYY
- **Spieltage**: Z

### Fairness-Bewertung
| Team | Heim | Auswärts | Balance |
|------|------|----------|---------|
| ...  | ...  | ...      | ...     |

### Kritische Befunde
1. **[HOCH]** Team X hat 4 Auswärtsspiele in Folge (Runde 5-8)
2. **[MITTEL]** Ungleiche Wochenendverteilung für Team Y
3. **[NIEDRIG]** ...

### Serien-Übersicht
- Längste Heim-Serie: Team A (3 Spiele, Runde 2-4)
- Längste Auswärts-Serie: Team B (4 Spiele, Runde 5-8)

### Empfehlungen
1. Tausche Spiel in Runde X mit Runde Y für Team Z
2. ...
```

## Analyse-Workflow

1. **Datei laden**: JSON-Spielplan einlesen und validieren
2. **Grundmetriken berechnen**: Teams, Spiele, Zeitraum
3. **Team-basierte Analyse**: Für jedes Team Heim/Auswärts-Statistiken
4. **Serien erkennen**: Aufeinanderfolgende Heim/Auswärts-Spiele finden
5. **Kritische Punkte identifizieren**: Verstöße gegen Fairness-Regeln
6. **Empfehlungen formulieren**: Konkrete Verbesserungsvorschläge

## Best Practices

### Schwellenwerte

| Metrik | Akzeptabel | Warnung | Kritisch |
|--------|------------|---------|----------|
| Heim/Auswärts-Differenz | 0 | 1 | >1 |
| Heim-Serie | 2 | 3 | >3 |
| Auswärts-Serie | 2 | 3 | >3 |
| Tage zwischen Spielen | 5-10 | 3-4 / 11-14 | <3 / >14 |

### Priorisierung

1. **Hoch**: Auswärts-Serien >3, extreme Ungleichgewichte
2. **Mittel**: Heim-Serien >3, ungleiche Wochenendverteilung
3. **Niedrig**: Kleinere Abweichungen, Optimierungspotenzial

## Beispiel-Prompts

Wenn der Benutzer `/schedule-analyzer` aufruft:

- "Analysiere den Spielplan auf Fairness"
- "Zeige mir alle Teams mit Auswärts-Serien von mehr als 2 Spielen"
- "Welches Team hat die ungünstigste Spieltagsverteilung?"
- "Vergleiche die Reisebelastung der Top-4-Teams"
- "Gibt es englische Wochen im Spielplan?"

## Integration mit league-ai

Dieser Skill ergänzt die bestehende `LLMService`-Analyse durch strukturierte, regelbasierte Auswertung. Die KI-gestützte Interpretation kann auf den berechneten Metriken aufbauen.

Spielplan-Dateien befinden sich in `data/schedules/`.