Capstone - Complete Analytics System

# Analyzing Fixture Congestion
import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Sample fixture data
fixtures = pd.DataFrame({
    "date": ["2024-08-17", "2024-08-24", "2024-08-28", "2024-08-31",
             "2024-09-14", "2024-09-17", "2024-09-21", "2024-09-24", "2024-09-28"],
    "competition": ["Premier League", "Premier League", "League Cup", "Premier League",
                    "Premier League", "Champions League", "Premier League",
                    "League Cup", "Premier League"],
    "opponent": ["Chelsea", "Brighton", "Fulham", "Newcastle", "Everton",
                 "AC Milan", "Bournemouth", "West Ham", "Wolves"],
    "location": ["Home", "Away", "Home", "Home", "Away", "Away", "Home", "Away", "Away"],
    "result": ["W", "W", "W", "D", "W", "W", "W", "W", "L"]
})

# Convert dates
fixtures["date"] = pd.to_datetime(fixtures["date"])

# Calculate rest days
fixtures["days_since_last"] = fixtures["date"].diff().dt.days
fixtures["days_to_next"] = fixtures["date"].diff(-1).dt.days.abs()

# Categorize rest periods
def categorize_rest(days):
    if pd.isna(days):
        return "N/A"
    elif days <= 3:
        return "Short (<=3 days)"
    elif days <= 5:
        return "Medium (4-5 days)"
    elif days <= 7:
        return "Normal (6-7 days)"
    else:
        return "Extended (>7 days)"

fixtures["rest_category"] = fixtures["days_since_last"].apply(categorize_rest)

# Month and week
fixtures["month"] = fixtures["date"].dt.month_name()
fixtures["week"] = fixtures["date"].dt.isocalendar().week

# Monthly congestion analysis
monthly_congestion = fixtures.groupby("month").agg({
    "date": "count",
    "days_since_last": ["mean", "min"],
    "competition": "nunique"
}).reset_index()
monthly_congestion.columns = ["month", "matches", "avg_rest", "min_rest", "competitions"]

print("Monthly Fixture Congestion:")
print(monthly_congestion)

# Performance by rest days
def get_points(result):
    return 3 if result == "W" else (1 if result == "D" else 0)

fixtures["points"] = fixtures["result"].apply(get_points)

rest_performance = fixtures[fixtures["days_since_last"].notna()].groupby("rest_category").agg({
    "date": "count",
    "points": "mean",
    "result": lambda x: (x == "W").mean() * 100
}).reset_index()
rest_performance.columns = ["rest_category", "matches", "avg_points", "win_rate"]

print("\nPerformance by Rest Period:")
print(rest_performance)

# Player Workload Tracking System
import pandas as pd
import numpy as np

# Player appearance data
appearances = pd.DataFrame({
    "player": ["Player A"]*6 + ["Player B"]*6,
    "date": ["2024-08-17", "2024-08-24", "2024-08-28", "2024-08-31",
             "2024-09-14", "2024-09-17"] * 2,
    "minutes": [90, 90, 70, 90, 0, 90, 90, 65, 0, 90, 90, 75],
    "competition": ["League", "League", "Cup", "League", "League", "UCL"] * 2,
    "started": [True, True, True, True, False, True,
                True, True, False, True, True, True]
})

appearances["date"] = pd.to_datetime(appearances["date"])

