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

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import requests
import json
from scipy import stats
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Set style
sns.set_style("whitegrid")
plt.rcParams['figure.dpi'] = 100

print("✓ Python packages loaded successfully")

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

# Function to load recruiting data from CFBD API
def load_recruiting_data(years):
    """Load recruiting data from College Football Data API"""
    all_data = []

    for year in years:
        url = f"https://api.collegefootballdata.com/recruiting/players?year={year}"
        try:
            response = requests.get(url)
            if response.status_code == 200:
                data = response.json()
                df = pd.DataFrame(data)
                df['year'] = year
                all_data.append(df)
        except Exception as e:
            print(f"Error loading {year}: {e}")

    return pd.concat(all_data, ignore_index=True)

# Load data for recent years
years = [2020, 2021, 2022, 2023]
recruiting_data = load_recruiting_data(years)

# Clean and prepare data
recruiting_data['stars'] = pd.to_numeric(recruiting_data['stars'], errors='coerce')
recruiting_data['rating'] = pd.to_numeric(recruiting_data['rating'], errors='coerce')
recruiting_data['year'] = pd.to_numeric(recruiting_data['year'], errors='coerce')

print(f"Loaded {len(recruiting_data):,} recruits from 2020-2023")
print("\nSample of data:")
print(recruiting_data[['year', 'name', 'school', 'position',
                       'stars', 'rating', 'stateProvince']].head(10))

#| label: class-rankings-py
#| message: false
#| warning: false

# Calculate team recruiting class metrics
class_rankings = (recruiting_data
    .groupby(['year', 'school'])
    .agg(
        total_recruits=('name', 'count'),
        five_stars=('stars', lambda x: (x == 5).sum()),
        four_stars=('stars', lambda x: (x == 4).sum()),
        three_stars=('stars', lambda x: (x == 3).sum()),
        avg_rating=('rating', 'mean'),
        avg_stars=('stars', 'mean'),
        total_points=('rating', 'sum')
    )
    .reset_index()
)

# Calculate blue chip metrics
class_rankings['blue_chips'] = class_rankings['five_stars'] + class_rankings['four_stars']
class_rankings['blue_chip_pct'] = class_rankings['blue_chips'] / class_rankings['total_recruits']

# Sort by average rating
class_rankings = class_rankings.sort_values(['year', 'avg_rating'], ascending=[True, False])

# Display top 10 classes in 2023
print("\nTop 10 Recruiting Classes - 2023")
print("="*80)
top_2023 = class_rankings[class_rankings['year'] == 2023].head(10)
print(top_2023[['school', 'total_recruits', 'five_stars', 'four_stars',
                'avg_rating', 'blue_chip_pct']].to_string(index=False))

#| label: fig-star-distribution-py
#| fig-cap: "Distribution of star ratings - Python"
#| fig-width: 10
#| fig-height: 6
#| message: false
#| warning: false

# Star rating distribution by year
star_dist = (recruiting_data
    .query("stars.notna() & stars >= 2 & stars <= 5")
    .groupby(['year', 'stars'])
    .size()
    .reset_index(name='count')
)

# Create grouped bar chart
fig, ax = plt.subplots(figsize=(10, 6))
years = star_dist['year'].unique()
x = np.arange(4)  # 2, 3, 4, 5 stars
width = 0.2

for i, year in enumerate(sorted(years)):
    year_data = star_dist[star_dist['year'] == year]
    counts = [year_data[year_data['stars'] == s]['count'].values[0]
              if len(year_data[year_data['stars'] == s]) > 0 else 0
              for s in [2, 3, 4, 5]]
    ax.bar(x + i*width, counts, width, label=str(int(year)), alpha=0.8)

ax.set_xlabel('Star Rating', fontsize=12)
ax.set_ylabel('Number of Recruits', fontsize=12)
ax.set_title('Distribution of Star Ratings by Year\n2020-2023 Recruiting Classes',
             fontsize=14, fontweight='bold')
ax.set_xticks(x + width * 1.5)
ax.set_xticklabels(['2★', '3★', '4★', '5★'])
ax.legend(title='Year', loc='upper right')
ax.text(0.98, 0.02, 'Data: CollegeFootballData.com',
        transform=ax.transAxes, ha='right', fontsize=8, style='italic')
