Capstone - Complete Analytics System

# Manager Performance Analysis Framework
import pandas as pd
import numpy as np

# Manager career data
manager_data = pd.DataFrame({
    "manager": ["Manager A"]*3 + ["Manager B"]*3 + ["Manager C"]*3,
    "club": ["Club X"]*3 + ["Club Y", "Club Y", "Club Z"] + ["Club W", "Club W", "Club V"],
    "season": ["2021-22", "2022-23", "2023-24"]*3,
    "matches": [38]*9,
    "wins": [22, 25, 28, 15, 18, 20, 12, 16, 14],
    "draws": [8, 7, 5, 10, 9, 10, 12, 10, 8],
    "losses": [8, 6, 5, 13, 11, 8, 14, 12, 16],
    "goals_for": [68, 75, 82, 52, 58, 62, 45, 50, 48],
    "goals_against": [35, 32, 28, 48, 45, 40, 55, 48, 58],
    "xG_for": [62.5, 70.1, 78.3, 48.2, 55.6, 60.2, 42.1, 52.4, 45.8],
    "xG_against": [38.2, 35.8, 30.5, 50.1, 47.3, 42.8, 52.8, 48.9, 55.2],
    "budget_rank": [3, 2, 1, 8, 7, 5, 12, 10, 15]
})

# Calculate metrics
manager_data["points"] = manager_data["wins"] * 3 + manager_data["draws"]
manager_data["ppg"] = manager_data["points"] / manager_data["matches"]
manager_data["gd"] = manager_data["goals_for"] - manager_data["goals_against"]
manager_data["xgd"] = manager_data["xG_for"] - manager_data["xG_against"]
manager_data["goal_overperformance"] = manager_data["goals_for"] - manager_data["xG_for"]
manager_data["defensive_overperformance"] = manager_data["xG_against"] - manager_data["goals_against"]
manager_data["total_overperformance"] = manager_data["gd"] - manager_data["xgd"]
manager_data["win_rate"] = manager_data["wins"] / manager_data["matches"] * 100

# Career summaries
def weighted_avg(group, value_col, weight_col):
    return np.average(group[value_col], weights=group[weight_col])

career_summary = manager_data.groupby("manager").apply(
    lambda g: pd.Series({
        "seasons": len(g),
        "total_matches": g["matches"].sum(),
        "avg_ppg": weighted_avg(g, "ppg", "matches"),
        "avg_win_rate": weighted_avg(g, "win_rate", "matches"),
        "avg_budget_rank": g["budget_rank"].mean(),
        "avg_xgd": weighted_avg(g, "xgd", "matches"),
        "avg_overperformance": weighted_avg(g, "total_overperformance", "matches")
    })
).reset_index()

# Resource-adjusted performance
career_summary["resource_adjusted_ppg"] = (
    career_summary["avg_ppg"] * (career_summary["avg_budget_rank"] / 10)
)

career_summary = career_summary.sort_values("avg_ppg", ascending=False)

print("Manager Career Summaries:")
print(career_summary.to_string(index=False))

# Tactical Fingerprint Analysis
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans

# Team tactical metrics by manager
tactical_data = pd.DataFrame({
    "manager": ["Guardiola", "Klopp", "Mourinho", "Arteta", "Conte", "Ancelotti"],
    "possession": [67.2, 58.5, 45.2, 62.8, 48.5, 55.2],
    "ppda": [7.8, 8.2, 12.5, 9.1, 11.2, 10.5],
    "deep_completions": [15.2, 12.8, 8.5, 13.5, 9.2, 11.8],
    "crosses_per_90": [18.5, 22.3, 15.2, 16.8, 20.5, 19.2],
    "shots_from_counter": [8, 18, 22, 12, 25, 15],
    "high_press_pct": [42, 55, 28, 48, 32, 38],
    "avg_pass_length": [14.2, 16.8, 18.5, 15.5, 17.2, 16.2],
    "progressive_passes_p90": [78.5, 65.2, 42.8, 72.1, 48.5, 58.3]
})

