Capstone - Complete Analytics System

import pandas as pd
from tabulate import tabulate

# Sports Analytics Timeline and Maturity Assessment
sports_analytics_evolution = pd.DataFrame({
    "sport": ["Baseball (MLB)", "Basketball (NBA)", "American Football (NFL)",
              "Hockey (NHL)", "Football (Soccer)"],
    "analytics_start": [1970, 2002, 2010, 2012, 2012],
    "major_breakthrough": ["Sabermetrics/Moneyball", "SportVU Tracking",
                           "NFL Next Gen Stats", "Expected Goals", "Opta/StatsBomb"],
    "current_maturity": ["Very High", "High", "High", "Medium-High", "Medium"],
    "key_metrics": ["WAR, OPS+, FIP", "RAPTOR, EPM, PIE", "EPA, CPOE, Win Rate",
                    "xG, Corsi, GSAA", "xG, xA, PPDA"],
    "tracking_adoption": ["2015 (Statcast)", "2013 (SportVU)", "2016 (Zebra)",
                          "2020 (Puck/Player)", "2019 (Limited)"],
    "open_data": ["High (Baseball Reference)", "Medium (NBA API)",
                  "Low (Limited)", "Medium (NHL API)", "Medium (StatsBomb)"]
})

print("Sports Analytics Maturity Comparison")
print("=" * 80)
print(tabulate(sports_analytics_evolution, headers="keys", tablefmt="grid", showindex=False))

# Summary statistics
print("\n\nKey Insights:")
print(f"- Earliest analytics adoption: Baseball ({sports_analytics_evolution['analytics_start'].min()})")
print(f"- Most recent tracking adoption: Hockey/Football (post-2019)")
print(f"- Football has medium maturity but fastest growth potential")

import pandas as pd
import numpy as np

# Concept Translation: Baseball to Football
# WAR (Wins Above Replacement) -> Goals Above Replacement (GAR)

def calculate_football_gar(player_data: pd.DataFrame) -> pd.DataFrame:
    """
    Football adaptation of baseball's WAR concept.
    Calculates Goals Above Replacement for football players.
    """

    # Define replacement level by position
    replacement_levels = {
        "Forward": 0.15,
        "Midfielder": 0.08,
        "Defender": 0.02,
        "Goalkeeper": -0.05
    }

    results = player_data.copy()

    # Get replacement level for each player
    results["replacement_level"] = results["position"].map(replacement_levels)

    # Calculate 90s played
    results["nineties"] = results["minutes"] / 90

    # Offensive contribution (xG + xA above replacement)
    results["offensive_gar"] = (
        (results["npxg_per_90"] + results["xa_per_90"] - results["replacement_level"])
        * results["nineties"]
    )

    # Defensive contribution
    results["defensive_gar"] = (
        (results["tackles_won_per_90"] * 0.05 +
         results["interceptions_per_90"] * 0.04 +
         results["blocks_per_90"] * 0.03)
        * results["nineties"]
    )

    # Possession contribution
    results["possession_gar"] = (
        (results["progressive_passes_per_90"] * 0.02 +
         results["progressive_carries_per_90"] * 0.015)
        * results["nineties"]
    )

    # Total Goals Above Replacement
    results["total_gar"] = (
        results["offensive_gar"] +
        results["defensive_gar"] +
        results["possession_gar"]
    )

    # Convert to Wins (roughly 2.5 goals per win)
    results["war_equivalent"] = results["total_gar"] / 2.5

    return results


# Example player data
example_players = pd.DataFrame({
    "player": ["Elite Forward", "Good Midfielder", "Solid Defender", "Average GK"],
    "position": ["Forward", "Midfielder", "Defender", "Goalkeeper"],
    "minutes": [2800, 3000, 2500, 3200],
    "npxg_per_90": [0.65, 0.15, 0.05, 0.00],
    "xa_per_90": [0.25, 0.20, 0.08, 0.02],
    "tackles_won_per_90": [0.8, 2.1, 3.5, 0.1],
    "interceptions_per_90": [0.5, 1.8, 2.8, 0.2],
    "blocks_per_90": [0.3, 0.8, 1.5, 0.0],
    "progressive_passes_per_90": [2.5, 5.8, 4.2, 3.5],
    "progressive_carries_per_90": [4.2, 3.5, 1.8, 0.1]
})

# Calculate GAR
gar_results = calculate_football_gar(example_players)

print("Goals Above Replacement (GAR) Analysis")
print("=" * 60)
print(gar_results[["player", "position", "total_gar", "war_equivalent"]]
      .sort_values("total_gar", ascending=False)
      .to_string(index=False))

