Capstone - Complete Analytics System

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsbombpy import sb

# ============================================
# COMPLETE PPDA ANALYSIS SYSTEM
# ============================================

def calculate_match_ppda(events, team_name):
    """
    Calculate PPDA and zone metrics for a single match.
    """
    # Helper to extract x coordinate
    def get_x(loc):
        return loc[0] if isinstance(loc, list) else np.nan

    events = events.copy()
    events['x'] = events['location'].apply(get_x)

    # Opponent passes in their defensive zone
    opponent_passes = len(events[
        (events['team'] != team_name) &
        (events['type'] == 'Pass') &
        (events['x'] < 60)
    ])

    # Our defensive actions in opponent's half
    defensive_types = ['Pressure', 'Tackle', 'Interception', 'Foul Committed', 'Duel']
    defensive_actions = len(events[
        (events['team'] == team_name) &
        (events['type'].isin(defensive_types)) &
        (events['x'] > 60)
    ])

    # PPDA
    ppda = opponent_passes / defensive_actions if defensive_actions > 0 else np.nan

    # Zone breakdown
    team_def = events[
        (events['team'] == team_name) &
        (events['type'].isin(['Pressure', 'Tackle', 'Interception']))
    ]

    total_def = len(team_def)
    high_third = len(team_def[team_def['x'] > 80])
    mid_third = len(team_def[(team_def['x'] >= 40) & (team_def['x'] <= 80)])
    low_third = len(team_def[team_def['x'] < 40])

    return {
        'ppda': ppda,
        'opponent_passes': opponent_passes,
        'defensive_actions': defensive_actions,
        'high_third_pct': high_third / total_def * 100 if total_def > 0 else 0,
        'mid_third_pct': mid_third / total_def * 100 if total_def > 0 else 0,
        'low_third_pct': low_third / total_def * 100 if total_def > 0 else 0
    }

def calculate_season_ppda(competition_id, season_id):
    """
    Calculate PPDA for all matches in a season.
    """
    matches = sb.matches(competition_id=competition_id, season_id=season_id)
    results = []

    for _, match in matches.iterrows():
        try:
            events = sb.events(match_id=match['match_id'])
        except:
            continue

        # Home team
        home_ppda = calculate_match_ppda(events, match['home_team'])
        home_ppda.update({
            'team': match['home_team'],
            'opponent': match['away_team'],
            'match_id': match['match_id'],
            'match_date': match['match_date'],
            'venue': 'Home',
            'match_week': match.get('match_week', 0)
        })
        results.append(home_ppda)

        # Away team
        away_ppda = calculate_match_ppda(events, match['away_team'])
        away_ppda.update({
            'team': match['away_team'],
            'opponent': match['home_team'],
            'match_id': match['match_id'],
            'match_date': match['match_date'],
            'venue': 'Away',
            'match_week': match.get('match_week', 0)
        })
        results.append(away_ppda)

    return pd.DataFrame(results)

def add_rolling_metrics(ppda_data):
    """
    Add rolling averages and trend metrics.
    """
    ppda_data = ppda_data.sort_values(['team', 'match_date']).copy()

    def add_rolling(group):
        group['ppda_rolling_5'] = group['ppda'].rolling(5, min_periods=3).mean()
        group['ppda_rolling_10'] = group['ppda'].rolling(10, min_periods=5).mean()
        group['ppda_trend'] = group['ppda_rolling_5'] - group['ppda_rolling_5'].shift(5)
        group['match_number'] = range(1, len(group) + 1)
        return group

    return ppda_data.groupby('team').apply(add_rolling).reset_index(drop=True)