class TacticalFingerprint:
    """Analyze manager tactical styles"""

    def __init__(self, data):
        self.data = data
        self.metrics = [c for c in data.columns if c != "manager"]
        self._normalize()

    def _normalize(self):
        """Normalize metrics to 0-100 scale"""
        scaler = MinMaxScaler(feature_range=(0, 100))
        normalized = scaler.fit_transform(self.data[self.metrics])

        self.normalized = self.data[["manager"]].copy()
        for i, metric in enumerate(self.metrics):
            self.normalized[f"{metric}_norm"] = normalized[:, i]

    def get_profile(self, manager_name):
        """Get tactical profile for a manager"""
        profile = self.normalized[self.normalized["manager"] == manager_name]
        return profile.iloc[0]

    def compare_managers(self, manager1, manager2):
        """Compare tactical profiles of two managers"""
        p1 = self.get_profile(manager1)
        p2 = self.get_profile(manager2)

        comparison = []
        for metric in self.metrics:
            norm_metric = f"{metric}_norm"
            comparison.append({
                "metric": metric,
                manager1: p1[norm_metric],
                manager2: p2[norm_metric],
                "difference": p1[norm_metric] - p2[norm_metric]
            })

        return pd.DataFrame(comparison)

    def cluster_styles(self, n_clusters=3):
        """Cluster managers by tactical style"""
        norm_cols = [c for c in self.normalized.columns if c.endswith("_norm")]
        X = self.normalized[norm_cols].values

        kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
        clusters = kmeans.fit_predict(X)

        self.normalized["style_cluster"] = clusters

        # Label clusters based on characteristics
        cluster_labels = {}
        for i in range(n_clusters):
            cluster_data = self.normalized[self.normalized["style_cluster"] == i]
            avg_possession = cluster_data["possession_norm"].mean()
            avg_counter = cluster_data["shots_from_counter_norm"].mean()

            if avg_possession > 60:
                cluster_labels[i] = "Possession-based"
            elif avg_counter > 60:
                cluster_labels[i] = "Counter-attacking"
            else:
                cluster_labels[i] = "Balanced"

        self.normalized["style_label"] = self.normalized["style_cluster"].map(cluster_labels)

        return self.normalized[["manager", "style_cluster", "style_label"]]


# Analysis
fingerprint = TacticalFingerprint(tactical_data)

# Compare managers
comparison = fingerprint.compare_managers("Guardiola", "Mourinho")
print("Guardiola vs Mourinho Tactical Comparison:")
print(comparison.to_string(index=False))

# Cluster by style
styles = fingerprint.cluster_styles(n_clusters=3)
print("\nManager Style Clusters:")
print(styles.to_string(index=False))

# Manager Impact Estimation
import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression

# Historical data
historical_data = pd.DataFrame({
    "manager": ["Manager A"]*2 + ["Manager B"] + ["Manager C"]*2 + ["Manager D"] +
               ["Manager E"]*2 + ["Manager F"],
    "club": ["Club X"]*3 + ["Club Y"]*3 + ["Club Z"]*3,
    "season": ["2020-21", "2021-22", "2022-23"]*3,
    "squad_value_m": [450, 520, 580, 280, 310, 350, 180, 195, 220],
    "wage_bill_m": [180, 200, 220, 95, 105, 115, 65, 70, 80],
    "points": [74, 86, 75, 58, 65, 52, 45, 55, 62],
    "xG_for": [58.5, 72.3, 65.2, 48.2, 55.8, 45.1, 38.5, 48.2, 52.8],
    "xG_against": [42.1, 32.5, 38.8, 52.3, 48.1, 55.2, 58.2, 52.1, 45.5]
})

class ManagerImpactAnalyzer:
    """Estimate manager impact on team performance"""

    def __init__(self, data):
        self.data = data.copy()
        self._calculate_metrics()

    def _calculate_metrics(self):
        """Calculate resource index and expected points"""
        self.data["resource_index"] = (
            self.data["squad_value_m"] + self.data["wage_bill_m"] * 2
        ) / 3

        # Fit resource -> points model
        X = self.data[["resource_index"]].values
        y = self.data["points"].values

        self.model = LinearRegression()
        self.model.fit(X, y)

        self.data["expected_points"] = self.model.predict(X)
        self.data["points_above_expected"] = (
            self.data["points"] - self.data["expected_points"]
        )

    def get_manager_impact(self):
        """Summarize manager impact"""
        impact = self.data.groupby("manager").agg({
            "season": "count",
            "resource_index": "mean",
            "points": "mean",
            "expected_points": "mean",
            "points_above_expected": ["mean", "sum"]
        }).reset_index()

        impact.columns = ["manager", "seasons", "avg_resources", "avg_points",
                         "avg_expected_points", "avg_above_expected", "total_above_expected"]

        return impact.sort_values("avg_above_expected", ascending=False)

    def before_after_analysis(self, club_name):
        """Analyze before/after for manager changes at a club"""
        club_data = self.data[self.data["club"] == club_name].sort_values("season")

        # Identify manager changes
        club_data["manager_change"] = club_data["manager"] != club_data["manager"].shift(1)
        club_data["period"] = club_data["manager_change"].cumsum()

        # Summarize by period
        period_summary = club_data.groupby(["manager", "period"]).agg({
            "points": "mean",
            "expected_points": "mean",
            "points_above_expected": "mean"
        }).reset_index()

        return period_summary

    def rank_managers(self, min_seasons=2):
        """Rank managers by impact, filtered by minimum tenure"""
        impact = self.get_manager_impact()
        qualified = impact[impact["seasons"] >= min_seasons]
        return qualified.sort_values("avg_above_expected", ascending=False)