# Breakdown by component
print("\n\nGAR Component Breakdown:")
print(gar_results[["player", "offensive_gar", "defensive_gar", "possession_gar"]]
      .to_string(index=False))

import pandas as pd
import numpy as np

# Basketball Spatial Analytics Concepts Applied to Football
# Shot Charts -> Shot Maps with xG

def create_football_shot_chart(shots_data: pd.DataFrame) -> pd.DataFrame:
    """
    Apply basketball-style spatial analysis to football shots.
    Creates zones and calculates value above average.
    """

    result = shots_data.copy()

    # Zone classification (inspired by basketball court zones)
    def classify_zone(row):
        if row["distance"] <= 6:
            return "Six-Yard Box"
        elif row["distance"] <= 18 and abs(row["angle"]) < 30:
            return "Central Penalty Area"
        elif row["distance"] <= 18:
            return "Wide Penalty Area"
        elif row["distance"] <= 25 and abs(row["angle"]) < 25:
            return "Central Edge"
        elif row["distance"] <= 30:
            return "Long Range Central"
        else:
            return "Long Range Wide"

    result["zone"] = result.apply(classify_zone, axis=1)

    # Zone average xG (league benchmarks)
    zone_avg_xg = {
        "Six-Yard Box": 0.45,
        "Central Penalty Area": 0.22,
        "Wide Penalty Area": 0.08,
        "Central Edge": 0.06,
        "Long Range Central": 0.04,
        "Long Range Wide": 0.02
    }

    result["zone_xg_avg"] = result["zone"].map(zone_avg_xg)
    result["xg_above_average"] = result["xg"] - result["zone_xg_avg"]

    return result


# Simulate shot data
np.random.seed(42)
n_shots = 200

shot_data = pd.DataFrame({
    "shot_id": range(1, n_shots + 1),
    "player": np.random.choice(["Player A", "Player B", "Player C"], n_shots),
    "distance": np.random.uniform(3, 35, n_shots),
    "angle": np.random.uniform(-45, 45, n_shots)
})

# Generate xG based on distance
shot_data["xg"] = shot_data["distance"].apply(
    lambda d: np.random.uniform(0.35, 0.65) if d <= 6
    else (np.random.uniform(0.05, 0.35) if d <= 18
          else np.random.uniform(0.01, 0.08))
)

# Simulate goals
shot_data["goal"] = np.random.binomial(1, shot_data["xg"].clip(upper=0.8))

# Apply zone analysis
shot_analysis = create_football_shot_chart(shot_data)

# Summarize by zone (like basketball shot chart analysis)
zone_summary = shot_analysis.groupby("zone").agg(
    shots=("shot_id", "count"),
    goals=("goal", "sum"),
    total_xg=("xg", "sum"),
    conversion_rate=("goal", "mean"),
    avg_xg=("xg", "mean")
).reset_index()

zone_summary["xg_outperformance"] = zone_summary["conversion_rate"] - zone_summary["avg_xg"]
zone_summary = zone_summary.sort_values("avg_xg", ascending=False)

print("Shot Zone Analysis (Basketball-Style)")
print("=" * 70)
print(zone_summary.to_string(index=False))

# Player shot selection quality
player_shot_quality = shot_analysis.groupby("player").agg(
    shots=("shot_id", "count"),
    avg_shot_xg=("xg", "mean")
).reset_index()

player_shot_quality["shot_quality_percentile"] = (
    player_shot_quality["avg_shot_xg"].rank(pct=True) * 100
)

print("\n\nPlayer Shot Selection Quality:")
print(player_shot_quality.to_string(index=False))

import pandas as pd
import numpy as np

# Adapting Basketball Plus-Minus to Football
# RAPM (Regularized Adjusted Plus-Minus) Football Version

def calculate_football_plus_minus(match_segments: pd.DataFrame) -> pd.DataFrame:
    """
    Football adaptation of basketball's plus-minus metrics.
    Uses xG differential instead of goals due to low-scoring nature.
    """

    results = match_segments.groupby("player_id").agg(
        minutes_on=("segment_minutes", "sum"),
        total_team_xg=("team_xg", "sum"),
        total_opponent_xg=("opponent_xg", "sum"),
        avg_teammate_quality=("teammate_avg_rating", "mean"),
        avg_opponent_quality=("opponent_avg_rating", "mean")
    ).reset_index()

    # Calculate per-90 metrics
    results["nineties"] = results["minutes_on"] / 90
    results["xg_for_per_90"] = results["total_team_xg"] / results["nineties"]
    results["xg_against_per_90"] = results["total_opponent_xg"] / results["nineties"]
    results["xg_diff_per_90"] = results["xg_for_per_90"] - results["xg_against_per_90"]

    # Adjusted plus-minus (control for teammate/opponent quality)
    results["adjusted_xg_diff"] = (
        results["xg_diff_per_90"] -
        (results["avg_teammate_quality"] - 8) * 0.1 +
        (results["avg_opponent_quality"] - 8) * 0.1
    )

    return results


