• Time zone differences affecting live game viewing
• Limited video access for lower-tier competitions
• Cultural and language barriers in player evaluation
• Varying competitive levels across leagues
• Contract complexities and buyout clauses

• NBL (Australia): Growing development pathway for NBA prospects
• CBA (China): Lucrative league with improving talent development
• B.League (Japan): Professional league with growing international presence
• Basketball Africa League (BAL): New league tapping into African talent
• LNB (Argentina): Strong technical development in South America

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
import matplotlib.pyplot as plt
import seaborn as sns

class InternationalScoutingAnalyzer:
    """
    Analyze and normalize international player statistics
    for cross-league comparison and NBA projection.
    """

    def __init__(self):
        # League difficulty multipliers based on historical NBA success rates
        self.league_multipliers = {
            'EuroLeague': 1.00,
            'ACB': 0.95,
            'Bundesliga': 0.88,
            'Serie A': 0.85,
            'Greek League': 0.82,
            'Adriatic League': 0.80,
            'NBL': 0.85,
            'CBA': 0.75,
            'Other': 0.70
        }

        # Age adjustment factors
        self.age_prime = 27
        self.age_adjustment_factor = 0.03

    def load_international_data(self, filepath):
        """Load international player statistics from CSV."""
        df = pd.read_csv(filepath)
        required_cols = ['player', 'league', 'age', 'minutes', 'points',
                        'rebounds', 'assists', 'fg_pct', 'three_pct', 'ft_pct']

        missing_cols = set(required_cols) - set(df.columns)
        if missing_cols:
            raise ValueError(f"Missing required columns: {missing_cols}")

        return df

    def normalize_per_36(self, df):
        """Convert raw statistics to per-36-minute rates."""
        rate_stats = ['points', 'rebounds', 'assists', 'steals', 'blocks', 'turnovers']

        for stat in rate_stats:
            if stat in df.columns:
                df[f'{stat}_per36'] = (df[stat] / df['minutes']) * 36

        return df

    def adjust_for_league_quality(self, df):
        """Apply league difficulty multipliers to statistics."""
        df['league_multiplier'] = df['league'].map(self.league_multipliers).fillna(0.70)

        adjusted_stats = ['points_per36', 'rebounds_per36', 'assists_per36']

        for stat in adjusted_stats:
            if stat in df.columns:
                df[f'{stat}_adjusted'] = df[stat] * df['league_multiplier']

        return df

    def calculate_age_adjusted_performance(self, df):
        """Adjust performance metrics based on player age and development curve."""
        # Players younger than prime get bonus, older get penalty
        df['age_adjustment'] = 1 + ((self.age_prime - df['age']) * self.age_adjustment_factor)
        df['age_adjustment'] = df['age_adjustment'].clip(0.85, 1.20)

        performance_stats = ['points_per36_adjusted', 'rebounds_per36_adjusted', 'assists_per36_adjusted']

        for stat in performance_stats:
            if stat in df.columns:
                df[f'{stat}_age_adj'] = df[stat] * df['age_adjustment']

        return df

    def calculate_composite_score(self, df):
        """Create composite scouting score combining multiple factors."""
        # Weighted scoring system
        weights = {
            'points_per36_adjusted_age_adj': 0.35,
            'rebounds_per36_adjusted_age_adj': 0.20,
            'assists_per36_adjusted_age_adj': 0.20,
            'fg_pct': 0.10,
            'three_pct': 0.10,
            'ft_pct': 0.05
        }

        df['composite_score'] = 0

        for stat, weight in weights.items():
            if stat in df.columns:
                # Normalize to 0-100 scale
                scaler = StandardScaler()
                normalized = scaler.fit_transform(df[[stat]])
                df['composite_score'] += (normalized.flatten() * weight * 100)

        return df

    def identify_statistical_outliers(self, df):
        """Flag players with exceptional statistical profiles."""
        # Define thresholds for various categories
        df['elite_scorer'] = (df['points_per36_adjusted'] > 20) & (df['fg_pct'] > 0.48)
        df['elite_playmaker'] = (df['assists_per36_adjusted'] > 6) & (df['turnovers'] < 2.5)
        df['elite_rebounder'] = (df['rebounds_per36_adjusted'] > 10)
        df['three_point_specialist'] = (df['three_pct'] > 0.38) & (df['three_attempts'] > 4)

        # Flag multi-category excellence
        df['outlier_flags'] = (
            df['elite_scorer'].astype(int) +
            df['elite_playmaker'].astype(int) +
            df['elite_rebounder'].astype(int) +
            df['three_point_specialist'].astype(int)
        )

        return df

    def project_nba_translation(self, df):
        """
        Project how international statistics might translate to NBA performance.
        Based on historical conversion rates from similar players.
        """
        # Typical NBA translation rates (international stats to NBA stats)
        translation_rates = {
            'points': 0.75,      # Scoring typically drops 25%
            'rebounds': 0.85,    # Rebounding translates better
            'assists': 0.80,     # Playmaking moderately affected
            'fg_pct': 0.95,      # Efficiency slightly lower
            'three_pct': 0.93    # Three-point shooting translates well
        }

        for stat, rate in translation_rates.items():
            stat_col = f'{stat}_per36_adjusted_age_adj' if f'{stat}_per36_adjusted_age_adj' in df.columns else stat
            if stat_col in df.columns:
                df[f'nba_projected_{stat}'] = df[stat_col] * rate

        return df

    def generate_scouting_report(self, player_data):
        """Generate comprehensive scouting report for a player."""
        report = {
            'player': player_data['player'],
            'age': player_data['age'],
            'league': player_data['league'],
            'composite_score': round(player_data['composite_score'], 2),
            'strengths': [],
            'concerns': [],
            'nba_projection': {}
        }

        # Identify strengths
        if player_data.get('elite_scorer', False):
            report['strengths'].append('Elite scoring capability')
        if player_data.get('elite_playmaker', False):
            report['strengths'].append('Advanced playmaking skills')
        if player_data.get('elite_rebounder', False):
            report['strengths'].append('Exceptional rebounding')
        if player_data.get('three_point_specialist', False):
            report['strengths'].append('High-level three-point shooting')

        # Identify concerns
        if player_data['age'] > 24:
            report['concerns'].append('Limited development upside due to age')
        if player_data['league_multiplier'] < 0.80:
            report['concerns'].append('Competition level concerns')
        if player_data.get('fg_pct', 0) < 0.42:
            report['concerns'].append('Efficiency questions')

        # NBA projection
        proj_cols = [col for col in player_data.index if col.startswith('nba_projected_')]
        for col in proj_cols:
            stat_name = col.replace('nba_projected_', '')
            report['nba_projection'][stat_name] = round(player_data[col], 2)

        return report

    def visualize_player_comparison(self, df, players):
        """Create radar chart comparing multiple international prospects."""
        fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(projection='polar'))

        categories = ['Scoring', 'Rebounding', 'Playmaking', 'Efficiency', 'Three-Point']
        num_vars = len(categories)
        angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
        angles += angles[:1]

        for player in players:
            player_data = df[df['player'] == player].iloc[0]
            values = [
                player_data.get('points_per36_adjusted_age_adj', 0) / 30 * 100,
                player_data.get('rebounds_per36_adjusted_age_adj', 0) / 12 * 100,
                player_data.get('assists_per36_adjusted_age_adj', 0) / 8 * 100,
                player_data.get('fg_pct', 0) * 100,
                player_data.get('three_pct', 0) * 100
            ]
            values += values[:1]

            ax.plot(angles, values, 'o-', linewidth=2, label=player)
            ax.fill(angles, values, alpha=0.15)

        ax.set_xticks(angles[:-1])
        ax.set_xticklabels(categories)
        ax.set_ylim(0, 100)
        ax.set_title('International Prospect Comparison', size=16, weight='bold', pad=20)
        ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1.1))
        ax.grid(True)

        plt.tight_layout()
        return fig

    def analyze_league_trends(self, df):
        """Analyze statistical trends across different leagues."""
        league_analysis = df.groupby('league').agg({
            'points_per36': ['mean', 'std'],
            'rebounds_per36': ['mean', 'std'],
            'assists_per36': ['mean', 'std'],
            'fg_pct': ['mean', 'std'],
            'three_pct': ['mean', 'std'],
            'age': 'mean'
        }).round(2)

        return league_analysis

