#| label: setup-py
#| message: false
#| warning: false

import pandas as pd
import numpy as np
import nfl_data_py as nfl
import matplotlib.pyplot as plt
import seaborn as sns

# Load play-by-play data for multiple seasons
pbp = nfl.import_pbp_data([2021, 2022, 2023])

# Display data dimensions
print(f"Loaded {len(pbp):,} plays from {pbp['season'].nunique()} seasons")
print(f"Number of columns: {len(pbp.columns)}")
print(f"Seasons included: {', '.join(map(str, sorted(pbp['season'].unique())))}")

#| label: pbp-structure-py
#| message: false

# Display key variable categories
key_vars = {
    'Game_Info': ['game_id', 'season', 'week', 'game_date', 'season_type'],
    'Teams': ['posteam', 'defteam', 'home_team', 'away_team'],
    'Situation': ['down', 'ydstogo', 'yardline_100', 'quarter_seconds_remaining'],
    'Play_Info': ['play_type', 'yards_gained', 'touchdown', 'fumble', 'interception'],
    'Advanced_Metrics': ['epa', 'wpa', 'success', 'cpoe', 'air_yards'],
    'Players': ['passer_player_name', 'rusher_player_name', 'receiver_player_name']
}

# Flatten the list of columns
all_cols = [col for cols in key_vars.values() for col in cols]

# Show sample data
sample_data = (pbp
    .query("season == 2023 & week == 1 & epa.notna()")
    [all_cols]
    .head(3)
)

print("\nSample Play-by-Play Data:")
print(sample_data.to_string())

#| label: nflreadr-datasets-py
#| eval: false

import nfl_data_py as nfl

# Play-by-play data
pbp = nfl.import_pbp_data([2023])

# Roster data
rosters = nfl.import_rosters([2023])

# Team information
teams = nfl.import_team_desc()

# Schedule data
schedules = nfl.import_schedules([2023])

# Weekly player statistics
weekly_data = nfl.import_weekly_data([2023])

# Seasonal player statistics
seasonal_data = nfl.import_seasonal_data([2023])

# Next Gen Stats
ngs_passing = nfl.import_ngs_data('passing', [2023])
ngs_rushing = nfl.import_ngs_data('rushing', [2023])
ngs_receiving = nfl.import_ngs_data('receiving', [2023])

# Depth charts
depth_charts = nfl.import_depth_charts([2023])

# Injuries
injuries = nfl.import_injuries([2023])

# Combine results
combine = nfl.import_combine_data([2020, 2021, 2022, 2023])

# Draft picks
draft_picks = nfl.import_draft_picks([2020, 2021, 2022, 2023])

# Snap counts
snap_counts = nfl.import_snap_counts([2023])

#| label: roster-data-py
#| message: false
#| warning: false
#| cache: true

# Load roster data
rosters_2023 = nfl.import_rosters([2023])

# Display key roster information
kc_roster = (rosters_2023
    .query("team == 'KC'")
    [['full_name', 'position', 'jersey_number', 'height', 'weight',
      'college', 'years_exp', 'gsis_id']]
    .sort_values(['position', 'jersey_number'])
    .head(10)
)

print("\nKansas City Chiefs Roster Sample (2023):")
print(kc_roster.to_string(index=False))

#| label: team-info-py
#| message: false
#| warning: false

# Load team information
teams = nfl.import_team_desc()

# Display team colors and identifiers
afc_west = (teams
    .query("team_conf == 'AFC' & team_division == 'AFC West'")
    [['team_abbr', 'team_name', 'team_color', 'team_color2',
      'team_conf', 'team_division']]
)

print("\nAFC West Team Information:")
print(afc_west.to_string(index=False))

#| label: fig-logo-plot-py
#| fig-cap: "Average EPA per play by team - Python (2023 season)"
#| fig-width: 12
#| fig-height: 8
#| message: false
#| warning: false
#| cache: true

# Calculate team offensive EPA
team_epa = (pbp
    .query("season == 2023 & epa.notna() & posteam.notna()")
    .query("play_type.isin(['pass', 'run'])")
    .groupby('posteam')
    .agg(
        plays=('epa', 'count'),
        epa_per_play=('epa', 'mean'),
        success_rate=('success', 'mean')
    )
    .reset_index()
    .sort_values('epa_per_play', ascending=True)
)