# Analysis
analyzer = ManagerImpactAnalyzer(historical_data)

print("Manager Impact (Points Above Resource Expectation):")
print(analyzer.get_manager_impact().to_string(index=False))

print("\nClub X Before/After Manager Changes:")
print(analyzer.before_after_analysis("Club X").to_string(index=False))

# Substitution Analytics
import pandas as pd
import numpy as np

# Substitution data
substitutions = pd.DataFrame({
    "match_id": [1, 1, 2, 3, 3, 4],
    "manager": ["Manager A"]*3 + ["Manager B"]*3,
    "minute": [62, 75, 55, 70, 82, 88],
    "player_off": ["Player X", "Player Z", "Player V", "Player A", "Player C", "Player E"],
    "player_on": ["Player Y", "Player W", "Player U", "Player B", "Player D", "Player F"],
    "score_diff": [-1, 0, 1, 0, 0, -1],
    "xG_diff_before": [-0.8, 0.2, 1.2, -0.3, 0.1, -0.5],
    "xG_diff_after": [0.5, 0.3, 0.8, 0.2, 0.4, -0.2],
    "result_change": ["improved", "maintained", "declined", "improved", "improved", "improved"]
})

class InGameAnalytics:
    """Analyze in-game management decisions"""

    def __init__(self, sub_data):
        self.subs = sub_data

    def substitution_effectiveness(self):
        """Analyze substitution effectiveness by manager"""
        effectiveness = self.subs.groupby("manager").apply(
            lambda g: pd.Series({
                "total_subs": len(g),
                "avg_minute": g["minute"].mean(),
                "improved_pct": (g["result_change"] == "improved").mean() * 100,
                "when_losing": (g["score_diff"] < 0).sum(),
                "when_losing_improved": (
                    (g["score_diff"] < 0) & (g["result_change"] == "improved")
                ).sum()
            })
        ).reset_index()

        effectiveness["losing_success_rate"] = (
            effectiveness["when_losing_improved"] /
            effectiveness["when_losing"].replace(0, np.nan) * 100
        )

        return effectiveness

    def timing_analysis(self):
        """Analyze substitution timing patterns"""
        subs = self.subs.copy()

        def timing_bucket(minute):
            if minute < 60: return "Early (< 60)"
            elif minute < 75: return "Mid (60-75)"
            elif minute < 85: return "Late (75-85)"
            return "Very Late (85+)"

        subs["timing_bucket"] = subs["minute"].apply(timing_bucket)

        timing = subs.groupby(["manager", "timing_bucket"]).agg({
            "match_id": "count",
            "result_change": lambda x: (x == "improved").mean() * 100
        }).reset_index()

        timing.columns = ["manager", "timing_bucket", "count", "success_rate"]
        return timing

    def analyze_situational_changes(self):
        """Analyze substitutions by game situation"""
        situations = {
            "winning": self.subs[self.subs["score_diff"] > 0],
            "drawing": self.subs[self.subs["score_diff"] == 0],
            "losing": self.subs[self.subs["score_diff"] < 0]
        }

        analysis = []
        for situation, data in situations.items():
            if len(data) > 0:
                analysis.append({
                    "situation": situation,
                    "count": len(data),
                    "avg_minute": data["minute"].mean(),
                    "success_rate": (data["result_change"] == "improved").mean() * 100
                })

        return pd.DataFrame(analysis)


# Analysis
analyzer = InGameAnalytics(substitutions)

print("Substitution Effectiveness by Manager:")
print(analyzer.substitution_effectiveness().to_string(index=False))

print("\nSubstitution Timing Analysis:")
print(analyzer.timing_analysis().to_string(index=False))

print("\nSituational Analysis:")
print(analyzer.analyze_situational_changes().to_string(index=False))

# Player Development Analysis
import pandas as pd
import numpy as np

