Capstone - Complete Analytics System

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from statsbombpy import sb

# ============================================
# POSSESSION QUALITY ANALYSIS SYSTEM
# ============================================

def identify_possession_sequences(events):
    """Identify distinct possession sequences."""
    events = events.sort_values('index').copy()
    events['new_possession'] = events['team'] != events['team'].shift(1)
    events['possession_id'] = events['new_possession'].cumsum()

    seq_info = (
        events.groupby('possession_id')
        .agg({'team': 'first', 'index': 'count'})
        .reset_index()
        .rename(columns={'team': 'possession_team', 'index': 'sequence_length'})
    )

    events = events.merge(seq_info, on='possession_id')
    return events

def calculate_team_possession_quality(events, team_name):
    """Calculate possession quality metrics for a team."""
    def get_x(loc):
        return loc[0] if isinstance(loc, list) else np.nan

    def get_y(loc):
        return loc[1] if isinstance(loc, list) else np.nan

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

    if 'pass_end_location' in events.columns:
        events['end_x'] = events['pass_end_location'].apply(get_x)

    team_poss = events[events['possession_team'] == team_name]

    possession_metrics = []
    for poss_id in team_poss['possession_id'].unique():
        poss = team_poss[team_poss['possession_id'] == poss_id]

        metrics = {
            'possession_id': poss_id,
            'sequence_length': len(poss),
            'max_x': poss['x'].max(),
            'entered_final_third': (poss['x'] > 80).any(),
            'entered_box': ((poss['x'] > 102) & (poss['y'] > 18) & (poss['y'] < 62)).any(),
            'total_passes': (poss['type'] == 'Pass').sum(),
            'successful_passes': ((poss['type'] == 'Pass') & (poss['pass_outcome'].isna())).sum(),
            'ended_in_shot': (poss['type'] == 'Shot').any(),
            'xg_generated': poss['shot_statsbomb_xg'].sum() if 'shot_statsbomb_xg' in poss.columns else 0,
            'ended_in_goal': ((poss['type'] == 'Shot') & (poss['shot_outcome'] == 'Goal')).any()
        }

        # Progressive passes
        if 'end_x' in poss.columns:
            poss_passes = poss[poss['type'] == 'Pass']
            metrics['progressive_passes'] = (
                ((120 - poss_passes['x']) - (120 - poss_passes['end_x']) > 10).sum()
            )
        else:
            metrics['progressive_passes'] = 0

        possession_metrics.append(metrics)

    poss_df = pd.DataFrame(possession_metrics)

    # Possession percentage
    all_poss = events.groupby('possession_team')['possession_id'].nunique()
    team_poss_pct = all_poss.get(team_name, 0) / all_poss.sum() * 100

    # Quality summary
    quality = {
        'team': team_name,
        'total_possessions': len(poss_df),
        'possession_pct': team_poss_pct,
        'avg_sequence_length': poss_df['sequence_length'].mean(),
        'final_third_entry_rate': poss_df['entered_final_third'].mean() * 100,
        'box_entry_rate': poss_df['entered_box'].mean() * 100,
        'pass_completion': poss_df['successful_passes'].sum() / max(poss_df['total_passes'].sum(), 1) * 100,
        'progressive_pass_rate': poss_df['progressive_passes'].sum() / max(poss_df['total_passes'].sum(), 1) * 100,
        'shot_rate': poss_df['ended_in_shot'].mean() * 100,
        'xg_per_possession': poss_df['xg_generated'].mean(),
        'goal_rate': poss_df['ended_in_goal'].mean() * 100
    }

    # Quality score
    quality['quality_score'] = (
        (quality['final_third_entry_rate'] / 50) * 25 +
        (quality['box_entry_rate'] / 20) * 25 +
        (quality['progressive_pass_rate'] / 15) * 25 +
        (quality['xg_per_possession'] / 0.05) * 25
    )

    # Efficiency score
    quality['efficiency_score'] = quality['quality_score'] / (quality['possession_pct'] / 50)

    return quality