def generate_ppda_rankings(ppda_data):
    """
    Generate league rankings with statistics.
    """
    rankings = (
        ppda_data
        .groupby('team')
        .agg({
            'ppda': ['count', 'mean', 'std', 'median', 'min', 'max'],
            'high_third_pct': 'mean'
        })
        .reset_index()
    )

    rankings.columns = ['team', 'matches', 'avg_ppda', 'ppda_sd', 'ppda_median',
                        'min_ppda', 'max_ppda', 'high_third_pct']

    # Home/Away split
    home_ppda = ppda_data[ppda_data['venue'] == 'Home'].groupby('team')['ppda'].mean()
    away_ppda = ppda_data[ppda_data['venue'] == 'Away'].groupby('team')['ppda'].mean()

    rankings = rankings.merge(
        home_ppda.reset_index().rename(columns={'ppda': 'home_ppda'}),
        on='team'
    ).merge(
        away_ppda.reset_index().rename(columns={'ppda': 'away_ppda'}),
        on='team'
    )

    # Confidence interval
    rankings['ci_lower'] = (
        rankings['avg_ppda'] - 1.96 * rankings['ppda_sd'] / np.sqrt(rankings['matches'])
    )
    rankings['ci_upper'] = (
        rankings['avg_ppda'] + 1.96 * rankings['ppda_sd'] / np.sqrt(rankings['matches'])
    )

    # Style classification
    def classify_style(ppda):
        if ppda < 8:
            return 'Gegenpressing'
        elif ppda < 10:
            return 'High Press'
        elif ppda < 12:
            return 'Mid Block'
        return 'Low Block'

    rankings['pressing_style'] = rankings['avg_ppda'].apply(classify_style)
    rankings['home_away_diff'] = rankings['home_ppda'] - rankings['away_ppda']
    rankings['ppda_rank'] = rankings['avg_ppda'].rank()

    return rankings.sort_values('avg_ppda')

def plot_ppda_trends(ppda_data, teams_to_show=None):
    """
    Visualize PPDA trends over the season.
    """
    fig, ax = plt.subplots(figsize=(14, 8))

    plot_data = ppda_data.copy()
    if teams_to_show:
        plot_data = plot_data[plot_data['team'].isin(teams_to_show)]

    for team in plot_data['team'].unique():
        team_data = plot_data[plot_data['team'] == team]
        ax.plot(team_data['match_number'], team_data['ppda_rolling_5'],
                label=team, linewidth=2, alpha=0.8)

    # Reference lines
    for level, label in [(8, 'Gegenpressing'), (10, 'High Press'), (12, 'Mid Block')]:
        ax.axhline(y=level, linestyle='--', alpha=0.4, color='gray')
        ax.text(1, level - 0.3, label, fontsize=9, alpha=0.7)

    ax.set_xlabel('Match Number', fontsize=12)
    ax.set_ylabel('PPDA (5-match rolling avg)', fontsize=12)
    ax.set_title('PPDA Trend Throughout Season\n(Lower = More Aggressive Pressing)',
                 fontsize=14, fontweight='bold')
    ax.legend(loc='upper right')
    ax.invert_yaxis()
    plt.tight_layout()
    plt.show()

def plot_ppda_rankings(rankings):
    """
    Create league PPDA rankings visualization.
    """
    fig, ax = plt.subplots(figsize=(12, 10))

    # Color mapping
    style_colors = {
        'Gegenpressing': '#d73027',
        'High Press': '#fc8d59',
        'Mid Block': '#91bfdb',
        'Low Block': '#4575b4'
    }

    colors = [style_colors[s] for s in rankings['pressing_style']]

    bars = ax.barh(rankings['team'], rankings['avg_ppda'], color=colors, alpha=0.8)

    # Error bars
    ax.errorbar(rankings['avg_ppda'], rankings['team'],
                xerr=[rankings['avg_ppda'] - rankings['ci_lower'],
                      rankings['ci_upper'] - rankings['avg_ppda']],
                fmt='none', color='black', capsize=3)

    # Reference lines
    for level in [8, 10, 12]:
        ax.axvline(x=level, linestyle='--', alpha=0.4, color='gray')

    ax.set_xlabel('Average PPDA', fontsize=12)
    ax.set_title('League PPDA Rankings\n(with 95% confidence intervals)',
                 fontsize=14, fontweight='bold')

    # Legend
    from matplotlib.patches import Patch
    legend_elements = [Patch(facecolor=c, label=s) for s, c in style_colors.items()]
    ax.legend(handles=legend_elements, loc='lower right')

    plt.tight_layout()
    plt.show()