# Player trajectories
player_trajectories = pd.DataFrame({
    "player": ["Player A"]*3 + ["Player B"]*3 + ["Player C"]*3,
    "manager": ["Manager X", "Manager X", "Manager Y",
                "Manager X", "Manager X", "Manager X",
                "Manager Y", "Manager Y", "Manager Z"],
    "season": ["2021-22", "2022-23", "2023-24"]*3,
    "age": [23, 24, 25, 21, 22, 23, 26, 27, 28],
    "xG_p90": [0.35, 0.42, 0.38, 0.15, 0.28, 0.35, 0.45, 0.42, 0.38],
    "xA_p90": [0.18, 0.22, 0.20, 0.12, 0.18, 0.25, 0.28, 0.25, 0.22],
    "press_p90": [22.5, 25.8, 23.2, 18.5, 24.2, 28.5, 20.1, 19.8, 18.2],
    "prog_passes_p90": [5.2, 6.1, 5.8, 4.2, 5.8, 7.2, 6.5, 6.2, 5.8]
})

class PlayerDevelopmentAnalyzer:
    """Analyze player development under different managers"""

    def __init__(self, trajectories):
        self.data = trajectories.sort_values(["player", "season"])
        self._calculate_growth()

    def _calculate_growth(self):
        """Calculate season-over-season growth rates"""
        df = self.data.copy()

        for metric in ["xG_p90", "xA_p90", "press_p90"]:
            df[f"{metric}_growth"] = df.groupby("player")[metric].pct_change() * 100

        self.data = df

    def manager_development_scores(self):
        """Calculate development scores by manager"""
        growth_data = self.data.dropna(subset=["xG_p90_growth"])

        scores = growth_data.groupby("manager").agg({
            "player": "nunique",
            "xG_p90_growth": "mean",
            "xA_p90_growth": "mean",
            "press_p90_growth": "mean"
        }).reset_index()

        scores.columns = ["manager", "players_developed", "avg_xG_growth",
                         "avg_xA_growth", "avg_press_growth"]

        scores["development_score"] = (
            scores["avg_xG_growth"] + scores["avg_xA_growth"] + scores["avg_press_growth"]
        ) / 3

        return scores.sort_values("development_score", ascending=False)

    def age_adjusted_development(self):
        """Calculate age-adjusted development scores"""
        growth_data = self.data.dropna(subset=["xG_p90_growth"]).copy()

        # Expected improvement by age
        def expected_improvement(age):
            if age < 23: return 10
            elif age < 26: return 5
            elif age < 29: return 0
            return -5

        growth_data["expected"] = growth_data["age"].apply(expected_improvement)
        growth_data["adjusted_growth"] = growth_data["xG_p90_growth"] - growth_data["expected"]

        adjusted = growth_data.groupby("manager").agg({
            "adjusted_growth": "mean"
        }).reset_index()

        adjusted.columns = ["manager", "avg_adjusted_growth"]

        return adjusted.sort_values("avg_adjusted_growth", ascending=False)


# Analysis
analyzer = PlayerDevelopmentAnalyzer(player_trajectories)

print("Manager Player Development Scores:")
print(analyzer.manager_development_scores().to_string(index=False))

print("\nAge-Adjusted Development:")
print(analyzer.age_adjusted_development().to_string(index=False))

# Python: Manager Sacking Analysis
import pandas as pd
import numpy as np
from typing import Dict
from dataclasses import dataclass

@dataclass
class SackingDecision:
    """Result of sacking decision analysis."""
    ppg_gap: float
    xg_concerning: bool
    recommendation: str
    confidence: str
    reasoning: str