class WorkloadTracker:
    """Track and analyze player workload"""

    def __init__(self, appearances_df):
        self.data = appearances_df.sort_values(["player", "date"])

    def calculate_metrics(self):
        """Calculate comprehensive workload metrics"""
        df = self.data.copy()

        metrics = []
        for player in df["player"].unique():
            player_data = df[df["player"] == player].copy()

            # Rolling minutes
            player_data["minutes_7d"] = player_data["minutes"].rolling(3, min_periods=1).sum()
            player_data["minutes_28d"] = player_data["minutes"].rolling(6, min_periods=1).sum()

            # ACWR
            player_data["acwr"] = player_data["minutes_7d"] / (player_data["minutes_28d"] / 4)

            # Consecutive starts
            player_data["consecutive_starts"] = player_data["started"].groupby(
                (~player_data["started"]).cumsum()
            ).cumsum()

            # Days rest
            player_data["days_rest"] = player_data["date"].diff().dt.days

            # Cumulative minutes
            player_data["season_minutes"] = player_data["minutes"].cumsum()

            metrics.append(player_data)

        return pd.concat(metrics)

    def get_current_status(self):
        """Get current workload status for all players"""
        metrics = self.calculate_metrics()

        current = metrics.groupby("player").last().reset_index()

        # Risk assessment
        def assess_fatigue(row):
            if row["acwr"] > 1.5:
                return "High"
            elif row["acwr"] > 1.2:
                return "Medium"
            return "Low"

        def assess_status(row):
            if row["season_minutes"] > 1000 and row["consecutive_starts"] > 4:
                return "Needs Rest"
            elif row["acwr"] > 1.3:
                return "Monitor Closely"
            return "Good"

        current["fatigue_risk"] = current.apply(assess_fatigue, axis=1)
        current["workload_status"] = current.apply(assess_status, axis=1)

        return current[["player", "season_minutes", "minutes_7d",
                       "acwr", "consecutive_starts", "days_rest",
                       "fatigue_risk", "workload_status"]]

    def rotation_recommendation(self):
        """Generate rotation recommendations"""
        status = self.get_current_status()

        priority_map = {"Needs Rest": 1, "Monitor Closely": 2, "Good": 3}
        status["priority"] = status["workload_status"].map(priority_map)

        recommendation_map = {
            1: "Rest recommended",
            2: "Consider rotation",
            3: "Available for selection"
        }
        status["recommendation"] = status["priority"].map(recommendation_map)

        return status.sort_values("priority")


# Usage
tracker = WorkloadTracker(appearances)
current_status = tracker.get_current_status()

print("Current Player Workload Status:")
print(current_status.to_string(index=False))

print("\nRotation Recommendations:")
print(tracker.rotation_recommendation()[["player", "recommendation"]].to_string(index=False))

# Squad Rotation Optimization
import pandas as pd
import numpy as np
from scipy.optimize import milp, LinearConstraint, Bounds

# Squad data
squad_data = {
    "player": ["GK1", "GK2", "CB1", "CB2", "CB3", "CB4", "LB1", "LB2",
               "RB1", "RB2", "CM1", "CM2", "CM3", "CM4", "WG1", "WG2",
               "WG3", "ST1", "ST2"],
    "position": ["GK", "GK", "CB", "CB", "CB", "CB", "LB", "LB",
                 "RB", "RB", "CM", "CM", "CM", "CM", "WG", "WG",
                 "WG", "ST", "ST"],
    "quality": [85, 72, 88, 85, 78, 75, 82, 74, 80, 73, 90, 86, 80, 75, 88, 82, 76, 90, 82],
    "fatigue": [0.2, 0.1, 0.6, 0.3, 0.2, 0.1, 0.5, 0.2, 0.4, 0.2,
                0.7, 0.4, 0.2, 0.1, 0.5, 0.3, 0.2, 0.6, 0.3],
    "form": [80, 75, 82, 85, 78, 72, 80, 76, 78, 74, 88, 84, 80, 72, 86, 80, 74, 88, 80],
    "age": [28, 24, 30, 27, 23, 21, 29, 22, 28, 23, 31, 27, 24, 20, 26, 25, 22, 29, 24],
    "injury_risk": [0.1, 0.1, 0.3, 0.2, 0.1, 0.1, 0.25, 0.1, 0.2, 0.1,
                    0.35, 0.2, 0.15, 0.1, 0.2, 0.15, 0.1, 0.25, 0.15]
}

squad = pd.DataFrame(squad_data)

