Capstone - Complete Analytics System

# Python: Define match day workflow structure
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import Dict, List, Optional, Any
from enum import Enum

class MatchPhase(Enum):
    PRE_MATCH = "pre_match"
    MATCH_DAY = "match_day"
    LIVE = "live"
    POST_MATCH = "post_match"

@dataclass
class PreMatchData:
    """Container for pre-match analytics."""
    opposition_report: Optional[Dict] = None
    set_piece_analysis: Optional[Dict] = None
    selection_insights: Optional[Dict] = None
    key_matchups: Optional[List[Dict]] = None
    tactical_plan: Optional[Dict] = None

@dataclass
class LiveMatchData:
    """Container for live match analytics."""
    first_half_stats: Optional[Dict] = None
    halftime_analysis: Optional[Dict] = None
    second_half_stats: Optional[Dict] = None
    substitution_recommendations: Optional[List[Dict]] = None

@dataclass
class PostMatchData:
    """Container for post-match analytics."""
    performance_report: Optional[Dict] = None
    player_ratings: Optional[Dict[str, float]] = None
    video_clips: Optional[List[str]] = None
    xg_timeline: Optional[List[Dict]] = None

@dataclass
class MatchDayWorkflow:
    """Complete match day analytics workflow."""
    match_id: str
    opponent: str
    match_date: date
    home_away: str
    competition: str
    pre_match: PreMatchData = field(default_factory=PreMatchData)
    live_match: LiveMatchData = field(default_factory=LiveMatchData)
    post_match: PostMatchData = field(default_factory=PostMatchData)

    def days_until_match(self) -> int:
        """Calculate days until match."""
        return (self.match_date - date.today()).days

    def get_current_phase(self) -> MatchPhase:
        """Determine current workflow phase."""
        days = self.days_until_match()
        if days > 0:
            return MatchPhase.PRE_MATCH
        elif days == 0:
            return MatchPhase.MATCH_DAY
        else:
            return MatchPhase.POST_MATCH

# Example initialization
next_match = MatchDayWorkflow(
    match_id="2024_001",
    opponent="Manchester City",
    match_date=date.today() + timedelta(days=5),
    home_away="Away",
    competition="Premier League"
)

print(f"Match: vs {next_match.opponent} ({next_match.home_away})")
print(f"Days until match: {next_match.days_until_match()}")
print(f"Current phase: {next_match.get_current_phase().value}")

# Python: Build pre-match opposition report
import pandas as pd
import numpy as np
from typing import Dict, List
from dataclasses import dataclass
from datetime import date

@dataclass
class OppositionReport:
    """Structured opposition report."""
    opponent: str
    generated_date: date
    team_style: Dict
    formations: pd.DataFrame
    key_players: Dict[str, pd.DataFrame]
    recent_results: pd.DataFrame
    set_pieces: Dict
    weaknesses: List[str]