class SackingAnalyzer:
    """Analyze manager sacking timing and outcomes."""

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

    def _analyze_outcomes(self):
        """Analyze historical sacking outcomes."""

        df = self.data.copy()

        # PPG improvement
        df["ppg_improvement"] = df["ppg_after"] - df["ppg_at_sacking"]
        df["improved_ppg"] = df["ppg_improvement"] > 0

        # Position improvement
        df["position_improvement"] = df["position_at_sacking"] - df["final_position"]
        df["improved_position"] = df["position_improvement"] > 0

        # Overall success
        df["sacking_successful"] = df["improved_ppg"] & df["improved_position"]

        # Timing assessment
        def timing_category(matches):
            if matches < 10: return "Too early"
            elif matches < 15: return "Standard timing"
            elif matches < 20: return "Patient approach"
            return "Very late"

        df["timing_category"] = df["matches"].apply(timing_category)

        self.analyzed = df

    def timing_success_rates(self) -> pd.DataFrame:
        """Calculate success rates by sacking timing."""

        return self.analyzed.groupby("timing_category").agg({
            "club": "count",
            "sacking_successful": "mean",
            "ppg_improvement": "mean"
        }).reset_index().rename(columns={
            "club": "sackings",
            "sacking_successful": "success_rate",
            "ppg_improvement": "avg_ppg_improvement"
        })

    def should_sack(self, current_ppg: float, xg_diff: float,
                   matches_played: int, position: int,
                   league_size: int = 20) -> SackingDecision:
        """Recommend whether to sack manager."""

        # Expected PPG for position
        expected_ppg = 38 / league_size

        # Metrics
        ppg_gap = expected_ppg - current_ppg
        xg_concerning = xg_diff < -0.3
        relegation_risk = position > (league_size - 3)

        # Decision logic
        if ppg_gap > 0.5 and xg_concerning and matches_played > 10:
            recommendation = "Sack now"
            confidence = "High"
            reasoning = "Significant underperformance with poor underlying numbers"
        elif ppg_gap > 0.3 and xg_concerning:
            recommendation = "Consider sacking"
            confidence = "Medium"
            reasoning = "Moderate underperformance with concerning xG"
        elif relegation_risk and ppg_gap > 0.2:
            recommendation = "Sack now (survival mode)"
            confidence = "High"
            reasoning = "Relegation zone with negative trajectory"
        elif ppg_gap > 0.5 and not xg_concerning:
            recommendation = "Monitor closely"
            confidence = "Low"
            reasoning = "Results poor but underlying metrics acceptable"
        else:
            recommendation = "Retain manager"
            confidence = "Medium"
            reasoning = "Performance within acceptable range"

        return SackingDecision(
            ppg_gap=ppg_gap,
            xg_concerning=xg_concerning,
            recommendation=recommendation,
            confidence=confidence,
            reasoning=reasoning
        )

    def calculate_cost_of_sacking(self, remaining_contract_months: int,
                                  monthly_salary: float,
                                  new_manager_fee: float) -> Dict:
        """Calculate financial cost of sacking decision."""

        severance = remaining_contract_months * monthly_salary * 0.8  # Typical settlement
        total_cost = severance + new_manager_fee

        return {
            "severance_estimate": severance,
            "hiring_cost": new_manager_fee,
            "total_cost": total_cost,
            "monthly_burden": total_cost / 12
        }


# Example usage
sacking_data = pd.DataFrame({
    "club": ["Club A", "Club B", "Club C"],
    "manager": ["Manager 1", "Manager 2", "Manager 3"],
    "matches": [12, 15, 18],
    "ppg_at_sacking": [1.08, 0.93, 1.22],
    "xg_diff": [-0.3, -0.5, -0.2],
    "ppg_after": [1.52, 1.35, 1.18],
    "position_at_sacking": [15, 18, 12],
    "final_position": [10, 14, 13]
})

analyzer = SackingAnalyzer(sacking_data)

# Example decision
decision = analyzer.should_sack(
    current_ppg=1.0,
    xg_diff=-0.4,
    matches_played=12,
    position=15
)

print("Sacking Decision Analysis:")
print(f"  PPG Gap: {decision.ppg_gap:.2f}")
print(f"  xG Concerning: {decision.xg_concerning}")
print(f"  Recommendation: {decision.recommendation}")
print(f"  Reasoning: {decision.reasoning}")

# Python: Manager Hiring Analysis
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class SquadProfile:
    """Profile of squad characteristics."""
    avg_age: float
    young_players: int
    peak_players: int
    technical_avg: float
    physical_avg: float
    pace_avg: float
    recommended_style: str

@dataclass
class ManagerCandidate:
    """Manager candidate profile."""
    name: str
    preferred_style: str
    pressing_intensity: str
    possession_avg: float
    youth_dev_score: int
    tactical_flexibility: int
    experience_level: str
    available: bool