class RotationOptimizer:
    """Optimize squad rotation for fixture congestion"""

    def __init__(self, squad_df):
        self.squad = squad_df.copy()
        self._calculate_metrics()

    def _calculate_metrics(self):
        """Calculate effective quality metrics"""
        df = self.squad
        df["fatigue_penalty"] = df["fatigue"] * 15
        df["effective_quality"] = df["quality"] - df["fatigue_penalty"] + (df["form"] - 80) * 0.5
        df["match_fitness"] = df["effective_quality"] * (1 - df["injury_risk"])

    def optimize_lineup(self, formation="4-3-3", match_importance="high"):
        """Select optimal XI based on formation and match importance"""

        formations = {
            "4-3-3": {"GK": 1, "CB": 2, "LB": 1, "RB": 1, "CM": 3, "WG": 2, "ST": 1},
            "4-4-2": {"GK": 1, "CB": 2, "LB": 1, "RB": 1, "CM": 4, "WG": 0, "ST": 2},
            "3-5-2": {"GK": 1, "CB": 3, "LB": 0, "RB": 0, "CM": 5, "WG": 0, "ST": 2}
        }

        reqs = formations[formation]

        # Importance weighting
        weights = {"high": 0.8, "medium": 0.5, "low": 0.2}
        w = weights.get(match_importance, 0.5)

        # Selection score
        self.squad["selection_score"] = (
            self.squad["effective_quality"] * w +
            (100 - self.squad["fatigue"] * 100) * (1 - w)
        )

        # Greedy selection by position
        selected = []
        selected_players = set()

        for pos, needed in reqs.items():
            if needed > 0:
                candidates = self.squad[
                    (self.squad["position"] == pos) &
                    (~self.squad["player"].isin(selected_players))
                ].nlargest(needed, "selection_score")

                selected.append(candidates)
                selected_players.update(candidates["player"].tolist())

        return pd.concat(selected).sort_values(
            "position",
            key=lambda x: pd.Categorical(x, ["GK", "CB", "LB", "RB", "CM", "WG", "ST"])
        )

    def weekly_rotation_plan(self, fixtures):
        """Generate rotation plan for upcoming fixtures"""
        plans = []

        for fixture in fixtures:
            lineup = self.optimize_lineup(
                formation=fixture.get("formation", "4-3-3"),
                match_importance=fixture.get("importance", "medium")
            )

            plans.append({
                "match": fixture["opponent"],
                "lineup": lineup["player"].tolist(),
                "avg_quality": lineup["effective_quality"].mean()
            })

            # Update fatigue for selected players
            for player in lineup["player"]:
                idx = self.squad[self.squad["player"] == player].index[0]
                self.squad.loc[idx, "fatigue"] = min(1.0,
                    self.squad.loc[idx, "fatigue"] + 0.15)

            # Rest effect for non-selected
            non_selected = ~self.squad["player"].isin(lineup["player"])
            self.squad.loc[non_selected, "fatigue"] = (
                self.squad.loc[non_selected, "fatigue"] * 0.7
            )

            self._calculate_metrics()

        return plans


# Usage
optimizer = RotationOptimizer(squad)

print("High Importance Match XI:")
high_xi = optimizer.optimize_lineup("4-3-3", "high")
print(high_xi[["player", "position", "effective_quality", "fatigue"]].to_string(index=False))

optimizer2 = RotationOptimizer(squad)  # Fresh instance
print("\nRotation Match XI:")
rotation_xi = optimizer2.optimize_lineup("4-3-3", "low")
print(rotation_xi[["player", "position", "effective_quality", "fatigue"]].to_string(index=False))

# Competition Prioritization Model
import pandas as pd
import numpy as np

# Competition values
competitions = pd.DataFrame({
    "competition": ["Premier League", "Champions League", "FA Cup",
                    "League Cup", "Europa League", "Community Shield"],
    "trophy_value": [100, 100, 70, 40, 60, 20],
    "financial_value": [150, 200, 30, 20, 80, 10],
    "prestige": [95, 100, 80, 50, 70, 30]
})

# Current context
context = pd.DataFrame({
    "competition": ["Premier League", "Champions League", "FA Cup", "League Cup"],
    "current_position": ["3", "QF", "R16", "Out"],
    "matches_remaining": [15, 3, 4, 0]
})