def calculate_league_possession(events):
    """Calculate possession metrics for all teams."""
    events_seq = identify_possession_sequences(events)
    teams = events_seq['team'].unique()

    league_data = [calculate_team_possession_quality(events_seq, team) for team in teams if team]
    return pd.DataFrame(league_data)

def classify_possession_style(league_df):
    """Classify teams by possession style."""
    def get_category(row):
        if row['possession_pct'] >= 55 and row['quality_score'] >= 50:
            return 'Dominant'
        elif row['possession_pct'] >= 55 and row['quality_score'] < 50:
            return 'Sterile Possession'
        elif row['possession_pct'] < 45 and row['quality_score'] >= 50:
            return 'Efficient Counter'
        elif row['possession_pct'] < 45 and row['quality_score'] < 50:
            return 'Low Quality'
        return 'Balanced'

    league_df['possession_category'] = league_df.apply(get_category, axis=1)
    return league_df

def cluster_possession_styles(league_df):
    """Cluster teams by possession style using K-means."""
    features = ['possession_pct', 'final_third_entry_rate', 'box_entry_rate',
                'progressive_pass_rate', 'xg_per_possession', 'shot_rate']

    X = league_df[features].fillna(0)
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)

    kmeans = KMeans(n_clusters=4, random_state=42, n_init=25)
    league_df['cluster'] = kmeans.fit_predict(X_scaled)

    return league_df

def visualize_possession_quality(league_df):
    """Create possession quality visualizations."""
    fig, axes = plt.subplots(1, 2, figsize=(16, 7))

    # Scatter plot
    colors = {'Dominant': 'green', 'Sterile Possession': 'red',
              'Efficient Counter': 'blue', 'Low Quality': 'gray', 'Balanced': 'orange'}

    for cat in league_df['possession_category'].unique():
        subset = league_df[league_df['possession_category'] == cat]
        axes[0].scatter(subset['possession_pct'], subset['quality_score'],
                        c=colors.get(cat, 'gray'), label=cat, s=100, alpha=0.7)

    axes[0].axvline(x=50, linestyle='--', alpha=0.5, color='gray')
    axes[0].axhline(y=50, linestyle='--', alpha=0.5, color='gray')
    axes[0].set_xlabel('Possession %')
    axes[0].set_ylabel('Quality Score')
    axes[0].set_title('Possession Quantity vs Quality')
    axes[0].legend()

    # Efficiency bar chart
    sorted_df = league_df.sort_values('efficiency_score', ascending=True)
    bars = axes[1].barh(sorted_df['team'], sorted_df['efficiency_score'],
                        color=[colors.get(c, 'gray') for c in sorted_df['possession_category']])
    axes[1].set_xlabel('Efficiency Score')
    axes[1].set_title('Possession Efficiency (Quality / Quantity)')

    plt.tight_layout()
    plt.show()

def generate_possession_report(league_df):
    """Generate comprehensive possession report."""
    print("\n" + "=" * 65)
    print("LEAGUE POSSESSION QUALITY REPORT")
    print("=" * 65 + "\n")

    print("POSSESSION STYLE DISTRIBUTION:")
    print(league_df['possession_category'].value_counts())

    print("\n\nTOP 5 QUALITY TEAMS:")
    print("-" * 55)
    top_quality = league_df.nlargest(5, 'quality_score')[
        ['team', 'possession_pct', 'quality_score', 'xg_per_possession', 'possession_category']
    ]
    print(top_quality.to_string(index=False))

    print("\n\nTOP 5 MOST EFFICIENT TEAMS:")
    print("-" * 55)
    top_eff = league_df.nlargest(5, 'efficiency_score')[
        ['team', 'possession_pct', 'quality_score', 'efficiency_score', 'possession_category']
    ]
    print(top_eff.to_string(index=False))

    print("\n\nSTERILE POSSESSION TEAMS:")
    print("-" * 55)
    sterile = league_df[league_df['possession_category'] == 'Sterile Possession'][
        ['team', 'possession_pct', 'quality_score', 'box_entry_rate', 'xg_per_possession']
    ]
    print(sterile.to_string(index=False) if len(sterile) > 0 else "  None found")

    print("\n\nEFFICIENT COUNTER TEAMS:")
    print("-" * 55)
    efficient = league_df[league_df['possession_category'] == 'Efficient Counter'][
        ['team', 'possession_pct', 'quality_score', 'box_entry_rate', 'xg_per_possession']
    ]
    print(efficient.to_string(index=False) if len(efficient) > 0 else "  None found")