def generate_ppda_report(ppda_data, rankings):
    """
    Print comprehensive PPDA report.
    """
    print("\n" + "=" * 60)
    print("PPDA ANALYSIS REPORT")
    print("=" * 60 + "\n")

    print("LEAGUE OVERVIEW:")
    print("-" * 45)
    print(f"League Average PPDA: {ppda_data['ppda'].mean():.2f}")
    print(f"Most Aggressive: {rankings.iloc[0]['team']} ({rankings.iloc[0]['avg_ppda']:.2f})")
    print(f"Least Aggressive: {rankings.iloc[-1]['team']} ({rankings.iloc[-1]['avg_ppda']:.2f})")

    print("\n\nPRESSING STYLE DISTRIBUTION:")
    print(rankings['pressing_style'].value_counts())

    print("\n\nTOP 10 MOST AGGRESSIVE TEAMS:")
    print("-" * 45)
    print(rankings.head(10)[['team', 'avg_ppda', 'ppda_sd', 'high_third_pct', 'pressing_style']].to_string(index=False))

    print("\n\nHOME vs AWAY ANALYSIS:")
    print("-" * 45)
    print("Teams pressing more aggressively at home:")
    home_aggressive = rankings[rankings['home_away_diff'] < 0].sort_values('home_away_diff')
    print(home_aggressive.head(5)[['team', 'home_ppda', 'away_ppda', 'home_away_diff']].to_string(index=False))

# Run analysis
ppda_data = calculate_season_ppda(competition_id=11, season_id=90)
ppda_data = add_rolling_metrics(ppda_data)
rankings = generate_ppda_rankings(ppda_data)

# Generate outputs
generate_ppda_report(ppda_data, rankings)
plot_ppda_trends(ppda_data, teams_to_show=rankings.head(4)['team'].tolist())
plot_ppda_rankings(rankings)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mplsoccer import Pitch
from statsbombpy import sb

# ============================================
# COUNTERPRESSING EFFECTIVENESS ANALYZER
# ============================================

def identify_possession_losses(events, team_name):
    """
    Identify all possession loss events.
    """
    team_events = events[events['team'] == team_name].copy()

    # Failed passes
    failed_passes = team_events[
        (team_events['type'] == 'Pass') &
        (team_events['pass_outcome'].notna()) &
        (team_events['pass_outcome'].isin(['Incomplete', 'Out', 'Pass Offside', 'Unknown']))
    ].copy()
    failed_passes['loss_type'] = 'Failed Pass'

    # Dispossessions
    dispossessions = team_events[
        team_events['type'].isin(['Dispossessed', 'Miscontrol'])
    ].copy()
    dispossessions['loss_type'] = 'Dispossessed'

    # Failed dribbles
    failed_dribbles = team_events[
        (team_events['type'] == 'Dribble') &
        (team_events['dribble_outcome'] != 'Complete')
    ].copy()
    failed_dribbles['loss_type'] = 'Failed Dribble'

    # Combine
    all_losses = pd.concat([failed_passes, dispossessions, failed_dribbles])

    # Extract coordinates
    all_losses['loss_x'] = all_losses['location'].apply(
        lambda loc: loc[0] if isinstance(loc, list) else np.nan
    )
    all_losses['loss_y'] = all_losses['location'].apply(
        lambda loc: loc[1] if isinstance(loc, list) else np.nan
    )

    # Classify zone
    def classify_zone(x):
        if x > 80:
            return 'Attacking Third'
        elif x >= 40:
            return 'Middle Third'
        return 'Defensive Third'

    all_losses['loss_zone'] = all_losses['loss_x'].apply(classify_zone)

    return all_losses[['match_id', 'index', 'minute', 'second', 'player',
                       'loss_x', 'loss_y', 'loss_type', 'loss_zone']]