class ManagerHiringAnalyzer:
    """Analyze and rank manager candidates for a club."""

    def __init__(self, squad_data: pd.DataFrame):
        self.squad = squad_data
        self.squad_profile = self._analyze_squad()

    def _analyze_squad(self) -> SquadProfile:
        """Analyze squad to determine ideal manager profile."""

        df = self.squad

        avg_age = df["age"].mean()
        young = (df["age"] < 23).sum()
        peak = ((df["age"] >= 23) & (df["age"] <= 29)).sum()
        technical = df["technical_skill"].mean()
        physical = df["physical_rating"].mean()
        pace = df["pace"].mean()

        # Recommend style based on squad
        if pace > 75 and (df["position"] == "W").sum() >= 2:
            style = "Counter-attacking"
        elif technical > 80:
            style = "Possession-based"
        elif physical > 78:
            style = "Direct/Physical"
        elif young > 5:
            style = "Development-focused"
        else:
            style = "Flexible"

        return SquadProfile(
            avg_age=avg_age,
            young_players=young,
            peak_players=peak,
            technical_avg=technical,
            physical_avg=physical,
            pace_avg=pace,
            recommended_style=style
        )

    def calculate_match_score(self, candidate: Dict,
                             priorities: Dict) -> float:
        """Calculate how well a candidate matches club needs."""

        score = 0
        profile = self.squad_profile

        # Style match
        if candidate["preferred_style"] == profile.recommended_style:
            score += 25
        elif candidate["tactical_flexibility"] > 70:
            score += 15

        # Youth development
        if profile.young_players > 5 and candidate["youth_dev_score"] > 70:
            score += 20

        # Experience
        if priorities.get("needs_experienced", False):
            if candidate["experience_level"] in ["Experienced", "Very Experienced"]:
                score += 20

        # Availability
        if candidate["available"]:
            score += 15

        # Pressing match
        if profile.physical_avg > 75 and candidate["pressing_intensity"] == "Very High":
            score += 10

        # Tactical flexibility bonus
        score += candidate["tactical_flexibility"] * 0.1

        return score

    def rank_candidates(self, candidates: List[Dict],
                       priorities: Dict) -> pd.DataFrame:
        """Rank all candidates by match score."""

        results = []
        for candidate in candidates:
            score = self.calculate_match_score(candidate, priorities)
            results.append({
                "manager": candidate["name"],
                "preferred_style": candidate["preferred_style"],
                "experience": candidate["experience_level"],
                "available": candidate["available"],
                "match_score": score
            })

        return pd.DataFrame(results).sort_values("match_score", ascending=False)

    def generate_shortlist(self, candidates: List[Dict],
                          priorities: Dict, top_n: int = 3) -> pd.DataFrame:
        """Generate shortlist of top candidates."""

        ranked = self.rank_candidates(candidates, priorities)
        shortlist = ranked.head(top_n)

        # Add reasoning for each
        reasons = []
        for _, row in shortlist.iterrows():
            reason = f"Score: {row['match_score']:.1f} - "
            if row["preferred_style"] == self.squad_profile.recommended_style:
                reason += "Style match; "
            if row["available"]:
                reason += "Available; "
            if row["experience"] in ["Experienced", "Very Experienced"]:
                reason += "Experienced; "
            reasons.append(reason.rstrip("; "))

        shortlist["reasoning"] = reasons
        return shortlist


# Example usage
squad_data = pd.DataFrame({
    "player": [f"Player {i}" for i in range(20)],
    "age": np.random.randint(19, 34, 20),
    "position": np.random.choice(["GK", "CB", "FB", "CM", "W", "ST"], 20),
    "technical_skill": np.random.randint(65, 90, 20),
    "physical_rating": np.random.randint(65, 85, 20),
    "pace": np.random.randint(60, 90, 20)
})

analyzer = ManagerHiringAnalyzer(squad_data)

candidates = [
    {"name": "Candidate A", "preferred_style": "Possession-based",
     "pressing_intensity": "Medium", "youth_dev_score": 75,
     "tactical_flexibility": 60, "experience_level": "Experienced", "available": True},
    {"name": "Candidate B", "preferred_style": "Counter-attacking",
     "pressing_intensity": "Very High", "youth_dev_score": 55,
     "tactical_flexibility": 80, "experience_level": "Very Experienced", "available": True},
    {"name": "Candidate C", "preferred_style": "Development-focused",
     "pressing_intensity": "Medium", "youth_dev_score": 90,
     "tactical_flexibility": 70, "experience_level": "Developing", "available": True}
]

priorities = {"needs_experienced": True}
shortlist = analyzer.generate_shortlist(candidates, priorities)

print(f"Squad Profile: {analyzer.squad_profile.recommended_style} style recommended")
print(f"\nCandidate Shortlist:")
print(shortlist.to_string(index=False))

# Python: Coaching Staff Analysis
import pandas as pd
import numpy as np
from typing import Dict, List