plt.tight_layout()
plt.show()

#| label: composite-analysis-py
#| message: false
#| warning: false

# Analyze composite ratings by star level
rating_by_stars = (recruiting_data
    .query("stars.notna() & rating.notna() & stars >= 2 & stars <= 5")
    .groupby('stars')
    .agg(
        count=('rating', 'count'),
        mean_rating=('rating', 'mean'),
        median_rating=('rating', 'median'),
        sd_rating=('rating', 'std'),
        min_rating=('rating', 'min'),
        max_rating=('rating', 'max')
    )
    .reset_index()
)

print("\nComposite Rating Statistics by Star Level")
print("="*80)
print(rating_by_stars.to_string(index=False))

#| label: geographic-analysis-py
#| message: false
#| warning: false

# Top talent-producing states
state_production = (recruiting_data
    .query("stateProvince.notna() & stars.notna()")
    .groupby('stateProvince')
    .agg(
        total_recruits=('name', 'count'),
        five_stars=('stars', lambda x: (x == 5).sum()),
        four_stars=('stars', lambda x: (x == 4).sum()),
        avg_rating=('rating', 'mean')
    )
    .reset_index()
)

state_production['blue_chips'] = state_production['five_stars'] + state_production['four_stars']
state_production = state_production.sort_values('blue_chips', ascending=False)

print("\nTop 15 Talent-Producing States (2020-2023)")
print("="*80)
print(state_production.head(15).to_string(index=False))

#| label: footprint-analysis-py
#| message: false
#| warning: false

# Recruiting footprint for selected schools
schools_of_interest = ["Alabama", "Ohio State", "Georgia", "Texas"]

footprint_analysis = (recruiting_data
    .query("school in @schools_of_interest & stateProvince.notna()")
    .groupby(['school', 'stateProvince'])
    .agg(
        recruits=('name', 'count'),
        avg_stars=('stars', 'mean')
    )
    .reset_index()
)

# Calculate percentage of class
footprint_analysis['pct_of_class'] = (footprint_analysis
    .groupby('school')['recruits']
    .transform(lambda x: x / x.sum())
)

# Show top 5 states for each school
print("\nTop Recruiting States by School (2020-2023)")
print("="*80)
for school in schools_of_interest:
    school_data = footprint_analysis[footprint_analysis['school'] == school]
    top5 = school_data.nlargest(5, 'recruits')
    print(f"\n{school}:")
    print(top5[['stateProvince', 'recruits', 'avg_stars', 'pct_of_class']].to_string(index=False))

#| label: position-analysis-py
#| message: false
#| warning: false

# Position group analysis
position_analysis = (recruiting_data
    .query("position.notna() & stars.notna()")
    .groupby('position')
    .agg(
        total=('name', 'count'),
        avg_stars=('stars', 'mean'),
        avg_rating=('rating', 'mean'),
        blue_chips=('stars', lambda x: (x >= 4).sum())
    )
    .reset_index()
)

# Filter for positions with sufficient data
position_analysis = position_analysis[position_analysis['total'] >= 100]
position_analysis['blue_chip_pct'] = position_analysis['blue_chips'] / position_analysis['total']
position_analysis = position_analysis.sort_values('avg_stars', ascending=False)

print("\nTop 15 Positions by Average Star Rating (2020-2023)")
print("="*80)
print(position_analysis.head(15)[['position', 'total', 'avg_stars',
                                   'avg_rating', 'blue_chip_pct']].to_string(index=False))

#| label: fig-position-scarcity-py
#| fig-cap: "Elite talent scarcity by position - Python"
#| fig-width: 10
#| fig-height: 6
#| message: false
#| warning: false

# 5-star recruits by position
five_star_positions = (recruiting_data
    .query("stars == 5 & position.notna()")
    .groupby('position')
    .size()
    .reset_index(name='count')
    .sort_values('count', ascending=True)
    .tail(12)
)

fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(five_star_positions['position'], five_star_positions['count'],
        color='#0066CC', alpha=0.8)