def find_counterpresses(events, losses, team_name, window_seconds=5):
    """
    Find counterpress events within window after loss.
    """
    pressures = events[
        (events['team'] == team_name) &
        (events['type'] == 'Pressure')
    ].copy()

    pressures['press_x'] = pressures['location'].apply(
        lambda loc: loc[0] if isinstance(loc, list) else np.nan
    )
    pressures['press_y'] = pressures['location'].apply(
        lambda loc: loc[1] if isinstance(loc, list) else np.nan
    )

    counterpresses = []

    for _, loss in losses.iterrows():
        loss_time = loss['minute'] * 60 + loss['second']

        # Find pressures after this loss
        subsequent_pressures = pressures[
            (pressures['match_id'] == loss['match_id']) &
            (pressures['index'] > loss['index'])
        ].copy()

        subsequent_pressures['press_time'] = (
            subsequent_pressures['minute'] * 60 + subsequent_pressures['second']
        )
        subsequent_pressures['time_diff'] = subsequent_pressures['press_time'] - loss_time

        # Filter within window
        valid_presses = subsequent_pressures[
            (subsequent_pressures['time_diff'] > 0) &
            (subsequent_pressures['time_diff'] <= window_seconds)
        ]

        if len(valid_presses) > 0:
            first_press = valid_presses.iloc[0]

            # Calculate distance
            distance = np.sqrt(
                (first_press['press_x'] - loss['loss_x'])**2 +
                (first_press['press_y'] - loss['loss_y'])**2
            )

            counterpresses.append({
                'loss_index': loss['index'],
                'loss_x': loss['loss_x'],
                'loss_y': loss['loss_y'],
                'loss_type': loss['loss_type'],
                'loss_zone': loss['loss_zone'],
                'press_index': first_press['index'],
                'press_player': first_press['player'],
                'press_x': first_press['press_x'],
                'press_y': first_press['press_y'],
                'time_diff': first_press['time_diff'],
                'distance': distance,
                'counterpress_flag': first_press.get('counterpress', False)
            })

    return pd.DataFrame(counterpresses)

def check_regain_success(events, counterpresses, team_name):
    """
    Check if counterpress led to ball regain.
    """
    regain_events = events[
        events['type'].isin(['Ball Recovery', 'Interception', 'Tackle'])
    ].copy()

    results = []

    for _, cp in counterpresses.iterrows():
        # Find next regain event
        subsequent_regains = regain_events[
            (regain_events['index'] > cp['press_index'])
        ].head(1)

        if len(subsequent_regains) > 0:
            regain = subsequent_regains.iloc[0]
            success = regain['team'] == team_name
        else:
            success = False

        cp_dict = cp.to_dict()
        cp_dict['regain_success'] = success
        results.append(cp_dict)

    return pd.DataFrame(results)

def calculate_counterpress_metrics(losses, counterpresses):
    """
    Calculate comprehensive counterpress metrics.
    """
    overall = {
        'total_losses': len(losses),
        'counterpress_attempts': len(counterpresses),
        'counterpress_rate': len(counterpresses) / len(losses) * 100 if len(losses) > 0 else 0,
        'successful_regains': counterpresses['regain_success'].sum(),
        'regain_rate': counterpresses['regain_success'].mean() * 100 if len(counterpresses) > 0 else 0,
        'avg_time_to_press': counterpresses['time_diff'].mean(),
        'avg_distance_pressed': counterpresses['distance'].mean()
    }

    # By zone
    by_zone = (
        counterpresses
        .groupby('loss_zone')
        .agg({
            'loss_index': 'count',
            'regain_success': ['sum', 'mean'],
            'time_diff': 'mean'
        })
        .reset_index()
    )
    by_zone.columns = ['zone', 'attempts', 'regains', 'regain_rate', 'avg_reaction_time']
    by_zone['regain_rate'] *= 100

    # By player
    by_player = (
        counterpresses
        .groupby('press_player')
        .agg({
            'loss_index': 'count',
            'regain_success': ['sum', 'mean'],
            'time_diff': 'mean'
        })
        .reset_index()
    )
    by_player.columns = ['player', 'actions', 'regains', 'regain_rate', 'avg_reaction']
    by_player['regain_rate'] *= 100
    by_player = by_player.sort_values('actions', ascending=False)

    # By loss type
    by_loss_type = (
        counterpresses
        .groupby('loss_type')
        .agg({
            'loss_index': 'count',
            'regain_success': 'mean'
        })
        .reset_index()
    )
    by_loss_type.columns = ['loss_type', 'attempts', 'regain_rate']
    by_loss_type['regain_rate'] *= 100

    return {
        'overall': overall,
        'by_zone': by_zone,
        'by_player': by_player,
        'by_loss_type': by_loss_type
    }