# Create bar plot
fig, ax = plt.subplots(figsize=(12, 8))

# Get team colors
team_colors = dict(zip(teams['team_abbr'], teams['team_color']))
colors = [team_colors.get(team, '#333333') for team in team_epa['posteam']]

bars = ax.barh(range(len(team_epa)), team_epa['epa_per_play'], color=colors, alpha=0.7)

# Customize plot
ax.set_yticks(range(len(team_epa)))
ax.set_yticklabels(team_epa['posteam'])
ax.set_xlabel('EPA per Play', fontsize=12)
ax.set_title('Offensive Efficiency by Team\nAverage EPA per play, 2023 Regular Season',
             fontsize=16, fontweight='bold', pad=20)
ax.text(0.99, 0.01, 'Data: nfl_data_py | Includes pass and run plays only',
        transform=ax.transAxes, ha='right', va='bottom', fontsize=8, style='italic')
ax.axvline(x=0, color='black', linestyle='-', linewidth=0.5, alpha=0.3)
ax.grid(axis='x', alpha=0.3)

plt.tight_layout()
plt.show()

#| label: fig-scatter-logos-py
#| fig-cap: "Team offensive vs defensive EPA - Python (2023 season)"
#| fig-width: 10
#| fig-height: 10
#| message: false
#| warning: false
#| cache: true

# Calculate offensive EPA
off_epa = (pbp
    .query("season == 2023 & epa.notna() & play_type.isin(['pass', 'run'])")
    .groupby('posteam')
    .agg(off_epa=('epa', 'mean'))
    .reset_index()
)

# Calculate defensive EPA
def_epa = (pbp
    .query("season == 2023 & epa.notna() & play_type.isin(['pass', 'run'])")
    .groupby('defteam')
    .agg(def_epa=('epa', 'mean'))
    .reset_index()
)

# Merge
team_off_def = off_epa.merge(def_epa, left_on='posteam', right_on='defteam')

# Create scatter plot
fig, ax = plt.subplots(figsize=(10, 10))

# Plot points with team colors
for _, row in team_off_def.iterrows():
    team = row['posteam']
    color = team_colors.get(team, '#333333')
    ax.scatter(row['off_epa'], -row['def_epa'], s=300, color=color, alpha=0.6)
    ax.text(row['off_epa'], -row['def_epa'], team,
            ha='center', va='center', fontsize=8, fontweight='bold')

# Add reference lines
ax.axvline(x=0, linestyle='--', alpha=0.5, color='gray')
ax.axhline(y=0, linestyle='--', alpha=0.5, color='gray')

# Customize plot
ax.set_xlabel('Offensive EPA per Play', fontsize=12)
ax.set_ylabel('Defensive EPA per Play (reversed, higher = better)', fontsize=12)
ax.set_title('Team Performance Matrix: Offense vs Defense\nEPA per play, 2023 Regular Season | Top right = Best teams',
             fontsize=14, fontweight='bold', pad=20)
ax.text(0.99, 0.01, 'Data: nfl_data_py',
        transform=ax.transAxes, ha='right', va='bottom', fontsize=8, style='italic')
ax.grid(alpha=0.3)

plt.tight_layout()
plt.show()

#| label: fig-time-series-py
#| fig-cap: "Weekly EPA trends for AFC West teams - Python (2023)"
#| fig-width: 12
#| fig-height: 6
#| message: false
#| warning: false
#| cache: true

# Calculate weekly EPA for AFC West teams
afc_west_teams = ['KC', 'LV', 'LAC', 'DEN']

weekly_epa = (pbp
    .query("season == 2023 & season_type == 'REG' & posteam in @afc_west_teams")
    .query("epa.notna() & play_type.isin(['pass', 'run'])")
    .groupby(['posteam', 'week'])
    .agg(epa_per_play=('epa', 'mean'))
    .reset_index()
)

# Create line plot
fig, ax = plt.subplots(figsize=(12, 6))