# Example usage
if __name__ == "__main__":
    # Initialize analyzer
    analyzer = InternationalScoutingAnalyzer()

    # Example data structure
    sample_data = {
        'player': ['Luka Prospect', 'Euro Guard', 'NBL Forward'],
        'league': ['EuroLeague', 'ACB', 'NBL'],
        'age': [21, 23, 20],
        'minutes': [28, 32, 30],
        'points': [16.5, 18.2, 14.8],
        'rebounds': [6.2, 3.5, 7.1],
        'assists': [5.1, 4.8, 2.3],
        'steals': [1.2, 1.5, 0.9],
        'blocks': [0.4, 0.2, 1.1],
        'turnovers': [2.3, 2.1, 1.8],
        'fg_pct': [0.485, 0.445, 0.512],
        'three_pct': [0.365, 0.388, 0.342],
        'three_attempts': [4.2, 5.1, 3.8],
        'ft_pct': [0.812, 0.865, 0.735]
    }

    df = pd.DataFrame(sample_data)

    # Run analysis pipeline
    df = analyzer.normalize_per_36(df)
    df = analyzer.adjust_for_league_quality(df)
    df = analyzer.calculate_age_adjusted_performance(df)
    df = analyzer.calculate_composite_score(df)
    df = analyzer.identify_statistical_outliers(df)
    df = analyzer.project_nba_translation(df)

    # Generate reports
    for idx, row in df.iterrows():
        report = analyzer.generate_scouting_report(row)
        print(f"\n{'='*60}")
        print(f"Scouting Report: {report['player']}")
        print(f"{'='*60}")
        print(f"Age: {report['age']} | League: {report['league']}")
        print(f"Composite Score: {report['composite_score']}")
        print(f"\nStrengths: {', '.join(report['strengths']) if report['strengths'] else 'None identified'}")
        print(f"Concerns: {', '.join(report['concerns']) if report['concerns'] else 'None identified'}")
        print(f"\nNBA Projection:")
        for stat, value in report['nba_projection'].items():
            print(f"  {stat}: {value}")

    # League analysis
    print(f"\n{'='*60}")
    print("League-Wide Analysis")
    print(f"{'='*60}")
    print(analyzer.analyze_league_trends(df))