ax.set_xlabel('Number of 5-Star Recruits', fontsize=12)
ax.set_ylabel('Position', fontsize=12)
ax.set_title('Five-Star Recruits by Position\nElite talent distribution, 2020-2023',
             fontsize=14, fontweight='bold')

# Add count labels
for i, (pos, count) in enumerate(zip(five_star_positions['position'],
                                      five_star_positions['count'])):
    ax.text(count + 0.2, i, str(count), va='center', fontsize=9)

plt.text(0.98, 0.02, 'Data: CollegeFootballData.com',
         transform=ax.transAxes, ha='right', fontsize=8, style='italic')
plt.tight_layout()
plt.show()

#| label: projection-setup-py
#| message: false
#| warning: false
#| cache: true

# Create synthetic college performance data for demonstration
np.random.seed(42)

# Filter to 2020-2021 classes
college_performance = recruiting_data[
    (recruiting_data['year'].isin([2020, 2021])) &
    (recruiting_data['stars'].notna()) &
    (recruiting_data['rating'].notna())
].copy()

# Simulate college performance metrics (replace with actual data)
def simulate_draft_pick(stars):
    if stars == 5:
        return min(262, max(1, np.random.normal(80, 50)))
    elif stars == 4:
        return min(262, max(1, np.random.normal(150, 60)))
    elif stars == 3:
        return min(262, max(1, np.random.normal(220, 40)))
    else:
        return 999

def simulate_war(stars):
    if stars == 5:
        return max(0, np.random.normal(2.5, 1.2))
    elif stars == 4:
        return max(0, np.random.normal(1.5, 1.0))
    elif stars == 3:
        return max(0, np.random.normal(0.8, 0.8))
    else:
        return max(0, np.random.normal(0.3, 0.5))

college_performance['draft_pick'] = college_performance['stars'].apply(simulate_draft_pick)
college_performance['drafted'] = college_performance['draft_pick'] <= 262
college_performance['college_war'] = college_performance['stars'].apply(simulate_war)

# Calculate draft rates by star level
draft_rates = (college_performance
    .groupby('stars')
    .agg(
        total=('name', 'count'),
        drafted=('drafted', 'sum'),
        avg_pick=('draft_pick', lambda x: x[x <= 262].mean()),
        avg_war=('college_war', 'mean')
    )
    .reset_index()
)

draft_rates['draft_rate'] = draft_rates['drafted'] / draft_rates['total']

print("\nNFL Draft Success by Star Rating")
print("="*80)
print(draft_rates.to_string(index=False))

#| label: projection-model-py
#| message: false
#| warning: false

# Prepare data for modeling
model_data = college_performance.dropna(subset=['college_war', 'rating', 'position'])

# Create position dummies
position_dummies = pd.get_dummies(model_data['position'], prefix='pos', drop_first=True)
X = pd.concat([model_data[['rating']], position_dummies], axis=1)
y = model_data['college_war']

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train linear regression
lr_model = LinearRegression()
lr_model.fit(X_train, y_train)

# Predictions
y_pred = lr_model.predict(X_test)

# Evaluate
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print("\nLinear Regression Model Performance")
print("="*80)
print(f"R-squared: {r2:.3f}")
print(f"RMSE: {rmse:.3f}")

# Feature importance
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'coefficient': lr_model.coef_
}).sort_values('coefficient', key=abs, ascending=False)

print("\nTop Predictive Features:")
print(feature_importance.head(10).to_string(index=False))

#| label: ensemble-model-py
#| message: false
#| warning: false

# Train Random Forest
rf_model = RandomForestRegressor(
    n_estimators=500,
    max_depth=10,
    random_state=42,
    n_jobs=-1
)

rf_model.fit(X_train, y_train)

# Predictions
y_pred_rf = rf_model.predict(X_test)

# Evaluate
r2_rf = r2_score(y_test, y_pred_rf)
rmse_rf = np.sqrt(mean_squared_error(y_test, y_pred_rf))

print("\nRandom Forest Model Performance")
print("="*80)
print(f"R-squared: {r2_rf:.3f}")
print(f"RMSE: {rmse_rf:.3f}")

# Feature importance
rf_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

print("\nFeature Importance (Top 10):")
print(rf_importance.head(10).to_string(index=False))

#| label: blue-chip-ratio-py
#| message: false
#| warning: false