class CoachingStaffAnalyzer:
    """Analyze contribution of coaching staff members."""

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

    def set_piece_coach_analysis(self) -> pd.DataFrame:
        """Analyze set piece coach effectiveness."""

        sp_analysis = self.data.groupby("set_piece_coach").agg({
            "season": "count",
            "club": "nunique",
            "set_piece_goals_for": "mean",
            "set_piece_goals_against": "mean",
            "total_goals_for": "mean"
        }).reset_index()

        sp_analysis.columns = ["set_piece_coach", "seasons", "clubs",
                              "avg_sp_for", "avg_sp_against", "avg_total"]

        sp_analysis["sp_net"] = sp_analysis["avg_sp_for"] - sp_analysis["avg_sp_against"]
        sp_analysis["sp_pct"] = sp_analysis["avg_sp_for"] / sp_analysis["avg_total"] * 100

        return sp_analysis.sort_values("sp_net", ascending=False)

    def continuity_analysis(self) -> pd.DataFrame:
        """Analyze impact of coaching staff continuity."""

        df = self.data.sort_values(["club", "season"]).copy()

        # Track changes
        df["prev_manager"] = df.groupby("club")["manager"].shift(1)
        df["prev_assistant"] = df.groupby("club")["assistant"].shift(1)

        df["manager_changed"] = df["manager"] != df["prev_manager"]
        df["assistant_continuity"] = df["assistant"] == df["prev_assistant"]

        # Categorize scenarios
        def categorize(row):
            if pd.isna(row["prev_manager"]):
                return None
            if not row["manager_changed"]:
                return "Stability"
            elif row["assistant_continuity"]:
                return "New manager, same assistant"
            else:
                return "Complete change"

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

        # Analyze by scenario
        scenarios = df.dropna(subset=["scenario"]).groupby("scenario").agg({
            "club": "count",
            "total_goals_for": "mean"
        }).reset_index()

        scenarios.columns = ["scenario", "cases", "avg_goals"]
        return scenarios

    def coach_value(self, coach_name: str, role: str = "assistant") -> Dict:
        """Calculate value metrics for a specific coach."""

        if role == "assistant":
            coached = self.data[self.data["assistant"] == coach_name]
        elif role == "set_piece":
            coached = self.data[self.data["set_piece_coach"] == coach_name]
        else:
            return {"error": "Invalid role"}

        if len(coached) == 0:
            return {"error": "Coach not found"}

        return {
            "coach": coach_name,
            "role": role,
            "clubs": coached["club"].nunique(),
            "seasons": len(coached),
            "managers_worked_with": coached["manager"].nunique(),
            "avg_goals": coached["total_goals_for"].mean()
        }

    def assistant_manager_pairs(self) -> pd.DataFrame:
        """Analyze successful manager-assistant pairings."""

        pairs = self.data.groupby(["manager", "assistant"]).agg({
            "season": "count",
            "total_goals_for": "mean",
            "set_piece_goals_for": "mean"
        }).reset_index()

        pairs.columns = ["manager", "assistant", "seasons_together",
                        "avg_goals", "avg_sp_goals"]

        return pairs.sort_values("avg_goals", ascending=False)


# Example usage
staff_data = pd.DataFrame({
    "season": ["2022-23", "2023-24", "2022-23", "2023-24"],
    "club": ["Club A", "Club A", "Club B", "Club B"],
    "manager": ["Manager 1", "Manager 1", "Manager 2", "Manager 3"],
    "assistant": ["Assistant A", "Assistant A", "Assistant B", "Assistant B"],
    "set_piece_coach": ["SP Coach X", "SP Coach X", "SP Coach Y", "SP Coach Y"],
    "set_piece_goals_for": [15, 18, 8, 10],
    "set_piece_goals_against": [8, 6, 12, 10],
    "total_goals_for": [68, 72, 52, 55]
})

analyzer = CoachingStaffAnalyzer(staff_data)

print("Set Piece Coach Analysis:")
print(analyzer.set_piece_coach_analysis().to_string(index=False))

print("\nCoaching Continuity Impact:")
print(analyzer.continuity_analysis().to_string(index=False))

# Python: Complete Manager Analytics Pipeline
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from lifelines import KaplanMeierFitter
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple

@dataclass
class ManagerAnalyticsConfig:
    """Configuration for manager analytics pipeline."""
    min_matches_fingerprint: int = 30
    min_matches_resource: int = 20
    n_style_clusters: int = 5
    fingerprint_metrics: List[str] = None

    def __post_init__(self):
        if self.fingerprint_metrics is None:
            self.fingerprint_metrics = [
                "possession_pct", "ppda", "defensive_line_height",
                "build_up_pct", "direct_play_pct", "pressing_triggers",
                "avg_formation_width", "transition_speed"
            ]