for team in afc_west_teams:
    team_data = weekly_epa[weekly_epa['posteam'] == team]
    color = team_colors.get(team, '#333333')
    ax.plot(team_data['week'], team_data['epa_per_play'],
            marker='o', linewidth=2.5, label=team, color=color, alpha=0.8)

ax.set_xlabel('Week', fontsize=12)
ax.set_ylabel('EPA per Play', fontsize=12)
ax.set_title('AFC West Weekly Offensive Performance\nEPA per play by week, 2023 Regular Season',
             fontsize=14, fontweight='bold', pad=20)
ax.legend(title='Team', loc='best', frameon=True)
ax.grid(alpha=0.3)
ax.set_xticks(range(1, 19))
ax.text(0.99, 0.01, 'Data: nfl_data_py',
        transform=ax.transAxes, ha='right', va='bottom', fontsize=8, style='italic')

plt.tight_layout()
plt.show()

#| label: nfl4th-example-py
#| eval: false
#| echo: true

# Python doesn't have a direct nfl4th equivalent
# But you can calculate win probability using EPA models
# Here's a conceptual example of how you might approach this

def calculate_4th_down_wp(
    yardline_100, ydstogo, score_diff,
    seconds_remaining, timeouts_remaining
):
    """
    Simplified 4th down win probability calculator
    In practice, you would use a trained model
    """
    # This is a placeholder for demonstration
    # Real implementation would use historical data
    # to build a win probability model

    # Factors to consider:
    # - Distance to go
    # - Field position
    # - Score differential
    # - Time remaining
    # - Historical conversion rates

    pass  # Implementation would go here

# Example usage
situation = {
    'yardline_100': 35,
    'ydstogo': 3,
    'score_diff': -3,
    'seconds_remaining': 300,
    'timeouts': 3
}

#| label: nflseedr-example-py
#| eval: false
#| echo: true

# Python implementation of playoff simulation
# This is a simplified conceptual example

import numpy as np

def simulate_remaining_games(schedule, team_strengths, n_sims=10000):
    """
    Simulate remaining NFL games to calculate playoff probabilities
    """
    results = []

    for sim in range(n_sims):
        # Simulate each remaining game
        season_results = schedule.copy()

        for idx, game in season_results.iterrows():
            home_team = game['home_team']
            away_team = game['away_team']

            # Get team strengths (could use EPA, ELO, etc.)
            home_strength = team_strengths.get(home_team, 0)
            away_strength = team_strengths.get(away_team, 0)

            # Calculate win probability (simplified)
            home_wp = 1 / (1 + np.exp(-(home_strength - away_strength + 0.2)))

            # Simulate outcome
            home_wins = np.random.random() < home_wp

            # Store result
            # ... continue simulation logic

    return results

# This would be expanded into full playoff simulation

#| label: combine-data-py
#| message: false
#| warning: false
#| cache: true

# Load multiple data sources
rosters = nfl.import_rosters([2023])
pbp_2023_py = nfl.import_pbp_data([2023])

# Analyze QB performance with roster information
qb_analysis = (pbp_2023_py
    .query("passer_player_id.notna() & play_type == 'pass'")
    .groupby(['passer_player_id', 'passer_player_name'])
    .agg(
        team=('posteam', 'first'),
        dropbacks=('epa', 'count'),
        epa_per_dropback=('epa', lambda x: x.mean()),
        cpoe=('cpoe', lambda x: x.mean()),
        success_rate=('success', lambda x: x.mean())
    )
    .reset_index()
    .query("dropbacks >= 100")
)

# Join with roster data
qb_analysis = qb_analysis.merge(
    rosters[['gsis_id', 'college', 'years_exp', 'height', 'weight']],
    left_on='passer_player_id',
    right_on='gsis_id',
    how='left'
)

# Sort and display
qb_analysis = qb_analysis.sort_values('epa_per_dropback', ascending=False)

print("\nTop Quarterback Performance (Min 100 dropbacks, 2023):")
print(qb_analysis[['passer_player_name', 'team', 'dropbacks', 'epa_per_dropback',
                    'cpoe', 'success_rate', 'college', 'years_exp']].head(10).to_string(index=False))

#| label: roster-composition-py
#| message: false
#| warning: false
#| cache: true