def visualize_counterpress_zones(counterpresses):
    """
    Create heatmap of counterpress locations and success.
    """
    pitch = Pitch(pitch_type='statsbomb', line_color='white', pitch_color='#1a472a')
    fig, ax = pitch.draw(figsize=(14, 9))

    # Separate by outcome
    successful = counterpresses[counterpresses['regain_success'] == True]
    failed = counterpresses[counterpresses['regain_success'] == False]

    # Plot
    ax.scatter(successful['press_x'], successful['press_y'],
               c='lime', s=80, alpha=0.7, label=f'Regained ({len(successful)})', zorder=5)
    ax.scatter(failed['press_x'], failed['press_y'],
               c='red', s=80, alpha=0.5, label=f'Failed ({len(failed)})', zorder=4)

    # Zone lines
    ax.axvline(x=40, color='white', linestyle='--', alpha=0.5)
    ax.axvline(x=80, color='white', linestyle='--', alpha=0.5)

    # Zone success rates
    for zone, x_pos in [('Def Third', 20), ('Mid Third', 60), ('Att Third', 100)]:
        zone_data = counterpresses[
            (counterpresses['press_x'] > x_pos - 20) &
            (counterpresses['press_x'] <= x_pos + 20)
        ]
        if len(zone_data) > 0:
            rate = zone_data['regain_success'].mean() * 100
            ax.text(x_pos, 75, f'{rate:.0f}%', ha='center', fontsize=14,
                    color='white', fontweight='bold')

    ax.legend(loc='upper right', fontsize=10)
    ax.set_title('Counterpress Locations & Success Rate by Zone',
                 fontsize=14, fontweight='bold', color='white')
    plt.tight_layout()
    plt.show()

def generate_counterpress_report(metrics, team_name):
    """
    Print comprehensive counterpress report.
    """
    print("\n" + "=" * 65)
    print(f"COUNTERPRESSING ANALYSIS: {team_name}")
    print("=" * 65 + "\n")

    o = metrics['overall']
    print("OVERALL METRICS:")
    print("-" * 50)
    print(f"Total Possession Losses: {o['total_losses']}")
    print(f"Counterpress Attempts: {o['counterpress_attempts']} ({o['counterpress_rate']:.1f}% of losses)")
    print(f"Successful Regains: {o['successful_regains']} ({o['regain_rate']:.1f}% success)")
    print(f"Avg Time to Press: {o['avg_time_to_press']:.2f} seconds")
    print(f"Avg Distance Pressed: {o['avg_distance_pressed']:.1f} meters")

    print("\n\nBY ZONE:")
    print("-" * 50)
    print(metrics['by_zone'].to_string(index=False))

    print("\n\nTOP COUNTERPRESSING PLAYERS:")
    print("-" * 50)
    print(metrics['by_player'].head(10).to_string(index=False))

    print("\n\nBY LOSS TYPE:")
    print("-" * 50)
    print(metrics['by_loss_type'].to_string(index=False))

# Main execution
events = sb.events(match_id=3773585)
team_name = 'Liverpool'

losses = identify_possession_losses(events, team_name)
counterpresses = find_counterpresses(events, losses, team_name)
counterpresses = check_regain_success(events, counterpresses, team_name)
metrics = calculate_counterpress_metrics(losses, counterpresses)