class PreMatchAnalyzer:
    """Generate pre-match analysis reports."""

    def generate_opposition_report(self, opponent_name: str,
                                    matches_data: pd.DataFrame,
                                    players_data: pd.DataFrame) -> OppositionReport:
        """Generate comprehensive opposition report."""

        # Filter to opponent matches
        opponent_matches = matches_data[
            matches_data["team"] == opponent_name
        ].sort_values("date", ascending=False).head(10)

        # Calculate team style metrics
        team_style = {
            "avg_possession": opponent_matches["possession"].mean(),
            "avg_xg_for": opponent_matches["xg"].mean(),
            "avg_xg_against": opponent_matches["xg_against"].mean(),
            "avg_ppda": opponent_matches["ppda"].mean(),
            "avg_field_tilt": opponent_matches["field_tilt"].mean(),
            "pressing_style": self._classify_pressing(opponent_matches),
            "build_up_style": self._classify_buildup(opponent_matches)
        }

        # Formation analysis
        formations = opponent_matches.groupby("formation").size().reset_index()
        formations.columns = ["formation", "count"]
        formations["pct"] = formations["count"] / formations["count"].sum() * 100
        formations = formations.sort_values("count", ascending=False)

        # Key players
        opponent_players = players_data[
            players_data["team"] == opponent_name
        ].sort_values("minutes", ascending=False).head(15)

        key_players = {
            "scorers": opponent_players.nlargest(3, "goals"),
            "creators": opponent_players.nlargest(3, "xa"),
            "progressive": opponent_players.nlargest(3, "progressive_passes")
        }

        # Identify weaknesses
        weaknesses = self._identify_weaknesses(team_style, opponent_matches)

        return OppositionReport(
            opponent=opponent_name,
            generated_date=date.today(),
            team_style=team_style,
            formations=formations,
            key_players=key_players,
            recent_results=opponent_matches[["date", "opponent", "result", "score"]],
            set_pieces=self._analyze_set_pieces(opponent_matches),
            weaknesses=weaknesses
        )

    def _classify_pressing(self, matches: pd.DataFrame) -> str:
        """Classify team pressing style."""
        avg_ppda = matches["ppda"].mean()
        if avg_ppda < 8:
            return "High Press"
        elif avg_ppda < 12:
            return "Medium Press"
        return "Low Block"

    def _classify_buildup(self, matches: pd.DataFrame) -> str:
        """Classify build-up style."""
        avg_possession = matches["possession"].mean()
        if avg_possession > 55:
            return "Possession-Based"
        elif avg_possession > 48:
            return "Balanced"
        return "Direct/Counter"

    def _identify_weaknesses(self, style: Dict,
                             matches: pd.DataFrame) -> List[str]:
        """Identify potential weaknesses."""
        weaknesses = []
        if style["avg_xg_against"] > 1.5:
            weaknesses.append("Defensive vulnerability (high xGA)")
        if style["avg_possession"] > 60:
            weaknesses.append("Potentially vulnerable on counter-attacks")
        if matches["goals_conceded_set_pieces"].mean() > 0.5:
            weaknesses.append("Set piece defending issues")
        return weaknesses

    def _analyze_set_pieces(self, matches: pd.DataFrame) -> Dict:
        """Analyze set piece patterns."""
        return {
            "corners_per_game": matches["corners"].mean(),
            "set_piece_goals": matches["goals_from_set_pieces"].sum(),
            "set_piece_goals_conceded": matches["goals_conceded_set_pieces"].sum()
        }

    def format_report(self, report: OppositionReport) -> str:
        """Format report for display."""
        output = f"""
=== OPPOSITION REPORT: {report.opponent} ===
Generated: {report.generated_date}

TEAM STYLE:
  Possession: {report.team_style["avg_possession"]:.1f}%
  Build-up: {report.team_style["build_up_style"]}
  Pressing: {report.team_style["pressing_style"]}
  xG For: {report.team_style["avg_xg_for"]:.2f}
  xG Against: {report.team_style["avg_xg_against"]:.2f}

FORMATIONS:
{report.formations.head(3).to_string(index=False)}

KEY THREATS:
  Scorers: {", ".join(report.key_players["scorers"]["player"].tolist())}
  Creators: {", ".join(report.key_players["creators"]["player"].tolist())}

IDENTIFIED WEAKNESSES:
{chr(10).join(["  - " + w for w in report.weaknesses])}
"""
        return output

analyzer = PreMatchAnalyzer()
print("Pre-match analyzer ready")

# Python: Identify key matchups
import pandas as pd
from typing import Dict, List, Optional
from dataclasses import dataclass

@dataclass
class Matchup:
    """Individual player matchup."""
    our_player: str
    opponent: str
    our_stats: Dict
    opponent_stats: Dict
    advantage: str
    key_metric: str