# Simulate match segment data
np.random.seed(123)
n_segments = 500

match_segments = pd.DataFrame({
    "segment_id": range(1, n_segments + 1),
    "player_id": np.random.choice([f"Player_{i}" for i in range(1, 21)], n_segments),
    "segment_minutes": np.random.uniform(5, 45, n_segments),
    "team_xg": np.random.poisson(0.4, n_segments),
    "opponent_xg": np.random.poisson(0.35, n_segments),
    "teammate_avg_rating": np.random.normal(7.5, 0.8, n_segments),
    "opponent_avg_rating": np.random.normal(7.5, 0.8, n_segments)
})

# Calculate plus-minus
plus_minus_results = calculate_football_plus_minus(match_segments)

# Filter for minimum minutes and show top performers
qualified = plus_minus_results[plus_minus_results["minutes_on"] >= 400]
top_performers = qualified.nlargest(10, "adjusted_xg_diff")

print("Football Plus-Minus Rankings (xG Differential per 90)")
print("=" * 60)
print(top_performers[["player_id", "minutes_on", "xg_diff_per_90", "adjusted_xg_diff"]]
      .to_string(index=False))

import pandas as pd
import numpy as np

# Hockey Analytics Concepts Applied to Football
# Corsi -> Territorial Dominance Metrics

def calculate_football_corsi(match_data: pd.DataFrame) -> pd.DataFrame:
    """
    Apply hockey's Corsi concept to football.
    Measures territorial dominance through attacking actions.
    """

    result = match_data.copy()

    # Football "Corsi" - territorial actions
    result["team_corsi"] = (
        result["shots"] + result["shots_blocked"] + result["crosses_attempted"] +
        result["final_third_entries"] + result["box_entries"]
    )

    result["opponent_corsi"] = (
        result["opponent_shots"] + result["opponent_shots_blocked"] +
        result["opponent_crosses_attempted"] + result["opponent_final_third_entries"] +
        result["opponent_box_entries"]
    )

    # Corsi For percentage (CF%)
    result["corsi_for_pct"] = (
        result["team_corsi"] / (result["team_corsi"] + result["opponent_corsi"]) * 100
    )

    # High-danger chances (like hockey slot shots)
    result["high_danger_cf"] = result["shots_inside_box"] + result["headers_inside_box"]
    result["high_danger_ca"] = (
        result["opponent_shots_inside_box"] + result["opponent_headers_inside_box"]
    )
    result["high_danger_cf_pct"] = (
        result["high_danger_cf"] / (result["high_danger_cf"] + result["high_danger_ca"]) * 100
    )

    # PDO (shooting % + save %) - regression indicator
    result["shooting_pct"] = result["goals"] / result["shots"] * 100
    result["save_pct"] = (1 - result["opponent_goals"] / result["opponent_shots"]) * 100
    result["pdo"] = result["shooting_pct"] / 10 + result["save_pct"]

    return result


# Generate example match data
np.random.seed(42)
n_matches = 20

match_data = pd.DataFrame({
    "match_id": range(1, n_matches + 1),
    "team": "Example FC",
    "shots": np.random.poisson(14, n_matches),
    "shots_blocked": np.random.poisson(4, n_matches),
    "crosses_attempted": np.random.poisson(18, n_matches),
    "final_third_entries": np.random.poisson(35, n_matches),
    "box_entries": np.random.poisson(12, n_matches),
    "shots_inside_box": np.random.poisson(8, n_matches),
    "headers_inside_box": np.random.poisson(2, n_matches),
    "goals": np.random.poisson(1.5, n_matches),
    "opponent_shots": np.random.poisson(12, n_matches),
    "opponent_shots_blocked": np.random.poisson(3, n_matches),
    "opponent_crosses_attempted": np.random.poisson(15, n_matches),
    "opponent_final_third_entries": np.random.poisson(30, n_matches),
    "opponent_box_entries": np.random.poisson(10, n_matches),
    "opponent_shots_inside_box": np.random.poisson(6, n_matches),
    "opponent_headers_inside_box": np.random.poisson(1, n_matches),
    "opponent_goals": np.random.poisson(1.2, n_matches)
})