generate_counterpress_report(metrics, team_name)
visualize_counterpress_zones(counterpresses)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
from math import pi
from statsbombpy import sb

# ============================================
# TEAM PRESSING PROFILE COMPARISON DASHBOARD
# ============================================

def calculate_pressing_profile(events, team_name):
    """
    Calculate comprehensive pressing profile for a team.
    """
    team_events = events[events['team'] == team_name]
    opponent_events = events[events['team'] != team_name]

    # Extract coordinates
    def get_x(loc):
        return loc[0] if isinstance(loc, list) else np.nan

    match_minutes = events['minute'].max()

    # PPDA
    opp_passes = len(opponent_events[
        (opponent_events['type'] == 'Pass')
    ])
    opp_passes_their_half = len(opponent_events[
        (opponent_events['type'] == 'Pass') &
        (opponent_events['location'].apply(get_x) < 60)
    ])

    def_actions = team_events[
        team_events['type'].isin(['Pressure', 'Tackle', 'Interception', 'Foul Committed'])
    ].copy()
    def_actions['x'] = def_actions['location'].apply(get_x)
    def_actions_opp_half = len(def_actions[def_actions['x'] > 60])

    ppda = opp_passes_their_half / def_actions_opp_half if def_actions_opp_half > 0 else np.nan

    # Pressures
    pressures = team_events[team_events['type'] == 'Pressure'].copy()
    pressures['x'] = pressures['location'].apply(get_x)
    pressures['y'] = pressures['location'].apply(
        lambda loc: loc[1] if isinstance(loc, list) else np.nan
    )

    n_pressures = len(pressures)

    if n_pressures > 0:
        high_press_pct = (pressures['x'] > 80).mean() * 100
        mid_press_pct = ((pressures['x'] >= 40) & (pressures['x'] <= 80)).mean() * 100
        low_press_pct = (pressures['x'] < 40).mean() * 100
        avg_press_height = pressures['x'].mean()
        press_width_spread = pressures['y'].std()
        wide_press_pct = ((pressures['y'] < 20) | (pressures['y'] > 60)).mean() * 100
        central_press_pct = ((pressures['y'] >= 20) & (pressures['y'] <= 60)).mean() * 100
        counterpress_rate = pressures.get('counterpress', pd.Series([False]*len(pressures))).mean() * 100
    else:
        high_press_pct = mid_press_pct = low_press_pct = 0
        avg_press_height = press_width_spread = wide_press_pct = central_press_pct = 0
        counterpress_rate = 0

    pressures_per_90 = n_pressures / (match_minutes / 90) if match_minutes > 0 else 0

    # Efficiency
    turnovers = len(team_events[team_events['type'].isin(['Ball Recovery', 'Interception'])])
    pressing_efficiency = turnovers / n_pressures * 100 if n_pressures > 0 else 0

    # Engagement rate
    opp_touches = len(opponent_events[
        opponent_events['type'].isin(['Pass', 'Carry', 'Dribble', 'Shot'])
    ])
    defensive_engagement = len(def_actions) / opp_touches * 100 if opp_touches > 0 else 0

    return {
        'team': team_name,
        'ppda': ppda,
        'pressures_per_90': pressures_per_90,
        'high_press_pct': high_press_pct,
        'mid_press_pct': mid_press_pct,
        'low_press_pct': low_press_pct,
        'avg_press_height': avg_press_height,
        'counterpress_rate': counterpress_rate,
        'pressing_efficiency': pressing_efficiency,
        'defensive_engagement': defensive_engagement,
        'wide_press_pct': wide_press_pct,
        'central_press_pct': central_press_pct,
        'press_width_spread': press_width_spread
    }