class MatchupAnalyzer:
    """Analyze key player matchups."""

    def analyze_matchups(self, our_players: pd.DataFrame,
                         opponent_players: pd.DataFrame,
                         our_formation: str,
                         opp_formation: str) -> List[Matchup]:
        """Identify key matchups based on formations."""
        matchups = []

        # Striker vs Center-backs
        striker_matchup = self._analyze_striker_matchup(
            our_players, opponent_players
        )
        if striker_matchup:
            matchups.append(striker_matchup)

        # Winger vs Full-back
        winger_matchups = self._analyze_winger_matchups(
            our_players, opponent_players
        )
        matchups.extend(winger_matchups)

        # Midfield battle
        midfield_matchup = self._analyze_midfield(
            our_players, opponent_players
        )
        if midfield_matchup:
            matchups.append(midfield_matchup)

        return matchups

    def _analyze_striker_matchup(self, our_players: pd.DataFrame,
                                  opp_players: pd.DataFrame) -> Optional[Matchup]:
        """Analyze striker vs center-back matchup."""
        our_strikers = our_players[
            our_players["position"].str.contains("FW|CF|ST", na=False)
        ].sort_values("minutes", ascending=False)

        opp_cbs = opp_players[
            opp_players["position"].str.contains("CB|DC", na=False)
        ].sort_values("minutes", ascending=False)

        if our_strikers.empty or opp_cbs.empty:
            return None

        striker = our_strikers.iloc[0]
        cb = opp_cbs.iloc[0]

        # Determine advantage
        aerial_diff = striker.get("aerial_win_pct", 50) - cb.get("aerial_win_pct", 50)
        pace_diff = striker.get("pace", 70) - cb.get("pace", 70)

        if aerial_diff > 10:
            advantage = "Aerial advantage - target with crosses"
            key_metric = "aerial"
        elif pace_diff > 5:
            advantage = "Pace advantage - play balls in behind"
            key_metric = "pace"
        elif pace_diff < -5:
            advantage = "Opponent has pace advantage - hold up play"
            key_metric = "pace"
        else:
            advantage = "Even matchup - vary approach"
            key_metric = "balanced"

        return Matchup(
            our_player=striker["player"],
            opponent=cb["player"],
            our_stats={"aerial": striker.get("aerial_win_pct", 50),
                       "pace": striker.get("pace", 70)},
            opponent_stats={"aerial": cb.get("aerial_win_pct", 50),
                           "pace": cb.get("pace", 70)},
            advantage=advantage,
            key_metric=key_metric
        )

    def _analyze_winger_matchups(self, our_players: pd.DataFrame,
                                  opp_players: pd.DataFrame) -> List[Matchup]:
        """Analyze winger vs full-back matchups."""
        matchups = []
        # Implementation similar to striker matchup
        return matchups

    def _analyze_midfield(self, our_players: pd.DataFrame,
                          opp_players: pd.DataFrame) -> Optional[Matchup]:
        """Analyze midfield battle."""
        # Implementation
        return None

    def format_matchups(self, matchups: List[Matchup]) -> str:
        """Format matchups for display."""
        output = "\n=== KEY MATCHUPS ===\n"
        for m in matchups:
            output += f"""
{m.our_player} vs {m.opponent}
  Our stats: {m.our_stats}
  Their stats: {m.opponent_stats}
  Assessment: {m.advantage}
"""
        return output

print("Matchup analyzer ready")

# Python: Live match tracking system
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from datetime import datetime
import pandas as pd

@dataclass
class LiveStats:
    """Running match statistics."""
    team: str
    shots: int = 0
    shots_on_target: int = 0
    xg: float = 0.0
    passes: int = 0
    pass_accuracy: float = 0.0
    possession: float = 50.0
    corners: int = 0
    fouls: int = 0
    yellows: int = 0
    reds: int = 0