class CompetitionPrioritizer:
    """Calculate dynamic competition priorities"""

    def __init__(self, comp_values, season_context):
        self.comp_values = comp_values
        self.context = season_context

    def calculate_priorities(self):
        """Calculate priority scores for each competition"""
        df = self.comp_values.merge(self.context, on="competition", how="left")

        # Base score
        df["base_score"] = (df["trophy_value"] + df["financial_value"] + df["prestige"]) / 3

        # Position factor
        def position_factor(row):
            if row["competition"] == "Premier League":
                try:
                    pos = int(row["current_position"])
                    if pos <= 4: return 1.3
                    elif pos <= 6: return 1.1
                except: pass
            if row["competition"] == "Champions League" and row["current_position"] == "QF":
                return 1.4
            if row["current_position"] == "Out":
                return 0
            return 1.0

        df["position_factor"] = df.apply(position_factor, axis=1)

        # Proximity bonus
        def proximity_bonus(matches):
            if pd.isna(matches): return 1.0
            if matches <= 3 and matches > 0: return 1.2
            if matches <= 5 and matches > 0: return 1.1
            return 1.0

        df["proximity_bonus"] = df["matches_remaining"].apply(proximity_bonus)

        # Final priority
        df["priority_score"] = df["base_score"] * df["position_factor"] * df["proximity_bonus"]
        df["priority_rank"] = df["priority_score"].rank(ascending=False, method="dense")

        return df.sort_values("priority_rank")

    def match_importance(self, competition, opponent_strength, match_type="regular"):
        """Calculate importance of specific match"""
        priorities = self.calculate_priorities()

        comp_row = priorities[priorities["competition"] == competition]
        if len(comp_row) == 0:
            return 0

        comp_priority = comp_row["priority_score"].values[0]

        # Match type multiplier
        type_mult = {
            "final": 1.5,
            "semifinal": 1.3,
            "knockout": 1.2,
            "title_decider": 1.5,
            "regular": 1.0
        }.get(match_type, 1.0)

        # Opponent factor
        opponent_factor = 0.5 + (opponent_strength / 200)

        return comp_priority * type_mult * opponent_factor


# Usage
prioritizer = CompetitionPrioritizer(competitions, context)
priorities = prioritizer.calculate_priorities()

print("Competition Priority Rankings:")
print(priorities[["competition", "base_score", "priority_score", "priority_rank"]].to_string(index=False))

# Example matches
example_matches = [
    ("Premier League", "Liverpool", 95, "title_decider"),
    ("Champions League", "Bayern", 92, "knockout"),
    ("FA Cup", "Luton", 60, "regular"),
]

print("\nUpcoming Match Importance:")
for comp, opp, strength, mtype in example_matches:
    importance = prioritizer.match_importance(comp, strength, mtype)
    print(f"  {comp} vs {opp}: {importance:.1f}")

# Travel Impact Analysis
import pandas as pd
import numpy as np
from math import radians, sin, cos, sqrt, atan2

# Stadium locations
stadiums = pd.DataFrame({
    "city": ["London", "Manchester", "Liverpool", "Munich",
             "Milan", "Madrid", "Istanbul", "Moscow"],
    "lat": [51.5074, 53.4631, 53.4308, 48.2188,
            45.4781, 40.4530, 41.0370, 55.8166],
    "lon": [-0.1278, -2.2913, -2.9608, 11.6247,
            9.1240, -3.6883, 28.9850, 37.5554],
    "timezone_offset": [0, 0, 0, 1, 1, 1, 3, 3]  # Hours from GMT
})

def haversine_distance(lat1, lon1, lat2, lon2):
    """Calculate distance between two points in km"""
    R = 6371  # Earth radius in km

    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
    c = 2 * atan2(sqrt(a), sqrt(1-a))

    return R * c

class TravelAnalyzer:
    """Analyze travel impact on squad"""

    def __init__(self, stadiums_df):
        self.stadiums = stadiums_df

    def calculate_travel_burden(self, from_city, to_city):
        """Calculate travel burden between cities"""
        from_loc = self.stadiums[self.stadiums["city"] == from_city].iloc[0]
        to_loc = self.stadiums[self.stadiums["city"] == to_city].iloc[0]

        # Distance
        distance = haversine_distance(
            from_loc["lat"], from_loc["lon"],
            to_loc["lat"], to_loc["lon"]
        )

        # Timezone difference
        tz_diff = abs(from_loc["timezone_offset"] - to_loc["timezone_offset"])

        # Travel burden score
        burden = (distance / 500) + (tz_diff * 2)

        return {
            "from": from_city,
            "to": to_city,
            "distance_km": round(distance),
            "timezone_diff": tz_diff,
            "travel_burden": round(burden, 2)
        }

    def analyze_fixtures(self, fixtures_df):
        """Analyze travel burden for fixture list"""
        results = []

        for _, fixture in fixtures_df.iterrows():
            travel = self.calculate_travel_burden(
                fixture["home_city"],
                fixture["away_city"]
            )
            travel["match_date"] = fixture["match_date"]
            travel["competition"] = fixture["competition"]
            results.append(travel)

        df = pd.DataFrame(results)

        # Recovery recommendations
        def recovery_days(burden):
            if burden > 5: return 4
            elif burden > 3: return 3
            elif burden > 1: return 2
            return 1

        def rotation_rec(burden):
            if burden > 5: return "Heavy rotation recommended"
            elif burden > 3: return "Consider rotation"
            return "Normal selection"

        df["recovery_days"] = df["travel_burden"].apply(recovery_days)
        df["rotation_recommendation"] = df["travel_burden"].apply(rotation_rec)

        return df