def classify_pressing_style(profile):
    """
    Classify team pressing style and intensity.
    """
    # Style
    if profile['ppda'] < 8 and profile['high_press_pct'] > 35 and profile['counterpress_rate'] > 15:
        profile['pressing_style'] = 'Gegenpressing'
    elif profile['ppda'] < 10 and profile['high_press_pct'] > 25:
        profile['pressing_style'] = 'High Press'
    elif profile['ppda'] < 12:
        profile['pressing_style'] = 'Mid Block'
    else:
        profile['pressing_style'] = 'Low Block'

    # Intensity
    if profile['pressures_per_90'] > 180:
        profile['intensity_level'] = 'Very High'
    elif profile['pressures_per_90'] > 150:
        profile['intensity_level'] = 'High'
    elif profile['pressures_per_90'] > 120:
        profile['intensity_level'] = 'Medium'
    else:
        profile['intensity_level'] = 'Low'

    return profile

def normalize_profiles(profiles_df):
    """
    Normalize metrics for radar chart (0-100 scale).
    """
    df = profiles_df.copy()

    # PPDA: invert (lower is better)
    df['ppda_norm'] = 100 - (df['ppda'] - df['ppda'].min()) / (df['ppda'].max() - df['ppda'].min()) * 100

    for col, new_col in [
        ('pressures_per_90', 'intensity_norm'),
        ('high_press_pct', 'high_press_norm'),
        ('counterpress_rate', 'counterpress_norm'),
        ('pressing_efficiency', 'efficiency_norm'),
        ('defensive_engagement', 'engagement_norm')
    ]:
        df[new_col] = (df[col] - df[col].min()) / (df[col].max() - df[col].min()) * 100

    return df

def create_radar_comparison(profiles_df, teams_to_compare):
    """
    Create radar chart comparing team pressing profiles.
    """
    metrics = ['ppda_norm', 'intensity_norm', 'high_press_norm',
               'counterpress_norm', 'efficiency_norm', 'engagement_norm']
    labels = ['PPDA\n(inverted)', 'Intensity', 'High Press %',
              'Counterpress', 'Efficiency', 'Engagement']

    # Number of variables
    num_vars = len(metrics)
    angles = [n / float(num_vars) * 2 * pi for n in range(num_vars)]
    angles += angles[:1]  # Complete the loop

    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(projection='polar'))

    colors = ['#E41A1C', '#377EB8', '#4DAF4A', '#984EA3']

    for idx, team in enumerate(teams_to_compare):
        team_data = profiles_df[profiles_df['team'] == team]
        if len(team_data) == 0:
            continue

        values = team_data[metrics].values.flatten().tolist()
        values += values[:1]

        ax.plot(angles, values, 'o-', linewidth=2, label=team, color=colors[idx])
        ax.fill(angles, values, alpha=0.25, color=colors[idx])

    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(labels, size=10)
    ax.set_ylim(0, 100)
    ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1.0))
    ax.set_title('Pressing Profile Comparison', size=14, fontweight='bold', y=1.08)

    plt.tight_layout()
    plt.show()

def analyze_strengths_weaknesses(profile, all_profiles_df):
    """
    Identify team strengths and weaknesses vs league average.
    """
    league_avg = all_profiles_df[['ppda', 'pressures_per_90', 'high_press_pct',
                                   'counterpress_rate', 'pressing_efficiency']].mean()

    comparisons = {
        'ppda_vs_league': (league_avg['ppda'] - profile['ppda']) / league_avg['ppda'] * 100,
        'intensity_vs_league': (profile['pressures_per_90'] - league_avg['pressures_per_90']) / league_avg['pressures_per_90'] * 100,
        'high_press_vs_league': (profile['high_press_pct'] - league_avg['high_press_pct']) / league_avg['high_press_pct'] * 100,
        'counterpress_vs_league': (profile['counterpress_rate'] - league_avg['counterpress_rate']) / league_avg['counterpress_rate'] * 100,
        'efficiency_vs_league': (profile['pressing_efficiency'] - league_avg['pressing_efficiency']) / league_avg['pressing_efficiency'] * 100
    }

    strengths = []
    weaknesses = []

    if comparisons['ppda_vs_league'] > 15:
        strengths.append('Aggressive pressing (low PPDA)')
    elif comparisons['ppda_vs_league'] < -15:
        weaknesses.append('Passive pressing (high PPDA)')

    if comparisons['intensity_vs_league'] > 15:
        strengths.append('High pressing volume')
    elif comparisons['intensity_vs_league'] < -15:
        weaknesses.append('Low pressing volume')

    if comparisons['high_press_vs_league'] > 15:
        strengths.append('Strong high press')
    elif comparisons['high_press_vs_league'] < -15:
        weaknesses.append('Weak high press')

    if comparisons['counterpress_vs_league'] > 15:
        strengths.append('Effective counterpressing')
    elif comparisons['counterpress_vs_league'] < -15:
        weaknesses.append('Poor counterpressing')

    if comparisons['efficiency_vs_league'] > 15:
        strengths.append('Efficient pressing (high regain)')
    elif comparisons['efficiency_vs_league'] < -15:
        weaknesses.append('Inefficient pressing')

    return {'strengths': strengths, 'weaknesses': weaknesses, 'comparisons': comparisons}