# Calculate Blue Chip Ratio by school
blue_chip_ratio = (recruiting_data
    .query("stars.notna() & year >= 2020")
    .groupby('school')
    .agg(
        total_recruits=('name', 'count'),
        blue_chips=('stars', lambda x: (x >= 4).sum()),
        avg_stars=('stars', 'mean'),
        five_stars=('stars', lambda x: (x == 5).sum())
    )
    .reset_index()
)

# Filter minimum sample size
blue_chip_ratio = blue_chip_ratio[blue_chip_ratio['total_recruits'] >= 60]
blue_chip_ratio['blue_chip_ratio'] = blue_chip_ratio['blue_chips'] / blue_chip_ratio['total_recruits']
blue_chip_ratio = blue_chip_ratio.sort_values('blue_chip_ratio', ascending=False)

print("\nBlue Chip Ratio Leaders (2020-2023)")
print("="*80)
print(blue_chip_ratio.head(15).to_string(index=False))

#| label: fig-bcr-wins-py
#| fig-cap: "Blue Chip Ratio vs Winning Percentage - Python"
#| fig-width: 10
#| fig-height: 6
#| message: false
#| warning: false

# Simulated winning percentage (replace with actual data)
np.random.seed(42)
bcr_wins = blue_chip_ratio.copy()
bcr_wins['win_pct'] = (0.5 +
                        (bcr_wins['blue_chip_ratio'] * 0.35) +
                        np.random.normal(0, 0.08, len(bcr_wins)))
bcr_wins['win_pct'] = bcr_wins['win_pct'].clip(0.3, 1.0)
bcr_wins['championship'] = bcr_wins['blue_chip_ratio'] >= 0.5

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

# Scatter plot
colors = ['#999999' if not c else '#E41A1C' for c in bcr_wins['championship']]
scatter = ax.scatter(bcr_wins['blue_chip_ratio'], bcr_wins['win_pct'],
                     c=colors, s=bcr_wins['five_stars']*20, alpha=0.6)

# Regression line
z = np.polyfit(bcr_wins['blue_chip_ratio'], bcr_wins['win_pct'], 1)
p = np.poly1d(z)
ax.plot(bcr_wins['blue_chip_ratio'].sort_values(),
        p(bcr_wins['blue_chip_ratio'].sort_values()),
        "b--", alpha=0.8, label='Trend line')

# 50% threshold line
ax.axvline(x=0.5, color='red', linestyle='--', alpha=0.7, label='50% BCR threshold')

ax.set_xlabel('Blue Chip Ratio', fontsize=12)
ax.set_ylabel('Winning Percentage', fontsize=12)
ax.set_title('Blue Chip Ratio and Winning Percentage\nThe 50% threshold predicts championship contention',
             fontsize=14, fontweight='bold')

# Format as percentages
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: '{:.0%}'.format(y)))
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: '{:.0%}'.format(y)))

ax.legend()
plt.text(0.98, 0.02, 'Simulated data for demonstration',
         transform=ax.transAxes, ha='right', fontsize=8, style='italic')
plt.tight_layout()
plt.show()

#| label: development-efficiency-py
#| message: false
#| warning: false

# Calculate development efficiency
development = (college_performance
    .groupby('school')
    .agg(
        recruits=('name', 'count'),
        avg_stars=('stars', 'mean'),
        avg_rating=('rating', 'mean'),
        drafted=('drafted', 'sum'),
        avg_war=('college_war', 'mean')
    )
    .reset_index()
)

# Filter minimum sample size
development = development[development['recruits'] >= 20]
development['draft_rate'] = development['drafted'] / development['recruits']

# Expected draft rate based on average stars
def expected_draft_rate(avg_stars):
    if avg_stars >= 4.5:
        return 0.45
    elif avg_stars >= 4.0:
        return 0.35
    elif avg_stars >= 3.5:
        return 0.25
    elif avg_stars >= 3.0:
        return 0.15
    else:
        return 0.08

development['expected_draft_rate'] = development['avg_stars'].apply(expected_draft_rate)
development['development_index'] = development['draft_rate'] - development['expected_draft_rate']
development = development.sort_values('development_index', ascending=False)