class LiveMatchTracker:
    """Track and analyze match in real-time."""

    def __init__(self, match_id: str, home_team: str, away_team: str):
        self.match_id = match_id
        self.home_team = home_team
        self.away_team = away_team

        self.events: List[Dict] = []
        self.score = {"home": 0, "away": 0}
        self.current_minute = 0

        self.home_stats = LiveStats(team=home_team)
        self.away_stats = LiveStats(team=away_team)

    def add_event(self, minute: int, event_type: str, team: str,
                  player: Optional[str] = None, **details):
        """Add match event and update stats."""
        event = {
            "minute": minute,
            "event_type": event_type,
            "team": team,
            "player": player,
            "timestamp": datetime.now(),
            **details
        }
        self.events.append(event)
        self.current_minute = minute
        self._update_stats(event)

    def _update_stats(self, event: Dict):
        """Update running statistics based on event."""
        stats = self.home_stats if event["team"] == self.home_team else self.away_stats

        if event["event_type"] == "shot":
            stats.shots += 1
            if event.get("on_target"):
                stats.shots_on_target += 1
            stats.xg += event.get("xg", 0)

        elif event["event_type"] == "goal":
            if event["team"] == self.home_team:
                self.score["home"] += 1
            else:
                self.score["away"] += 1

        elif event["event_type"] == "corner":
            stats.corners += 1

        elif event["event_type"] == "foul":
            stats.fouls += 1

        elif event["event_type"] == "yellow_card":
            stats.yellows += 1

    def generate_halftime_report(self) -> Dict:
        """Generate halftime analysis report."""
        xg_diff = self.home_stats.xg - self.away_stats.xg

        return {
            "score": self.score,
            "xg": {
                "home": round(self.home_stats.xg, 2),
                "away": round(self.away_stats.xg, 2),
                "diff": round(xg_diff, 2)
            },
            "shots": {
                "home": f"{self.home_stats.shots} ({self.home_stats.shots_on_target} on target)",
                "away": f"{self.away_stats.shots} ({self.away_stats.shots_on_target} on target)"
            },
            "key_events": [e for e in self.events
                          if e["event_type"] in ["goal", "yellow_card", "red_card"]],
            "recommendations": self._generate_recommendations()
        }

    def _generate_recommendations(self) -> List[str]:
        """Generate tactical recommendations."""
        recs = []
        xg_diff = self.home_stats.xg - self.away_stats.xg
        score_diff = self.score["home"] - self.score["away"]

        if xg_diff < -0.5 and score_diff >= 0:
            recs.append("Overperforming xG - consider defensive consolidation")
        if xg_diff > 0.5 and score_diff <= 0:
            recs.append("Creating chances but not converting - maintain approach")
        if self.away_stats.xg > 1.0 and self.score["away"] == 0:
            recs.append("Opponent creating quality chances - tighten defense")

        return recs

    def format_halftime_display(self) -> str:
        """Format halftime report for display."""
        report = self.generate_halftime_report()
        return f"""
=== HALFTIME REPORT ===
Score: {self.home_team} {report["score"]["home"]} - {report["score"]["away"]} {self.away_team}

xG: {report["xg"]["home"]} - {report["xg"]["away"]}
Shots: {report["shots"]["home"]} - {report["shots"]["away"]}

Recommendations:
{chr(10).join(["  - " + r for r in report["recommendations"]])}
"""

print("Live match tracker ready")

# Python: Comprehensive post-match report generator
import pandas as pd
import numpy as np
from typing import Dict, List
from dataclasses import dataclass

@dataclass
class PostMatchReport:
    """Complete post-match analysis report."""
    match_id: str
    result: str
    score: str
    xg_analysis: Dict
    player_ratings: pd.DataFrame
    key_moments: pd.DataFrame
    improvement_areas: List[str]
    tactical_notes: List[str]