# Example fixtures
fixtures = pd.DataFrame({
    "match_date": ["2024-09-17", "2024-09-21", "2024-10-01", "2024-10-05"],
    "home_city": ["Munich", "London", "Istanbul", "London"],
    "away_city": ["London", "Manchester", "London", "Liverpool"],
    "competition": ["UCL", "PL", "UCL", "PL"]
})

analyzer = TravelAnalyzer(stadiums)
travel_analysis = analyzer.analyze_fixtures(fixtures)

print("Travel Burden Analysis:")
print(travel_analysis[["match_date", "competition", "from", "to",
                       "distance_km", "travel_burden"]].to_string(index=False))

print("\nRecovery Recommendations:")
print(travel_analysis[["match_date", "to", "recovery_days",
                       "rotation_recommendation"]].to_string(index=False))

# Python: Injury risk prediction model
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, roc_auc_score
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class InjuryRiskAssessment:
    """Assessment result for a player."""
    player_id: str
    injury_probability: float
    risk_level: str
    recommendation: str
    key_factors: List[str]

class InjuryPredictor:
    """Predict injury risk based on workload and player factors."""

    def __init__(self):
        self.model = None
        self.scaler = StandardScaler()
        self.feature_names = [
            "acwr", "cumulative_minutes_28d", "consecutive_starts",
            "days_since_last_match", "age", "previous_injuries",
            "muscle_fatigue_index", "match_intensity", "travel_burden"
        ]

    def generate_training_data(self, n_samples: int = 2000) -> pd.DataFrame:
        """Generate synthetic training data."""

        np.random.seed(42)

        data = pd.DataFrame({
            "player_id": np.repeat(range(50), n_samples // 50),
            "acwr": np.random.normal(1.0, 0.3, n_samples),
            "cumulative_minutes_28d": np.random.normal(450, 150, n_samples),
            "consecutive_starts": np.random.poisson(3, n_samples),
            "days_since_last_match": np.random.choice(range(2, 11), n_samples),
            "age": np.repeat(np.random.choice(range(20, 36), 50), n_samples // 50),
            "previous_injuries": np.repeat(np.random.poisson(1.5, 50), n_samples // 50),
            "muscle_fatigue_index": np.random.normal(50, 15, n_samples),
            "match_intensity": np.random.normal(70, 10, n_samples),
            "travel_burden": np.random.exponential(2, n_samples)
        })

        # Generate injury labels based on features
        log_odds = (
            -3 +
            (data["acwr"] - 1) * 2 +
            (data["cumulative_minutes_28d"] - 450) / 200 +
            data["consecutive_starts"] * 0.1 +
            (data["days_since_last_match"] < 4).astype(int) * 0.5 +
            (data["age"] > 30).astype(int) * 0.3 +
            data["previous_injuries"] * 0.2 +
            data["muscle_fatigue_index"] / 100
        )
        prob = 1 / (1 + np.exp(-log_odds))
        data["injury"] = (np.random.random(n_samples) < prob).astype(int)

        return data

    def train(self, data: pd.DataFrame) -> Dict:
        """Train the injury prediction model."""

        X = data[self.feature_names]
        y = data["injury"]

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

        # Scale features
        X_train_scaled = self.scaler.fit_transform(X_train)
        X_test_scaled = self.scaler.transform(X_test)

        # Train model
        self.model = LogisticRegression(
            class_weight="balanced",
            max_iter=1000
        )
        self.model.fit(X_train_scaled, y_train)

        # Evaluate
        y_pred = self.model.predict(X_test_scaled)
        y_prob = self.model.predict_proba(X_test_scaled)[:, 1]

        return {
            "auc": roc_auc_score(y_test, y_prob),
            "report": classification_report(y_test, y_pred),
            "feature_importance": dict(zip(
                self.feature_names,
                self.model.coef_[0]
            ))
        }

    def assess_risk(self, player_data: pd.DataFrame) -> List[InjuryRiskAssessment]:
        """Assess injury risk for players."""

        if self.model is None:
            raise ValueError("Model not trained")

        X = player_data[self.feature_names]
        X_scaled = self.scaler.transform(X)

        probabilities = self.model.predict_proba(X_scaled)[:, 1]

        assessments = []
        for i, (_, row) in enumerate(player_data.iterrows()):
            prob = probabilities[i]

            # Determine risk level
            if prob > 0.3:
                risk_level = "High"
                recommendation = "REST - Do not play"
            elif prob > 0.15:
                risk_level = "Medium"
                recommendation = "MONITOR - Limited minutes only"
            else:
                risk_level = "Low"
                recommendation = "AVAILABLE - Normal selection"

            # Identify key risk factors
            key_factors = []
            if row["acwr"] > 1.3:
                key_factors.append(f"High ACWR ({row['acwr']:.2f})")
            if row["consecutive_starts"] > 5:
                key_factors.append(f"Many consecutive starts ({row['consecutive_starts']})")
            if row["days_since_last_match"] < 4:
                key_factors.append(f"Short recovery ({row['days_since_last_match']} days)")
            if row["muscle_fatigue_index"] > 70:
                key_factors.append(f"High fatigue ({row['muscle_fatigue_index']:.0f})")

            assessments.append(InjuryRiskAssessment(
                player_id=str(row.get("player_id", i)),
                injury_probability=prob,
                risk_level=risk_level,
                recommendation=recommendation,
                key_factors=key_factors
            ))

        return assessments

    def acwr_zone(self, acwr: float) -> str:
        """Classify ACWR into risk zones."""
        if acwr < 0.8:
            return "Undertraining"
        elif acwr <= 1.3:
            return "Sweet Spot"
        elif acwr <= 1.5:
            return "Danger Zone"
        else:
            return "High Risk"


# Example usage
predictor = InjuryPredictor()

# Train on synthetic data
training_data = predictor.generate_training_data()
results = predictor.train(training_data)

print("Injury Prediction Model Results:")
print(f"AUC: {results['auc']:.3f}")
print("\nFeature Importance:")
for feature, importance in sorted(results["feature_importance"].items(),
                                  key=lambda x: abs(x[1]), reverse=True):
    print(f"  {feature}: {importance:.3f}")

# Python: Youth integration planning
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class YouthPlayer:
    """Youth player profile."""
    name: str
    position: str
    age: int
    quality: int
    potential: int
    experience_level: str
    ready_for: str

class YouthIntegrationPlanner:
    """Plan youth player integration during fixture congestion."""

    def __init__(self, youth_players: pd.DataFrame):
        self.youth = youth_players

    def calculate_development_value(self, match_context: str) -> pd.DataFrame:
        """Calculate development value per 90 minutes in given context."""

        df = self.youth.copy()

        # Base development rate
        df["base_dev_rate"] = (df["potential"] - df["quality"]) / 10

        # Competition multiplier
        comp_mult = {
            "League": 1.5,
            "UCL": 2.0,
            "Cup": 1.2,
            "Friendly": 0.5
        }
        df["comp_mult"] = comp_mult.get(match_context, 1.0)

        # Development value per 90
        df["dev_value_per_90"] = df["base_dev_rate"] * df["comp_mult"]

        # Readiness check
        def is_ready(row):
            if row["experience_level"] == "First team fringe":
                return True
            if row["experience_level"] == "Reserves" and match_context in ["Cup", "League"]:
                return True
            if row["experience_level"] == "Academy" and match_context == "Cup":
                return True
            return False

        df["is_ready"] = df.apply(is_ready, axis=1)

        return df

    def find_integration_windows(self, fixtures: pd.DataFrame) -> pd.DataFrame:
        """Identify matches suitable for youth integration."""

        df = fixtures.copy()

        def is_opportunity(row):
            if row["competition"] == "League Cup":
                return True
            if row["competition"] == "FA Cup" and row.get("round", 4) <= 3:
                return True
            if row.get("importance_score", 50) < 50:
                return True
            if row.get("days_until_key_match", 3) > 5:
                return True
            return False

        df["is_integration_opportunity"] = df.apply(is_opportunity, axis=1)

        def youth_minutes(row):
            if row["is_integration_opportunity"]:
                return 270  # 3 starters
            if row.get("importance_score", 70) < 70:
                return 90  # 1 starter
            return 30  # Late sub

        df["youth_minutes_available"] = df.apply(youth_minutes, axis=1)

        return df[df["is_integration_opportunity"]]

    def create_development_plan(self) -> pd.DataFrame:
        """Create season-long development plan for youth players."""

        df = self.youth.copy()

        # Target minutes by experience level
        target_map = {
            "First team fringe": 1500,
            "Reserves": 800,
            "Academy": 400
        }
        df["season_target"] = df["experience_level"].map(target_map).fillna(200)

        # Preferred competitions
        pref_map = {
            "First team fringe": "League, Cup, UCL groups",
            "Reserves": "Cup, League rotation",
            "Academy": "Cup early rounds"
        }
        df["preferred_comps"] = df["experience_level"].map(pref_map)

        # Integration priority score
        df["priority"] = df["potential"] - df["quality"] + (21 - df["age"]) * 2

        return df.sort_values("priority", ascending=False)

    def recommend_lineup_youth(self, match_info: Dict,
                               first_team_fatigue: pd.DataFrame) -> List[str]:
        """Recommend which youth players to include in lineup."""

        dev_values = self.calculate_development_value(match_info.get("competition", "Cup"))
        ready_youth = dev_values[dev_values["is_ready"]]

        # Sort by development value
        recommended = ready_youth.nlargest(3, "dev_value_per_90")

        return recommended[["name", "position", "dev_value_per_90"]].to_dict("records")


# Example usage
youth_data = pd.DataFrame({
    "name": ["Youth A", "Youth B", "Youth C", "Youth D", "Youth E"],
    "position": ["CM", "RB", "ST", "CB", "WG"],
    "age": [18, 19, 17, 20, 18],
    "quality": [65, 70, 60, 72, 68],
    "potential": [88, 82, 90, 78, 85],
    "experience_level": ["Academy", "Reserves", "Academy", "First team fringe", "Academy"],
    "ready_for": ["Cup", "League rotation", "Late sub", "League starter", "Cup"]
})

planner = YouthIntegrationPlanner(youth_data)
dev_plan = planner.create_development_plan()

print("Youth Development Priority List:")
print(dev_plan[["name", "position", "age", "quality", "potential",
               "priority", "season_target"]].to_string(index=False))

# Python: In-season squad planning system
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List

class InSeasonPlanner:
    """Dynamic in-season squad planning system."""

    def __init__(self, squad_data: pd.DataFrame):
        self.data = squad_data

    def assess_squad_status(self, recent_matches: int = 10) -> pd.DataFrame:
        """Assess current squad status across all players."""

        # Get recent data for each player
        recent = self.data.groupby("player").apply(
            lambda x: x.nlargest(recent_matches, "date")
        ).reset_index(drop=True)

        # Aggregate by player
        status = recent.groupby(["player", "position"]).agg({
            "minutes": ["sum", "mean"],
            "started": "sum",
            "rating": "mean",
            "goals": "sum",
            "assists": "sum",
            "fatigue": "last",
            "date": "max"
        }).reset_index()

        status.columns = ["player", "position", "total_minutes", "avg_minutes",
                         "starts", "avg_rating", "goals", "assists",
                         "current_fatigue", "last_match"]

        # Workload status
        def workload_status(row):
            if row["total_minutes"] > 800 and row["current_fatigue"] > 0.6:
                return "Overworked"
            elif row["total_minutes"] > 700:
                return "High Load"
            elif row["total_minutes"] > 500:
                return "Optimal"
            elif row["total_minutes"] > 300:
                return "Underused"
            return "Minimal Involvement"

        status["workload_status"] = status.apply(workload_status, axis=1)

        # Form status
        def form_status(rating):
            if rating > 7.5: return "Excellent"
            elif rating > 7.0: return "Good"
            elif rating > 6.5: return "Average"
            return "Poor"

        status["form_status"] = status["avg_rating"].apply(form_status)

        # Action required
        def action_needed(row):
            if row["workload_status"] == "Overworked":
                return "Immediate rest needed"
            if row["workload_status"] == "Underused" and row["form_status"] == "Good":
                return "Increase minutes"
            if row["form_status"] == "Poor":
                return "Review/Drop"
            return "Continue current plan"

        status["action"] = status.apply(action_needed, axis=1)

        return status

    def identify_squad_gaps(self) -> pd.DataFrame:
        """Identify positions needing reinforcement."""

        status = self.assess_squad_status()

        position_summary = status.groupby("position").agg({
            "player": "count",
            "workload_status": lambda x: (x != "Overworked").sum(),
            "form_status": lambda x: x.isin(["Excellent", "Good"]).sum(),
            "total_minutes": "std"
        }).reset_index()

        position_summary.columns = ["position", "total_players",
                                    "healthy_available", "in_form", "minutes_spread"]

        # Identify concerns
        position_summary["has_depth_issue"] = position_summary["healthy_available"] < 2
        position_summary["has_form_issue"] = position_summary["in_form"] < 1

        def concern_level(row):
            if row["has_depth_issue"] and row["has_form_issue"]:
                return "Critical"
            elif row["has_depth_issue"] or row["has_form_issue"]:
                return "Moderate"
            elif row["minutes_spread"] > 300:
                return "Minor"
            return "OK"

        position_summary["concern_level"] = position_summary.apply(concern_level, axis=1)

        def recommendation(level):
            if level == "Critical":
                return "Consider January signing"
            elif level == "Moderate":
                return "Promote youth player"
            return "No action needed"

        position_summary["recommendation"] = position_summary["concern_level"].apply(recommendation)

        return position_summary

    def monthly_review(self, month: int, year: int) -> pd.DataFrame:
        """Review squad utilization for a specific month."""

        month_data = self.data[
            (self.data["date"].dt.month == month) &
            (self.data["date"].dt.year == year)
        ]

        review = month_data.groupby("player").agg({
            "match_id": "count",
            "started": "sum",
            "minutes": "sum",
            "rating": "mean"
        }).reset_index()

        review.columns = ["player", "matches_available", "matches_started",
                         "total_minutes", "avg_rating"]

        review["utilization"] = review["matches_started"] / review["matches_available"]

        def classify_utilization(util):
            if util > 0.9: return "Over-relied upon"
            elif util > 0.7: return "Key player"
            elif util > 0.4: return "Rotation option"
            elif util > 0.2: return "Underutilized"
            return "Unused"

        review["status"] = review["utilization"].apply(classify_utilization)

        return review.sort_values("total_minutes", ascending=False)

    def project_remaining_season(self, remaining_matches: int) -> Dict:
        """Project squad capacity for remaining season."""

        status = self.assess_squad_status()

        # Capacity by workload status
        capacity_multiplier = {
            "Optimal": 1.0,
            "Underused": 1.0,
            "High Load": 0.5,
            "Overworked": 0.2,
            "Minimal Involvement": 0.8
        }

        status["capacity"] = status["workload_status"].map(capacity_multiplier)
        status["estimated_available_matches"] = status["capacity"] * remaining_matches * 0.7

        # Position-level summary
        position_capacity = status.groupby("position").agg({
            "estimated_available_matches": "sum",
            "player": "count"
        }).reset_index()

        position_capacity["matches_needed"] = remaining_matches
        position_capacity["coverage_ratio"] = (
            position_capacity["estimated_available_matches"] /
            position_capacity["matches_needed"]
        )
        position_capacity["needs_reinforcement"] = position_capacity["coverage_ratio"] < 1.5

        return {
            "player_projections": status[["player", "position", "capacity",
                                         "estimated_available_matches"]],
            "position_capacity": position_capacity
        }


# Example usage
print("In-Season Squad Planner initialized")
print("Methods: assess_squad_status(), identify_squad_gaps(), monthly_review(), project_remaining_season()")