print("\nPlayer Development Leaders (Simulated Data)")
print("="*80)
print(development.head(10)[['school', 'recruits', 'avg_stars', 'draft_rate',
                            'expected_draft_rate', 'development_index']].to_string(index=False))

#| label: transfer-analysis-py
#| message: false
#| warning: false

# Simulate transfer portal data
np.random.seed(42)

portal_data = pd.DataFrame({
    'year': np.repeat([2020, 2021, 2022, 2023], 500),
    'player_name': [f'Player_{i}' for i in range(2000)],
    'from_school': np.random.choice(recruiting_data['school'].dropna().unique(), 2000),
    'to_school': np.random.choice(recruiting_data['school'].dropna().unique(), 2000),
    'position': np.random.choice(recruiting_data['position'].dropna().unique(), 2000),
    'original_stars': np.random.choice([2, 3, 4, 5], 2000, p=[0.1, 0.5, 0.35, 0.05]),
    'portal_rating': np.random.normal(85, 10, 2000)
})

# Remove same-school transfers
portal_data = portal_data[portal_data['from_school'] != portal_data['to_school']]

# Transfer trends over time
transfer_trends = (portal_data
    .groupby('year')
    .agg(
        total_transfers=('player_name', 'count'),
        avg_rating=('portal_rating', 'mean'),
        four_plus_stars=('original_stars', lambda x: (x >= 4).sum())
    )
    .reset_index()
)

print("\nTransfer Portal Trends (Simulated Data)")
print("="*80)
print(transfer_trends.to_string(index=False))

#| label: fig-portal-value-py
#| fig-cap: "Transfer portal growth trends - Python"
#| fig-width: 10
#| fig-height: 6
#| message: false
#| warning: false

fig, ax = plt.subplots(figsize=(10, 6))

ax.plot(transfer_trends['year'], transfer_trends['total_transfers'],
        color='#0066CC', linewidth=2.5, marker='o', markersize=10)

# Add value labels
for x, y in zip(transfer_trends['year'], transfer_trends['total_transfers']):
    ax.text(x, y + 10, str(int(y)), ha='center', fontsize=11)

ax.set_xlabel('Year', fontsize=12)
ax.set_ylabel('Total Transfers', fontsize=12)
ax.set_title('Transfer Portal Growth\nTotal transfers by year (simulated data)',
             fontsize=14, fontweight='bold')
ax.set_ylim(0, transfer_trends['total_transfers'].max() * 1.2)

plt.text(0.98, 0.02, 'Data: Simulated for demonstration',
         transform=ax.transAxes, ha='right', fontsize=8, style='italic')
plt.tight_layout()
plt.show()

#| label: recruiting-report-py
#| message: false
#| warning: false

def generate_recruiting_report(school_name, year_val):
    """Generate comprehensive recruiting report for a school"""

    # Filter data
    school_data = recruiting_data[
        (recruiting_data['school'] == school_name) &
        (recruiting_data['year'] == year_val)
    ]

    # Class composition
    composition = {
        'total_commits': len(school_data),
        'five_stars': (school_data['stars'] == 5).sum(),
        'four_stars': (school_data['stars'] == 4).sum(),
        'three_stars': (school_data['stars'] == 3).sum(),
        'avg_rating': school_data['rating'].mean(),
        'avg_stars': school_data['stars'].mean(),
        'blue_chip_ratio': (school_data['stars'] >= 4).sum() / len(school_data)
    }

    # Position breakdown
    positions = school_data['position'].value_counts().head(10)

    # Geographic distribution
    geography = school_data['stateProvince'].value_counts().head(10)

    return {
        'composition': composition,
        'positions': positions,
        'geography': geography
    }

# Example report for Alabama 2023
report = generate_recruiting_report("Alabama", 2023)

print("="*80)
print("RECRUITING REPORT CARD")
print("School: Alabama | Year: 2023")
print("="*80)

print("\nCLASS COMPOSITION:")
for key, value in report['composition'].items():
    if isinstance(value, float):
        print(f"  {key}: {value:.2f}")
    else:
        print(f"  {key}: {value}")

print("\nTOP POSITIONS:")
print(report['positions'].head(5))

print("\nTOP STATES:")
print(report['geography'].head(5))