# Analyze roster composition by team
roster_composition = (rosters
    .query("status == 'ACT'")
    .groupby(['team', 'position'])
    .agg(
        count=('gsis_id', 'count'),
        avg_exp=('years_exp', 'mean')
    )
    .reset_index()
    .pivot_table(
        index='team',
        columns='position',
        values='count',
        fill_value=0
    )
    .reset_index()
)

# Calculate team performance
team_performance = (pbp_2023_py
    .query("epa.notna() & play_type.isin(['pass', 'run'])")
    .groupby('posteam')
    .agg(epa_per_play=('epa', 'mean'))
    .reset_index()
)

# Combine and analyze
roster_performance = roster_composition.merge(
    team_performance,
    left_on='team',
    right_on='posteam',
    how='left'
)

print("\nRoster composition analysis complete")
print(f"Teams analyzed: {len(roster_performance)}")

#| label: data-relationships-py
#| message: false
#| warning: false

# Examine data relationships
data_structure = pd.DataFrame({
    'Level': ['Season', 'Game', 'Drive', 'Play'],
    'Key_Field': ['season', 'game_id', 'drive', 'play_id'],
    'Count_2023': [
        pbp_2023_py['season'].nunique(),
        pbp_2023_py['game_id'].nunique(),
        pbp_2023_py['drive'].sum() if 'drive' in pbp_2023_py.columns else 0,
        len(pbp_2023_py)
    ],
    'Example_Fields': [
        'season_type, week',
        'home_team, away_team, game_date',
        'drive_start_yard_line, drive_end_yard_line',
        'down, ydstogo, play_type, epa'
    ]
})

print("\nPlay-by-Play Data Structure:")
print(data_structure.to_string(index=False))

#| label: missing-data-py
#| message: false
#| warning: false

# Analyze missing data patterns
fields_to_check = ['epa', 'wpa', 'cpoe', 'air_yards', 'passer_player_id']
total_plays = len(pbp_2023_py)

missing_data = []
for field in fields_to_check:
    if field in pbp_2023_py.columns:
        missing_count = pbp_2023_py[field].isna().sum()
        missing_data.append({
            'field': field,
            'missing_count': missing_count,
            'pct_missing': (missing_count / total_plays) * 100
        })

missing_analysis = pd.DataFrame(missing_data)

print("\nMissing Data Analysis (2023 season):")
print(f"Total plays: {total_plays:,}")
print(missing_analysis.to_string(index=False))

#| label: best-practice-loading-py
#| eval: false
#| echo: true

# DO: Cache loaded data
pbp = nfl.import_pbp_data(list(range(2020, 2024)))
pbp.to_parquet('data/pbp_2020_2023.parquet')

# Later, load from cache
pbp = pd.read_parquet('data/pbp_2020_2023.parquet')

# DON'T: Repeatedly download the same data
for season in range(2020, 2024):
    pbp = nfl.import_pbp_data([season])  # Inefficient!

#| label: best-practice-filtering-py
#| eval: false
#| echo: true

# DO: Filter comprehensively
analysis_data = (pbp
    .query("epa.notna()")                      # Remove plays without EPA
    .query("play_type.isin(['pass', 'run'])")  # Only standard plays
    .query("posteam.notna()")                  # Remove missing team
    .query("season_type == 'REG'")             # Only regular season
)

# DON'T: Incomplete filtering
bad_data = pbp.query("play_type == 'pass'")  # Missing other important filters!

#| label: best-practice-grouping-py
#| eval: false
#| echo: true

# DO: Use meaningful aggregations
team_stats = (pbp
    .query("epa.notna() & play_type.isin(['pass', 'run'])")
    .groupby(['posteam', 'season'])
    .agg(
        plays=('epa', 'count'),
        epa_per_play=('epa', 'mean'),
        success_rate=('success', 'mean'),
        explosive_rate=('epa', lambda x: (x > 1.0).mean())
    )
    .reset_index()
    .query("plays >= 100")  # Minimum sample size
)

# DON'T: Aggregate without sample size filters
bad_stats = (pbp
    .groupby('posteam')
    .agg(avg_epa=('epa', 'mean'))  # Includes all plays!
)