library(tidyverse)
library(caret)
library(randomForest)
library(glmnet)
library(corrplot)
library(MASS)

# International to NBA Translation Model
# Predicts NBA performance from international statistics

# League quality adjustments based on historical data
league_coefficients <- tibble(
  league = c("EuroLeague", "ACB", "Bundesliga", "Serie A",
             "Greek League", "NBL", "CBA", "Other"),
  quality_factor = c(1.00, 0.95, 0.88, 0.85, 0.82, 0.85, 0.75, 0.70),
  pace_adjustment = c(1.05, 1.03, 1.00, 0.98, 0.97, 1.08, 1.12, 1.00)
)

# Load historical translation data
load_translation_data <- function(filepath) {
  # Expected columns: player, age, league, intl_ppg, intl_rpg, intl_apg,
  # intl_fg_pct, intl_3pt_pct, nba_ppg, nba_rpg, nba_apg, nba_success

  data <- read_csv(filepath) %>%
    mutate(
      age_at_arrival = as.numeric(age),
      years_to_prime = pmax(0, 27 - age_at_arrival)
    )

  return(data)
}

# Normalize international statistics for league quality
normalize_intl_stats <- function(data) {
  data %>%
    left_join(league_coefficients, by = "league") %>%
    mutate(
      # Adjust for league quality and pace
      adj_ppg = intl_ppg * quality_factor / pace_adjustment,
      adj_rpg = intl_rpg * quality_factor,
      adj_apg = intl_apg * quality_factor / pace_adjustment,

      # Create efficiency metrics
      scoring_efficiency = intl_ppg * intl_fg_pct,
      three_point_volume = intl_3pt_attempts * intl_3pt_pct,

      # Age-based development potential
      development_factor = case_when(
        age_at_arrival <= 21 ~ 1.20,
        age_at_arrival <= 23 ~ 1.10,
        age_at_arrival <= 25 ~ 1.00,
        TRUE ~ 0.90
      )
    )
}