# Main execution
matches = sb.matches(competition_id=11, season_id=90)
events = pd.concat([sb.events(match_id=m) for m in matches['match_id'].head(10)])

league_possession = calculate_league_possession(events)
league_possession = classify_possession_style(league_possession)
league_possession = cluster_possession_styles(league_possession)

generate_possession_report(league_possession)
visualize_possession_quality(league_possession)

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

# ============================================
# FIELD TILT & TERRITORIAL CONTROL DASHBOARD
# ============================================

def calculate_field_tilt_metrics(events):
    """Calculate comprehensive field tilt metrics."""
    events = events.dropna(subset=['location']).copy()
    events['x'] = events['location'].apply(lambda loc: loc[0] if isinstance(loc, list) else np.nan)
    events['y'] = events['location'].apply(lambda loc: loc[1] if isinstance(loc, list) else np.nan)

    def get_zone(x):
        if x > 80:
            return 'final_third'
        elif x > 40:
            return 'middle_third'
        return 'defensive_third'

    events['zone'] = events['x'].apply(get_zone)
    teams = events['team'].unique()

    metrics = []
    for team in teams:
        if pd.isna(team):
            continue

        team_events = events[events['team'] == team]
        total = len(team_events)

        team_final = len(team_events[team_events['zone'] == 'final_third'])
        opp_defensive = len(events[(events['team'] != team) & (events['zone'] == 'defensive_third')])

        field_tilt = team_final / (team_final + opp_defensive) * 100 if (team_final + opp_defensive) > 0 else 50

        metrics.append({
            'team': team,
            'field_tilt': field_tilt,
            'final_third_pct': (team_events['zone'] == 'final_third').mean() * 100,
            'middle_third_pct': (team_events['zone'] == 'middle_third').mean() * 100,
            'defensive_third_pct': (team_events['zone'] == 'defensive_third').mean() * 100,
            'total_touches': total
        })

    return pd.DataFrame(metrics)