def generate_tactical_insights(profile, analysis):
    """
    Generate tactical recommendations based on profile.
    """
    insights = []

    if profile['pressing_style'] == 'Gegenpressing':
        insights.append('Maintain high defensive line to support aggressive pressing')
        insights.append('Focus on quick transitions after winning ball')
    elif profile['pressing_style'] == 'Low Block':
        insights.append('Consider situational higher pressing against weaker opponents')
        insights.append('Prioritize counter-attacking efficiency')

    if 'Poor counterpressing' in analysis['weaknesses']:
        insights.append('Train immediate reactions after possession loss')
    if 'Weak high press' in analysis['weaknesses']:
        insights.append('Consider pressing triggers to optimize timing')

    return insights

def generate_pressing_dashboard(all_profiles_df, focus_team):
    """
    Generate comprehensive pressing profile dashboard.
    """
    print("\n" + "=" * 70)
    print(f"PRESSING PROFILE DASHBOARD: {focus_team}")
    print("=" * 70 + "\n")

    profile = all_profiles_df[all_profiles_df['team'] == focus_team].iloc[0].to_dict()

    print("PROFILE SUMMARY:")
    print("-" * 55)
    print(f"Pressing Style: {profile['pressing_style']}")
    print(f"Intensity Level: {profile['intensity_level']}")
    print(f"PPDA: {profile['ppda']:.2f}")
    print(f"Pressures per 90: {profile['pressures_per_90']:.1f}")
    print(f"High Press %: {profile['high_press_pct']:.1f}%")
    print(f"Counterpress Rate: {profile['counterpress_rate']:.1f}%")
    print(f"Pressing Efficiency: {profile['pressing_efficiency']:.1f}%")

    analysis = analyze_strengths_weaknesses(profile, all_profiles_df)

    print("\n\nSTRENGTHS:")
    print("-" * 55)
    for s in analysis['strengths']:
        print(f"  + {s}")
    if not analysis['strengths']:
        print("  No significant strengths vs league average")

    print("\n\nWEAKNESSES:")
    print("-" * 55)
    for w in analysis['weaknesses']:
        print(f"  - {w}")
    if not analysis['weaknesses']:
        print("  No significant weaknesses vs league average")

    insights = generate_tactical_insights(profile, analysis)

    print("\n\nTACTICAL RECOMMENDATIONS:")
    print("-" * 55)
    for i, insight in enumerate(insights, 1):
        print(f"  {i}. {insight}")

    rankings = all_profiles_df.sort_values('ppda').reset_index(drop=True)
    rank = rankings[rankings['team'] == focus_team].index[0] + 1

    print(f"\n\nLEAGUE RANKING:")
    print("-" * 55)
    print(f"PPDA Rank: {rank} of {len(all_profiles_df)}")

# Example usage
# events = sb.events(match_id=3773585)
# teams = events['team'].unique()
# profiles = [classify_pressing_style(calculate_pressing_profile(events, t)) for t in teams]
# profiles_df = normalize_profiles(pd.DataFrame(profiles))
# generate_pressing_dashboard(profiles_df, 'Liverpool')
# create_radar_comparison(profiles_df, list(teams))