# Build translation prediction model
build_translation_model <- function(training_data) {
  # Prepare features for modeling
  model_data <- training_data %>%
    select(
      nba_ppg, nba_rpg, nba_apg,  # Target variables
      adj_ppg, adj_rpg, adj_apg,   # Adjusted international stats
      intl_fg_pct, intl_3pt_pct,   # Shooting percentages
      age_at_arrival, years_to_prime,
      quality_factor, development_factor
    ) %>%
    na.omit()

  # Split into features and targets
  features <- model_data %>%
    select(-starts_with("nba_"))

  # Train separate models for each NBA stat
  models <- list()

  # Points prediction model
  models$ppg <- train(
    x = features,
    y = model_data$nba_ppg,
    method = "rf",
    trControl = trainControl(method = "cv", number = 5),
    tuneGrid = expand.grid(mtry = c(2, 4, 6)),
    importance = TRUE
  )

  # Rebounds prediction model
  models$rpg <- train(
    x = features,
    y = model_data$nba_rpg,
    method = "rf",
    trControl = trainControl(method = "cv", number = 5),
    tuneGrid = expand.grid(mtry = c(2, 4, 6))
  )

  # Assists prediction model
  models$apg <- train(
    x = features,
    y = model_data$nba_apg,
    method = "rf",
    trControl = trainControl(method = "cv", number = 5),
    tuneGrid = expand.grid(mtry = c(2, 4, 6))
  )

  return(models)
}

# Predict NBA performance for international prospects
predict_nba_performance <- function(models, prospect_data) {
  # Normalize prospect data
  normalized_data <- normalize_intl_stats(prospect_data)

  # Prepare features
  features <- normalized_data %>%
    select(adj_ppg, adj_rpg, adj_apg, intl_fg_pct, intl_3pt_pct,
           age_at_arrival, years_to_prime, quality_factor, development_factor)

  # Generate predictions
  predictions <- normalized_data %>%
    mutate(
      predicted_nba_ppg = predict(models$ppg, newdata = features),
      predicted_nba_rpg = predict(models$rpg, newdata = features),
      predicted_nba_apg = predict(models$apg, newdata = features),

      # Calculate confidence intervals (simplified)
      ppg_lower = predicted_nba_ppg * 0.85,
      ppg_upper = predicted_nba_ppg * 1.15,

      # Overall projection grade
      projection_grade = case_when(
        predicted_nba_ppg >= 18 ~ "A - All-Star Potential",
        predicted_nba_ppg >= 14 ~ "B - Starter Quality",
        predicted_nba_ppg >= 10 ~ "C - Rotation Player",
        predicted_nba_ppg >= 6 ~ "D - Deep Bench",
        TRUE ~ "E - Marginal"
      )
    )

  return(predictions)
}

# Success probability model using logistic regression
build_success_classifier <- function(training_data) {
  # Define success as meeting performance threshold
  model_data <- training_data %>%
    mutate(
      success = ifelse(nba_ppg >= 10 | nba_rpg >= 6 | nba_apg >= 4, 1, 0)
    ) %>%
    select(success, adj_ppg, adj_rpg, adj_apg, intl_fg_pct,
           intl_3pt_pct, age_at_arrival, quality_factor) %>%
    na.omit()

  # Logistic regression model
  success_model <- glm(
    success ~ adj_ppg + adj_rpg + adj_apg + intl_fg_pct +
              intl_3pt_pct + age_at_arrival + quality_factor,
    data = model_data,
    family = binomial(link = "logit")
  )

  return(success_model)
}

# Calculate success probability for prospects
predict_success_probability <- function(success_model, prospect_data) {
  normalized_data <- normalize_intl_stats(prospect_data)

  predictions <- normalized_data %>%
    mutate(
      success_probability = predict(success_model, newdata = ., type = "response"),
      success_category = case_when(
        success_probability >= 0.70 ~ "High Probability",
        success_probability >= 0.50 ~ "Moderate Probability",
        success_probability >= 0.30 ~ "Low-Moderate Probability",
        TRUE ~ "Low Probability"
      )
    )

  return(predictions)
}

# Feature importance analysis
analyze_feature_importance <- function(models) {
  # Extract variable importance from PPG model
  importance_df <- varImp(models$ppg)$importance %>%
    as.data.frame() %>%
    rownames_to_column("feature") %>%
    arrange(desc(Overall))

  # Visualization
  ggplot(importance_df, aes(x = reorder(feature, Overall), y = Overall)) +
    geom_bar(stat = "identity", fill = "steelblue") +
    coord_flip() +
    labs(
      title = "Feature Importance for NBA PPG Prediction",
      x = "Feature",
      y = "Importance Score"
    ) +
    theme_minimal()
}