class PostMatchAnalyzer:
    """Generate comprehensive post-match analysis."""

    def generate_report(self, match_events: pd.DataFrame,
                        player_stats: pd.DataFrame,
                        our_team: str,
                        opponent: str) -> PostMatchReport:
        """Generate complete post-match report."""

        # Calculate match result
        our_goals = len(match_events[
            (match_events["event_type"] == "goal") &
            (match_events["team"] == our_team)
        ])
        opp_goals = len(match_events[
            (match_events["event_type"] == "goal") &
            (match_events["team"] == opponent)
        ])

        if our_goals > opp_goals:
            result = "Win"
        elif our_goals < opp_goals:
            result = "Loss"
        else:
            result = "Draw"

        # xG analysis
        our_xg = match_events[match_events["team"] == our_team]["xg"].sum()
        opp_xg = match_events[match_events["team"] == opponent]["xg"].sum()

        xg_analysis = {
            "our_xg": round(our_xg, 2),
            "opponent_xg": round(opp_xg, 2),
            "xg_difference": round(our_xg - opp_xg, 2),
            "goal_difference": our_goals - opp_goals,
            "performance": self._assess_performance(
                our_goals - opp_goals, our_xg - opp_xg
            )
        }

        # Player ratings
        player_ratings = self._calculate_player_ratings(
            player_stats[player_stats["team"] == our_team]
        )

        # Key moments
        key_moments = match_events[
            match_events["event_type"].isin(["goal", "red_card", "penalty"])
        ][["minute", "event_type", "team", "player"]]

        # Improvement areas
        improvement_areas = self._identify_improvements(match_events, our_team)

        return PostMatchReport(
            match_id=match_events["match_id"].iloc[0] if not match_events.empty else "N/A",
            result=result,
            score=f"{our_goals} - {opp_goals}",
            xg_analysis=xg_analysis,
            player_ratings=player_ratings,
            key_moments=key_moments,
            improvement_areas=improvement_areas,
            tactical_notes=[]
        )

    def _assess_performance(self, goal_diff: int, xg_diff: float) -> str:
        """Assess performance vs expectation."""
        actual_vs_expected = goal_diff - xg_diff
        if actual_vs_expected > 0.5:
            return "Overperformed expectations"
        elif actual_vs_expected < -0.5:
            return "Underperformed expectations"
        return "Performed as expected"

    def _calculate_player_ratings(self, stats: pd.DataFrame) -> pd.DataFrame:
        """Calculate player match ratings."""
        df = stats.copy()

        # Base rating + contributions
        df["rating"] = 6.0  # Base
        df["rating"] += df.get("goals", 0) * 0.5
        df["rating"] += df.get("assists", 0) * 0.3
        df["rating"] += df.get("key_passes", 0) * 0.1
        df["rating"] += df.get("tackles_won", 0) * 0.05
        df["rating"] -= df.get("errors", 0) * 0.3

        # Clamp ratings 4-10
        df["rating"] = df["rating"].clip(4, 10)

        return df.sort_values("rating", ascending=False)[
            ["player", "position", "minutes", "rating"]
        ]

    def _identify_improvements(self, events: pd.DataFrame,
                               our_team: str) -> List[str]:
        """Identify areas for improvement."""
        improvements = []

        # Check for goals conceded from set pieces
        goals_conceded = events[
            (events["event_type"] == "goal") &
            (events["team"] != our_team)
        ]

        if "situation" in goals_conceded.columns:
            set_piece_goals = goals_conceded[
                goals_conceded["situation"].str.contains(
                    "corner|free kick", case=False, na=False
                )
            ]
            if len(set_piece_goals) > 0:
                improvements.append(
                    f"Set piece defending: {len(set_piece_goals)} goal(s) conceded"
                )

        return improvements

    def format_report(self, report: PostMatchReport) -> str:
        """Format report for display."""
        return f"""
================================================================================
                      POST-MATCH ANALYSIS REPORT
================================================================================
Result: {report.result} ({report.score})

xG ANALYSIS:
  Our xG: {report.xg_analysis["our_xg"]}
  Opponent xG: {report.xg_analysis["opponent_xg"]}
  xG Difference: {report.xg_analysis["xg_difference"]:+.2f}
  Assessment: {report.xg_analysis["performance"]}

PLAYER RATINGS:
{report.player_ratings.head(5).to_string(index=False)}

AREAS FOR IMPROVEMENT:
{chr(10).join(["  - " + a for a in report.improvement_areas]) or "  None identified"}
================================================================================
"""

print("Post-match analyzer ready")