class ManagerAnalyticsPipeline:
    """Complete manager analytics system."""

    def __init__(self, config: ManagerAnalyticsConfig = None):
        self.config = config or ManagerAnalyticsConfig()
        self.scaler = StandardScaler()
        self.kmeans = None
        self.results = {}

    def fit(self, matches_df: pd.DataFrame, managers_df: pd.DataFrame,
            staff_df: pd.DataFrame) -> "ManagerAnalyticsPipeline":
        """Run full analytics pipeline."""

        # 1. Tactical fingerprinting
        self.results["fingerprints"] = self._compute_fingerprints(matches_df)

        # 2. Resource-adjusted performance
        self.results["resource_adjusted"] = self._compute_resource_adjusted(matches_df)

        # 3. Tenure survival analysis
        self.results["tenure_survival"] = self._compute_tenure_survival(managers_df)

        # 4. Staff continuity impact
        self.results["staff_impact"] = self._compute_staff_impact(staff_df)

        # 5. Generate summary
        self.results["summary"] = self._generate_summary(matches_df)

        return self

    def _compute_fingerprints(self, df: pd.DataFrame) -> pd.DataFrame:
        """Compute tactical fingerprints for each manager."""

        metrics = self.config.fingerprint_metrics
        available = [m for m in metrics if m in df.columns]

        # Aggregate by manager
        profiles = df.groupby("manager")[available].mean().reset_index()
        profiles = profiles[profiles["manager"].map(
            df.groupby("manager").size() >= self.config.min_matches_fingerprint
        )]

        if len(profiles) < 2:
            return pd.DataFrame()

        # Scale and cluster
        scaled = self.scaler.fit_transform(profiles[available])

        n_clusters = min(self.config.n_style_clusters, len(profiles))
        self.kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=25)
        profiles["style_cluster"] = self.kmeans.fit_predict(scaled)

        cluster_labels = ["Possession", "High Press", "Counter", "Balanced", "Defensive"]
        profiles["style_label"] = profiles["style_cluster"].map(
            lambda x: cluster_labels[x % len(cluster_labels)]
        )

        return profiles

    def _compute_resource_adjusted(self, df: pd.DataFrame) -> pd.DataFrame:
        """Compute resource-adjusted performance metrics."""

        # Simple resource adjustment
        if "wage_rank" not in df.columns:
            df["wage_rank"] = 10  # default middle rank

        df["expected_ppg"] = 3 - (df["wage_rank"] - 1) * 0.1  # rough expected
        df["residual"] = df.get("points", df.get("ppg", 1.5)) - df["expected_ppg"]

        adjusted = df.groupby("manager").agg({
            "residual": "mean",
            "manager": "count"
        }).reset_index(drop=True)

        adjusted.columns = ["avg_residual", "matches"]
        adjusted["manager"] = df.groupby("manager").first().index

        return adjusted.sort_values("avg_residual", ascending=False)

    def _compute_tenure_survival(self, df: pd.DataFrame) -> Dict:
        """Survival analysis for manager tenure."""

        if "tenure_days" not in df.columns:
            return {"status": "insufficient data"}

        kmf = KaplanMeierFitter()

        results = {}
        for level in df["resource_level"].unique():
            subset = df[df["resource_level"] == level]
            if len(subset) >= 10:
                kmf.fit(
                    subset["tenure_days"],
                    event_observed=subset["was_sacked"]
                )
                results[level] = {
                    "median_tenure": kmf.median_survival_time_,
                    "survival_6m": kmf.survival_function_at_times([180]).values[0],
                    "n": len(subset)
                }

        return results

    def _compute_staff_impact(self, df: pd.DataFrame) -> pd.DataFrame:
        """Analyze coaching staff continuity impact."""

        if "assistant_retained" not in df.columns:
            return pd.DataFrame()

        impact = df.groupby("assistant_retained").agg({
            "first_season_points": ["mean", "std", "count"],
            "survived_relegation": "mean"
        }).reset_index()

        impact.columns = ["retained", "avg_points", "std_points",
                         "n_cases", "survival_rate"]

        return impact

    def _generate_summary(self, df: pd.DataFrame) -> Dict:
        """Generate pipeline summary."""

        return {
            "total_managers": df["manager"].nunique(),
            "total_matches": len(df),
            "style_distribution": self.results.get("fingerprints", pd.DataFrame())[
                "style_label"
            ].value_counts().to_dict() if "fingerprints" in self.results else {},
            "pipeline_status": "complete"
        }

    def get_manager_report(self, manager_name: str) -> Dict:
        """Generate individual manager report."""

        report = {"manager": manager_name}

        # Get fingerprint
        if "fingerprints" in self.results:
            fp = self.results["fingerprints"]
            if manager_name in fp["manager"].values:
                row = fp[fp["manager"] == manager_name].iloc[0]
                report["style"] = row["style_label"]

        # Get resource-adjusted
        if "resource_adjusted" in self.results:
            ra = self.results["resource_adjusted"]
            if manager_name in ra["manager"].values:
                row = ra[ra["manager"] == manager_name].iloc[0]
                report["resource_adjusted_ppg"] = round(row["avg_residual"], 3)
                report["matches_analyzed"] = int(row["matches"])

        return report


# Example usage
config = ManagerAnalyticsConfig(
    min_matches_fingerprint=25,
    n_style_clusters=4
)

pipeline = ManagerAnalyticsPipeline(config)

print("Manager Analytics Pipeline Initialized")
print(f"Fingerprint metrics: {config.fingerprint_metrics}")
print(f"Style clusters: {config.n_style_clusters}")
print("\nReady to process match, manager, and staff data")