# Compare international stats vs NBA performance
correlation_analysis <- function(data) {
  # Select relevant columns
  cor_data <- data %>%
    select(adj_ppg, adj_rpg, adj_apg, intl_fg_pct, intl_3pt_pct,
           nba_ppg, nba_rpg, nba_apg) %>%
    na.omit()

  # Calculate correlation matrix
  cor_matrix <- cor(cor_data)

  # Visualize
  corrplot(cor_matrix, method = "color", type = "upper",
           tl.col = "black", tl.srt = 45,
           title = "International vs NBA Stats Correlation")

  return(cor_matrix)
}

# Age curve analysis for international players
analyze_age_curves <- function(data) {
  age_performance <- data %>%
    group_by(age_at_arrival) %>%
    summarise(
      avg_nba_ppg = mean(nba_ppg, na.rm = TRUE),
      avg_success_rate = mean(success, na.rm = TRUE),
      n = n()
    ) %>%
    filter(n >= 5)  # Minimum sample size

  # Visualization
  ggplot(age_performance, aes(x = age_at_arrival)) +
    geom_line(aes(y = avg_nba_ppg), color = "blue", size = 1.2) +
    geom_point(aes(y = avg_nba_ppg, size = n), color = "blue") +
    geom_line(aes(y = avg_success_rate * 20), color = "red", size = 1.2) +
    scale_y_continuous(
      name = "Average NBA PPG",
      sec.axis = sec_axis(~./20, name = "Success Rate")
    ) +
    labs(
      title = "NBA Performance by Age at Arrival",
      x = "Age at NBA Arrival"
    ) +
    theme_minimal()
}

# Comprehensive scouting report generator
generate_comprehensive_report <- function(prospect, models, success_model) {
  # Performance predictions
  perf_pred <- predict_nba_performance(models, prospect)
  success_pred <- predict_success_probability(success_model, prospect)

  report <- list(
    player_info = prospect %>% select(player, age_at_arrival, league),
    international_stats = prospect %>% select(starts_with("intl_")),
    nba_projections = perf_pred %>%
      select(predicted_nba_ppg, predicted_nba_rpg, predicted_nba_apg,
             projection_grade),
    success_metrics = success_pred %>%
      select(success_probability, success_category),
    confidence_intervals = perf_pred %>%
      select(ppg_lower, ppg_upper)
  )

  return(report)
}

# Example usage
set.seed(42)

# Simulate training data (in practice, load from database)
training_data <- tibble(
  player = paste0("Player_", 1:100),
  age = sample(19:26, 100, replace = TRUE),
  league = sample(c("EuroLeague", "ACB", "NBL", "Other"), 100, replace = TRUE),
  intl_ppg = rnorm(100, 15, 5),
  intl_rpg = rnorm(100, 5, 2),
  intl_apg = rnorm(100, 3, 1.5),
  intl_fg_pct = runif(100, 0.38, 0.55),
  intl_3pt_pct = runif(100, 0.30, 0.42),
  intl_3pt_attempts = rnorm(100, 4, 1.5),
  nba_ppg = rnorm(100, 10, 4),
  nba_rpg = rnorm(100, 4, 2),
  nba_apg = rnorm(100, 2.5, 1.5)
)

# Build models
normalized_training <- normalize_intl_stats(training_data)
translation_models <- build_translation_model(normalized_training)
success_classifier <- build_success_classifier(normalized_training)

# Analyze a prospect
new_prospect <- tibble(
  player = "Luka Doncic Clone",
  age = 19,
  league = "EuroLeague",
  intl_ppg = 16.0,
  intl_rpg = 4.8,
  intl_apg = 4.3,
  intl_fg_pct = 0.448,
  intl_3pt_pct = 0.308,
  intl_3pt_attempts = 4.5
) %>%
  mutate(age_at_arrival = age)

# Generate report
prospect_report <- generate_comprehensive_report(
  new_prospect,
  translation_models,
  success_classifier
)

print("=== International Prospect Scouting Report ===")
print(prospect_report)