# Apply hockey-style analysis
hockey_style_analysis = calculate_football_corsi(match_data)

# Season summary
print("Season Summary (Hockey-Style Metrics)")
print("=" * 50)
print(f"Matches: {len(hockey_style_analysis)}")
print(f"Avg Corsi For %: {hockey_style_analysis['corsi_for_pct'].mean():.1f}%")
print(f"Avg High Danger CF%: {hockey_style_analysis['high_danger_cf_pct'].mean():.1f}%")
print(f"Avg PDO: {hockey_style_analysis['pdo'].mean():.1f}")
print(f"Goals For: {hockey_style_analysis['goals'].sum()}")
print(f"Goals Against: {hockey_style_analysis['opponent_goals'].sum()}")

# PDO analysis
print("\n\nPDO Analysis (values far from 100 = regression candidate):")
hockey_style_analysis["pdo_deviation"] = abs(hockey_style_analysis["pdo"] - 100)
print(hockey_style_analysis.nlargest(5, "pdo_deviation")[
    ["match_id", "corsi_for_pct", "pdo", "goals", "opponent_goals"]
].to_string(index=False))

import pandas as pd
import numpy as np

# American Football Concepts Applied to Soccer
# EPA (Expected Points Added) -> Expected Goals State Model

def calculate_football_epa(events_data: pd.DataFrame) -> pd.DataFrame:
    """
    Adapt NFL's Expected Points Added to football.
    Measures value added by actions based on field position changes.
    """

    result = events_data.copy()

    # Expected goals from current state (pre-action)
    zone_xg = {
        "opponent_box": 0.15,
        "opponent_final_third": 0.05,
        "middle_third": 0.02,
        "own_final_third": 0.005
    }

    result_zone_xg = {
        "goal": 1.0,
        "opponent_box": 0.15,
        "opponent_final_third": 0.05,
        "middle_third": 0.02,
        "own_final_third": 0.005,
        "turnover": -0.03
    }

    result["pre_xg_state"] = result["pitch_zone"].map(zone_xg).fillna(0.01)
    result["post_xg_state"] = result["result_zone"].map(result_zone_xg).fillna(0.01)

    # EPA equivalent: Change in expected goals
    result["xg_added"] = result["post_xg_state"] - result["pre_xg_state"]

    # Game state adjustment
    def game_state_multiplier(row):
        if row["minute"] >= 80 and row["goal_diff"] < 0:
            return 1.3  # Chasing late
        elif row["minute"] >= 80 and row["goal_diff"] > 0:
            return 0.7  # Protecting lead
        elif row["goal_diff"] <= -2:
            return 1.2  # Need goals
        elif row["goal_diff"] >= 2:
            return 0.8  # Comfortable
        return 1.0

    result["game_state_multiplier"] = result.apply(game_state_multiplier, axis=1)
    result["adjusted_xg_added"] = result["xg_added"] * result["game_state_multiplier"]

    return result


def calculate_win_probability(minute: int, goal_diff: int, home: bool = True) -> dict:
    """
    NFL-style win probability model adapted for football.
    """

    remaining_minutes = 90 - minute
    goals_per_minute = 0.028  # ~2.5 goals per game

    # Expected goals remaining
    home_factor = 1.1 if home else 0.9
    team_expected = remaining_minutes * goals_per_minute * home_factor
    opponent_expected = remaining_minutes * goals_per_minute * (2 - home_factor)

    # Current advantage in expected final goals
    expected_final_diff = goal_diff + team_expected - opponent_expected

    # Convert to win probability (logistic function)
    win_prob = 1 / (1 + np.exp(-expected_final_diff * 0.8))
    draw_prob = max(0, 0.25 - abs(expected_final_diff) * 0.05) * \
                (1 - abs(minute - 45) / 90)

    return {
        "win": win_prob * (1 - draw_prob),
        "draw": draw_prob,
        "loss": (1 - win_prob) * (1 - draw_prob)
    }


# Example: Win probability at different game states
scenarios = [
    {"scenario": "Start (0-0)", "minute": 0, "goal_diff": 0},
    {"scenario": "Down 1 at HT", "minute": 45, "goal_diff": -1},
    {"scenario": "Up 1 at 75'", "minute": 75, "goal_diff": 1},
    {"scenario": "Down 2 at 80'", "minute": 80, "goal_diff": -2}
]

print("Win Probability by Game State")
print("=" * 60)
print(f"{'Scenario':<20} {'Win%':>10} {'Draw%':>10} {'Loss%':>10}")
print("-" * 60)