def calculate_territorial_timeline(events, interval_minutes=5):
    """Track territorial control over time."""
    events = events.dropna(subset=['location']).copy()
    events['x'] = events['location'].apply(lambda loc: loc[0] if isinstance(loc, list) else np.nan)
    events['time_bucket'] = (events['minute'] // interval_minutes) * interval_minutes
    events['in_opp_half'] = events['x'] > 60
    events['in_final_third'] = events['x'] > 80

    timeline = (
        events.groupby(['time_bucket', 'team'])
        .agg({
            'id': 'count',
            'in_opp_half': 'sum',
            'in_final_third': 'sum',
            'x': 'mean'
        })
        .reset_index()
        .rename(columns={'id': 'touches', 'in_opp_half': 'touches_opp_half',
                         'in_final_third': 'touches_final_third', 'x': 'avg_x'})
    )

    # Calculate territorial share
    total_opp_half = timeline.groupby('time_bucket')['touches_opp_half'].transform('sum')
    timeline['territorial_share'] = timeline['touches_opp_half'] / total_opp_half * 100

    return timeline

def identify_momentum_shifts(timeline, threshold=15):
    """Identify significant momentum shifts."""
    teams = timeline['team'].unique()
    team_a = teams[0]

    team_timeline = timeline[timeline['team'] == team_a].copy()
    team_timeline = team_timeline.sort_values('time_bucket')
    team_timeline['tilt_change'] = team_timeline['territorial_share'].diff()

    def classify_shift(change):
        if pd.isna(change):
            return 'Stable'
        elif change > threshold:
            return 'Gained Control'
        elif change < -threshold:
            return 'Lost Control'
        return 'Stable'

    team_timeline['momentum_shift'] = team_timeline['tilt_change'].apply(classify_shift)

    shifts = team_timeline[team_timeline['momentum_shift'] != 'Stable'][
        ['time_bucket', 'territorial_share', 'tilt_change', 'momentum_shift']
    ]

    return shifts

def calculate_tilt_xg_correlation(events, timeline):
    """Calculate correlation between field tilt and xG."""
    xg_by_period = (
        events[events['type'] == 'Shot']
        .dropna(subset=['shot_statsbomb_xg'])
        .assign(time_bucket=lambda x: (x['minute'] // 5) * 5)
        .groupby(['time_bucket', 'team'])
        ['shot_statsbomb_xg'].sum()
        .reset_index()
        .rename(columns={'shot_statsbomb_xg': 'xg'})
    )

    merged = timeline.merge(xg_by_period, on=['time_bucket', 'team'], how='left')
    merged['xg'] = merged['xg'].fillna(0)

    correlation = merged['territorial_share'].corr(merged['xg'])

    return {'correlation': correlation, 'data': merged}

def visualize_territorial_control(timeline):
    """Create territorial control visualizations."""
    fig, axes = plt.subplots(2, 1, figsize=(14, 10))
    teams = timeline['team'].unique()
    colors = {'team_a': '#C8102E', 'team_b': '#6CABDD'}

    # Area chart
    pivot = timeline.pivot(index='time_bucket', columns='team', values='territorial_share').fillna(50)
    pivot.plot(kind='area', stacked=True, ax=axes[0], alpha=0.8,
               color=['#C8102E', '#6CABDD'])
    axes[0].set_xlabel('Match Minute')
    axes[0].set_ylabel('Territorial Share (%)')
    axes[0].set_title('Territorial Control Over Time')
    axes[0].legend(title='Team')

    # Average position timeline
    for i, team in enumerate(teams):
        if pd.isna(team):
            continue
        team_data = timeline[timeline['team'] == team]
        axes[1].plot(team_data['time_bucket'], team_data['avg_x'],
                     label=team, linewidth=2, color=['#C8102E', '#6CABDD'][i])

    axes[1].axhline(y=60, linestyle='--', alpha=0.5, color='gray')
    axes[1].set_xlabel('Match Minute')
    axes[1].set_ylabel('Average X Position')
    axes[1].set_title('Average Touch Position Over Time')
    axes[1].legend()

    plt.tight_layout()
    plt.show()

def create_touch_heatmaps(events):
    """Create side-by-side touch heatmaps."""
    teams = [t for t in events['team'].unique() if pd.notna(t)]

    fig, axes = plt.subplots(1, 2, figsize=(16, 7))

    for i, team in enumerate(teams[:2]):
        pitch = Pitch(pitch_type='statsbomb', line_color='white', pitch_color='#1a472a')
        pitch.draw(ax=axes[i])

        team_events = events[events['team'] == team].copy()
        team_events['x'] = team_events['location'].apply(lambda loc: loc[0] if isinstance(loc, list) else np.nan)
        team_events['y'] = team_events['location'].apply(lambda loc: loc[1] if isinstance(loc, list) else np.nan)

        valid_events = team_events.dropna(subset=['x', 'y'])

        pitch.kdeplot(valid_events['x'], valid_events['y'], ax=axes[i],
                      cmap='plasma', fill=True, levels=50, alpha=0.7)

        axes[i].set_title(f'{team} Touch Heatmap', fontsize=14, fontweight='bold')

    plt.tight_layout()
    plt.show()

def generate_territorial_report(metrics, momentum_shifts, correlation):
    """Generate comprehensive territorial report."""
    print("\n" + "=" * 65)
    print("TERRITORIAL CONTROL DASHBOARD")
    print("=" * 65 + "\n")

    print("FIELD TILT SUMMARY:")
    print("-" * 55)
    print(metrics.to_string(index=False))

    print("\n\nMOMENTUM SHIFTS:")
    print("-" * 55)
    if len(momentum_shifts) > 0:
        print(momentum_shifts.to_string(index=False))
    else:
        print("  No significant momentum shifts detected")

    print("\n\nFIELD TILT vs xG CORRELATION:")
    print("-" * 55)
    print(f"Correlation coefficient: {correlation['correlation']:.3f}")

    if abs(correlation['correlation']) > 0.7:
        interpretation = "Strong"
    elif abs(correlation['correlation']) > 0.4:
        interpretation = "Moderate"
    else:
        interpretation = "Weak"

    print(f"Interpretation: {interpretation} relationship between territorial control and xG")

# Main execution
events = sb.events(match_id=3773585)

metrics = calculate_field_tilt_metrics(events)
timeline = calculate_territorial_timeline(events, interval_minutes=5)
momentum_shifts = identify_momentum_shifts(timeline)
correlation = calculate_tilt_xg_correlation(events, timeline)

generate_territorial_report(metrics, momentum_shifts, correlation)
visualize_territorial_control(timeline)
create_touch_heatmaps(events)

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

# ============================================
# POSSESSION VALUE MODEL & PLAYER RANKING
# ============================================

def build_pv_model(events, grid_size=10):
    """Build possession value model from event data."""
    events = events.copy()

    # Add possession sequences
    events = events.sort_values(['match_id', 'index'])
    events['new_poss'] = events.groupby('match_id')['team'].apply(
        lambda x: x != x.shift(1)
    ).values
    events['possession_id'] = events.groupby('match_id')['new_poss'].cumsum().values

    # Extract coordinates
    def get_coord(loc, idx):
        return loc[idx] if isinstance(loc, list) and len(loc) > idx else np.nan

    events['x'] = events['location'].apply(lambda loc: get_coord(loc, 0))
    events['y'] = events['location'].apply(lambda loc: get_coord(loc, 1))

    events = events.dropna(subset=['x', 'y'])

    # Grid locations
    events['grid_x'] = (events['x'] // grid_size) * grid_size
    events['grid_y'] = (events['y'] // grid_size) * grid_size

    # Calculate metrics per grid cell
    grid_metrics = (
        events.groupby(['match_id', 'possession_id', 'grid_x', 'grid_y'])
        .agg({
            'type': lambda x: (x == 'Shot').any(),
            'shot_statsbomb_xg': 'max',
            'shot_outcome': lambda x: (x == 'Goal').any()
        })
        .reset_index()
        .rename(columns={'type': 'ended_in_shot', 'shot_outcome': 'ended_in_goal'})
    )

    # Aggregate by grid cell
    pv_model = (
        grid_metrics.groupby(['grid_x', 'grid_y'])
        .agg({
            'ended_in_shot': ['count', 'mean'],
            'shot_statsbomb_xg': 'mean',
            'ended_in_goal': 'mean'
        })
        .reset_index()
    )
    pv_model.columns = ['grid_x', 'grid_y', 'n_possessions', 'shot_probability',
                        'avg_xg_when_shot', 'goal_probability']

    # Filter for minimum sample
    pv_model = pv_model[pv_model['n_possessions'] >= 20]

    # Calculate possession value
    pv_model['possession_value'] = (
        pv_model['shot_probability'] *
        pv_model['avg_xg_when_shot'].fillna(0.08)
    )

    return pv_model

def calculate_pv_added(events, pv_model, grid_size=10):
    """Calculate possession value added for each action."""
    events = events.copy()

    def get_coord(loc, idx):
        return loc[idx] if isinstance(loc, list) and len(loc) > idx else np.nan

    events['x'] = events['location'].apply(lambda loc: get_coord(loc, 0))
    events['y'] = events['location'].apply(lambda loc: get_coord(loc, 1))
    events['grid_x'] = (events['x'] // grid_size) * grid_size
    events['grid_y'] = (events['y'] // grid_size) * grid_size

    # End locations
    events['end_x'] = events['pass_end_location'].apply(lambda loc: get_coord(loc, 0))
    events['end_y'] = events['pass_end_location'].apply(lambda loc: get_coord(loc, 1))

    # Fill carry end locations
    if 'carry_end_location' in events.columns:
        events['end_x'] = events['end_x'].fillna(
            events['carry_end_location'].apply(lambda loc: get_coord(loc, 0))
        )
        events['end_y'] = events['end_y'].fillna(
            events['carry_end_location'].apply(lambda loc: get_coord(loc, 1))
        )

    events['end_x'] = events['end_x'].fillna(events['x'])
    events['end_y'] = events['end_y'].fillna(events['y'])

    events['end_grid_x'] = (events['end_x'] // grid_size) * grid_size
    events['end_grid_y'] = (events['end_y'] // grid_size) * grid_size

    # Merge with PV model
    events = events.merge(
        pv_model[['grid_x', 'grid_y', 'possession_value']].rename(
            columns={'possession_value': 'start_pv'}
        ),
        on=['grid_x', 'grid_y'],
        how='left'
    )

    events = events.merge(
        pv_model[['grid_x', 'grid_y', 'possession_value']].rename(
            columns={'grid_x': 'end_grid_x', 'grid_y': 'end_grid_y',
                     'possession_value': 'end_pv'}
        ),
        on=['end_grid_x', 'end_grid_y'],
        how='left'
    )

    events['pv_added'] = events['end_pv'] - events['start_pv']

    # Nullify for failed actions
    failed_pass = (events['type'] == 'Pass') & events['pass_outcome'].notna()
    failed_dribble = (events['type'] == 'Dribble') & (events['dribble_outcome'] != 'Complete')
    events.loc[failed_pass | failed_dribble, 'pv_added'] = np.nan

    return events

def calculate_player_pv_rankings(events_with_pv):
    """Calculate player rankings by possession value added."""
    actions = events_with_pv[
        events_with_pv['type'].isin(['Pass', 'Carry', 'Dribble']) &
        events_with_pv['pv_added'].notna()
    ]

    # Approximate minutes
    player_minutes = (
        events_with_pv.groupby(['player', 'team', 'position'])
        .agg({'minute': ['min', 'max']})
        .reset_index()
    )
    player_minutes.columns = ['player', 'team', 'position', 'first_event', 'last_event']
    player_minutes['minutes_approx'] = player_minutes['last_event'] - player_minutes['first_event']
    player_minutes = player_minutes[player_minutes['minutes_approx'] > 10]

    # Aggregate by player
    player_pv = (
        actions.groupby(['player', 'team', 'position'])
        .agg({
            'id': 'count',
            'pv_added': ['sum', 'mean', lambda x: (x > 0).sum(), lambda x: (x < 0).sum()]
        })
        .reset_index()
    )
    player_pv.columns = ['player', 'team', 'position', 'total_actions',
                         'total_pv_added', 'avg_pv_per_action',
                         'positive_actions', 'negative_actions']

    player_pv = player_pv.merge(
        player_minutes[['player', 'team', 'position', 'minutes_approx']],
        on=['player', 'team', 'position'],
        how='left'
    )

    player_pv['pv_per_90'] = player_pv['total_pv_added'] / (player_pv['minutes_approx'] / 90)
    player_pv['positive_ratio'] = player_pv['positive_actions'] / player_pv['total_actions'] * 100

    return player_pv.sort_values('total_pv_added', ascending=False)

def analyze_pv_by_category(events_with_pv, player_pv):
    """Analyze PV by position and action type."""
    # By position
    position_pv = (
        player_pv[player_pv['position'].notna()]
        .groupby('position')
        .agg({
            'player': 'count',
            'total_pv_added': 'mean',
            'pv_per_90': 'mean',
            'positive_ratio': 'mean'
        })
        .reset_index()
        .rename(columns={'player': 'n_players', 'total_pv_added': 'avg_total_pv',
                         'pv_per_90': 'avg_pv_per_90', 'positive_ratio': 'avg_positive_ratio'})
        .sort_values('avg_pv_per_90', ascending=False)
    )

    # By action type
    actions = events_with_pv[
        events_with_pv['type'].isin(['Pass', 'Carry', 'Dribble']) &
        events_with_pv['pv_added'].notna()
    ]

    action_pv = (
        actions.groupby('type')
        .agg({
            'id': 'count',
            'pv_added': ['sum', 'mean', lambda x: (x > 0).mean() * 100]
        })
        .reset_index()
    )
    action_pv.columns = ['action_type', 'n_actions', 'total_pv', 'avg_pv', 'positive_pct']

    return {'by_position': position_pv, 'by_action': action_pv}

def visualize_pv_grid(pv_model):
    """Visualize possession value grid on pitch."""
    pitch = Pitch(pitch_type='statsbomb', line_color='white', pitch_color='#1a1a1a')
    fig, ax = pitch.draw(figsize=(14, 9))

    scatter = ax.scatter(
        pv_model['grid_x'] + 5,
        pv_model['grid_y'] + 5,
        c=pv_model['possession_value'],
        s=300,
        cmap='plasma',
        alpha=0.8
    )

    plt.colorbar(scatter, ax=ax, label='Possession Value')
    ax.set_title('Possession Value Model\n(Based on shot probability × expected xG)',
                 fontsize=14, fontweight='bold', color='white')
    plt.tight_layout()
    plt.show()

def generate_pv_report(pv_model, player_pv, category_analysis):
    """Generate comprehensive PV report."""
    print("\n" + "=" * 70)
    print("POSSESSION VALUE ANALYSIS REPORT")
    print("=" * 70 + "\n")

    print("PV MODEL SUMMARY:")
    print("-" * 55)
    print(f"Grid cells with data: {len(pv_model)}")
    print(f"Max possession value: {pv_model['possession_value'].max():.4f}")
    print(f"Avg possession value: {pv_model['possession_value'].mean():.4f}")

    print("\n\nTOP 10 PLAYERS BY TOTAL PV ADDED:")
    print("-" * 55)
    print(player_pv.head(10)[['player', 'position', 'total_pv_added', 'pv_per_90', 'positive_ratio']].to_string(index=False))

    print("\n\nTOP 10 PLAYERS BY PV PER 90:")
    print("-" * 55)
    qualified = player_pv[player_pv['minutes_approx'] >= 45].nlargest(10, 'pv_per_90')
    print(qualified[['player', 'position', 'pv_per_90', 'total_actions', 'positive_ratio']].to_string(index=False))

    print("\n\nPV BY POSITION:")
    print("-" * 55)
    print(category_analysis['by_position'].to_string(index=False))

    print("\n\nPV BY ACTION TYPE:")
    print("-" * 55)
    print(category_analysis['by_action'].to_string(index=False))

# Main execution
matches = sb.matches(competition_id=11, season_id=90)
events = pd.concat([sb.events(match_id=m) for m in matches['match_id'].head(20)])

pv_model = build_pv_model(events, grid_size=10)
events_with_pv = calculate_pv_added(events, pv_model)
player_pv = calculate_player_pv_rankings(events_with_pv)
category_analysis = analyze_pv_by_category(events_with_pv, player_pv)

generate_pv_report(pv_model, player_pv, category_analysis)
visualize_pv_grid(pv_model)