for s in scenarios:
    probs = calculate_win_probability(s["minute"], s["goal_diff"])
    print(f"{s['scenario']:<20} {probs['win']*100:>9.1f}% {probs['draw']*100:>9.1f}% {probs['loss']*100:>9.1f}%")

import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Optional

# Unified Cross-Sport Analytics Framework for Football

class CrossSportAnalytics:
    """
    Unified framework synthesizing analytics concepts from
    baseball, basketball, hockey, and American football.
    """

    def __init__(self):
        print("Cross-Sport Analytics Framework initialized")

    def calculate_total_value(self, player_data: pd.DataFrame) -> pd.DataFrame:
        """
        Baseball-style comprehensive value metric (WAR equivalent).
        """
        result = player_data.copy()

        # Offensive value (baseball-style linear weights)
        result["offensive_value"] = (
            result["npxg_per_90"] * 0.4 +
            result["xa_per_90"] * 0.3 +
            result["key_passes_per_90"] * 0.05
        )

        # Defensive value
        result["defensive_value"] = (
            result["tackles_won_per_90"] * 0.05 +
            result["interceptions_per_90"] * 0.04 +
            result["pressures_per_90"] * 0.02
        )

        # Progression value
        result["progression_value"] = (
            result["progressive_passes_per_90"] * 0.02 +
            result["progressive_carries_per_90"] * 0.015
        )

        # Total Goals Above Replacement
        result["total_gar"] = (
            (result["offensive_value"] + result["defensive_value"] +
             result["progression_value"]) * (result["minutes"] / 90)
        )

        return result

    def calculate_spatial_efficiency(self, shot_data: pd.DataFrame) -> pd.DataFrame:
        """
        Basketball-style spatial efficiency analysis.
        """
        shot_data = shot_data.copy()

        def classify_zone(distance):
            if distance <= 6:
                return "high_value"
            elif distance <= 18:
                return "medium_value"
            return "low_value"

        shot_data["zone"] = shot_data["distance"].apply(classify_zone)

        return shot_data.groupby(["player_id", "zone"]).agg(
            shots=("shot_id", "count"),
            xg=("xg", "sum"),
            goals=("goal", "sum")
        ).reset_index().assign(
            efficiency=lambda df: df["goals"] / df["xg"].replace(0, np.nan)
        )

    def calculate_territorial_dominance(self, match_data: pd.DataFrame) -> pd.DataFrame:
        """
        Hockey-style territorial dominance metrics (Corsi adaptation).
        """
        result = match_data.copy()

        result["team_territory"] = (
            result["final_third_entries"] + result["box_entries"] + result["shots"]
        )
        result["opponent_territory"] = (
            result["opp_final_third_entries"] + result["opp_box_entries"] +
            result["opp_shots"]
        )
        result["territorial_cf"] = (
            result["team_territory"] /
            (result["team_territory"] + result["opponent_territory"])
        )

        # PDO for regression analysis
        result["pdo"] = (
            (result["goals"] / result["shots"] * 10) +
            ((result["opp_shots"] - result["opp_goals"]) / result["opp_shots"] * 100)
        )

        return result

    def calculate_game_state_value(self, events_data: pd.DataFrame) -> pd.DataFrame:
        """
        NFL-style game state value model.
        """
        result = events_data.copy()

        # State-based expected value
        zone_values = {
            "opponent_box": 0.15,
            "opponent_third": 0.05,
            "middle_third": 0.02
        }
        result["state_value"] = result["zone"].map(zone_values).fillna(0.005)

        # Game state adjustment
        def state_multiplier(row):
            if row["minute"] >= 75 and row["goal_diff"] < 0:
                return 1.3
            elif row["minute"] >= 75 and row["goal_diff"] > 0:
                return 0.7
            return 1.0

        result["state_multiplier"] = result.apply(state_multiplier, axis=1)
        result["adjusted_value"] = result["state_value"] * result["state_multiplier"]

        return result


# Usage example
framework = CrossSportAnalytics()

# Example player data
sample_player = pd.DataFrame({
    "player": ["Star Forward"],
    "minutes": [2800],
    "npxg_per_90": [0.55],
    "xa_per_90": [0.18],
    "key_passes_per_90": [2.1],
    "tackles_won_per_90": [0.9],
    "interceptions_per_90": [0.5],
    "pressures_per_90": [18.5],
    "progressive_passes_per_90": [3.2],
    "progressive_carries_per_90": [5.8]
})

result = framework.calculate_total_value(sample_player)

print("Player Total Value (GAR) Analysis")
print("=" * 60)
print(result[["player", "offensive_value", "defensive_value",
              "progression_value", "total_gar"]].to_string(index=False))