Capstone - Complete Analytics System

import pandas as pd
import numpy as np
from statsbombpy import sb
import matplotlib.pyplot as plt
from matplotlib.patches import Arc, Rectangle, Circle
from datetime import datetime
import warnings
warnings.filterwarnings('ignore')

class MatchReportGenerator:
    """Automated match report generator with multiple output formats."""

    def __init__(self, match_id):
        self.match_id = match_id
        self.events = sb.events(match_id=match_id)
        self.lineups = sb.lineups(match_id=match_id)
        self.match_info = self._get_match_info()
        self.team_stats = self._calculate_team_stats()

    def _get_match_info(self):
        """Extract basic match information."""
        teams = self.events['team'].unique()
        return {
            'home_team': teams[0] if len(teams) > 0 else 'Team A',
            'away_team': teams[1] if len(teams) > 1 else 'Team B',
            'date': datetime.now().strftime('%Y-%m-%d')
        }

    def _calculate_team_stats(self):
        """Calculate comprehensive team statistics."""
        stats = {}

        for team in [self.match_info['home_team'], self.match_info['away_team']]:
            team_events = self.events[self.events['team'] == team]
            shots = team_events[team_events['type'] == 'Shot']

            stats[team] = {
                'shots': len(shots),
                'shots_on_target': len(shots[shots['shot_outcome'].isin(['Goal', 'Saved'])]),
                'goals': len(shots[shots['shot_outcome'] == 'Goal']),
                'xg': shots['shot_statsbomb_xg'].sum() if 'shot_statsbomb_xg' in shots.columns else 0,
                'passes': len(team_events[team_events['type'] == 'Pass']),
                'pass_completion': self._calc_pass_completion(team_events),
                'possession_pct': len(team_events) / len(self.events) * 100,
                'pressures': len(team_events[team_events['type'] == 'Pressure']),
                'tackles': len(team_events[(team_events['type'] == 'Duel') &
                                           (team_events['duel_type'].fillna('') == 'Tackle') if 'duel_type' in team_events.columns else False]),
                'interceptions': len(team_events[team_events['type'] == 'Interception'])
            }

        return stats

    def _calc_pass_completion(self, team_events):
        """Calculate pass completion percentage."""
        passes = team_events[team_events['type'] == 'Pass']
        if len(passes) == 0:
            return 0
        completed = passes['pass_outcome'].isna().sum()
        return (completed / len(passes)) * 100

    def generate_executive_summary(self):
        """Generate plain-language executive summary."""
        home = self.match_info['home_team']
        away = self.match_info['away_team']
        h_stats = self.team_stats[home]
        a_stats = self.team_stats[away]

        # Determine result
        if h_stats['goals'] > a_stats['goals']:
            result = f"{home} won"
        elif a_stats['goals'] > h_stats['goals']:
            result = f"{away} won"
        else:
            result = "The match ended in a draw"

        # xG winner
        xg_winner = home if h_stats['xg'] > a_stats['xg'] else away

        # Possession dominance
        if h_stats['possession_pct'] > 55:
            poss_leader = home
        elif a_stats['possession_pct'] > 55:
            poss_leader = away
        else:
            poss_leader = "Neither team"

        summary = f"""
MATCH OVERVIEW
==============

{result} {h_stats['goals']}-{a_stats['goals']}.

KEY TAKEAWAYS:
- {xg_winner} created the better chances (xG: {h_stats['xg']:.2f} vs {a_stats['xg']:.2f})
- {poss_leader} dominated possession ({h_stats['possession_pct']:.1f}% vs {a_stats['possession_pct']:.1f}%)
- Shot efficiency: {home} {h_stats['shots_on_target']}/{h_stats['shots']} on target vs {away} {a_stats['shots_on_target']}/{a_stats['shots']}

PERFORMANCE RATING:
{home}: {self._rate_performance(h_stats)}
{away}: {self._rate_performance(a_stats)}
        """
        return summary.strip()

    def _rate_performance(self, stats):
        """Rate team performance based on key metrics."""
        score = 0

        # xG efficiency
        if stats['goals'] >= stats['xg']:
            score += 2
        elif stats['goals'] >= stats['xg'] * 0.8:
            score += 1

        # Pass completion
        if stats['pass_completion'] > 85:
            score += 2
        elif stats['pass_completion'] > 75:
            score += 1

        # Shots on target ratio
        if stats['shots'] > 0 and stats['shots_on_target'] / stats['shots'] > 0.4:
            score += 1

        if score >= 5:
            return "Excellent"
        elif score >= 3:
            return "Good"
        elif score >= 2:
            return "Average"
        else:
            return "Below Par"

    def generate_coach_summary(self):
        """Generate tactical analysis for coaching staff."""
        home = self.match_info['home_team']
        away = self.match_info['away_team']

        # Pressing analysis by zone
        press_by_zone = self._analyze_pressing()

        # Progressive passes
        prog_passes = self._analyze_progressive_passes()

        summary = f"""
TACTICAL ANALYSIS
=================

PRESSING:
- {home}: {press_by_zone.get(home, {}).get('High', 0)} high presses
- {away}: {press_by_zone.get(away, {}).get('High', 0)} high presses

PROGRESSIVE PLAY:
- {home}: {prog_passes.get(home, 0)} progressive passes
- {away}: {prog_passes.get(away, 0)} progressive passes

RECOMMENDATIONS:
{self._generate_recommendations()}
        """
        return summary.strip()

    def _analyze_pressing(self):
        """Analyze pressing by zone."""
        presses = self.events[self.events['type'] == 'Pressure'].copy()
        if len(presses) == 0:
            return {}

        presses['zone'] = presses['location'].apply(
            lambda loc: 'High' if isinstance(loc, list) and loc[0] > 80
                        else ('Mid' if isinstance(loc, list) and loc[0] > 40 else 'Low')
        )

        result = {}
        for team in presses['team'].unique():
            team_presses = presses[presses['team'] == team]
            result[team] = team_presses.groupby('zone').size().to_dict()

        return result

    def _analyze_progressive_passes(self):
        """Count progressive passes (>10m forward)."""
        passes = self.events[self.events['type'] == 'Pass'].copy()

        def calc_progress(row):
            if not isinstance(row['location'], list) or not isinstance(row.get('pass_end_location'), list):
                return 0
            return row['pass_end_location'][0] - row['location'][0]

        passes['progress'] = passes.apply(calc_progress, axis=1)

        result = {}
        for team in passes['team'].unique():
            team_passes = passes[passes['team'] == team]
            result[team] = (team_passes['progress'] > 10).sum()

        return result

    def _generate_recommendations(self):
        """Generate data-driven recommendations."""
        recs = []
        home = self.match_info['home_team']
        h_stats = self.team_stats[home]

        if h_stats['goals'] < h_stats['xg'] * 0.8:
            recs.append(f"- Review finishing; created {h_stats['xg']:.2f} xG but only scored {h_stats['goals']}")

        if h_stats['pass_completion'] < 75:
            recs.append(f"- Passing under pressure needs work ({h_stats['pass_completion']:.1f}% completion)")

        if not recs:
            recs.append("- Strong all-around performance, maintain current approach")

        return '\n'.join(recs)

    def create_shot_map(self, team_name, ax=None):
        """Create shot map visualization."""
        if ax is None:
            fig, ax = plt.subplots(figsize=(10, 7))

        # Draw pitch (simplified)
        ax.set_xlim(60, 120)
        ax.set_ylim(0, 80)
        ax.set_facecolor('darkgreen')
        ax.add_patch(Rectangle((102, 18), 18, 44, fill=False, color='white', lw=2))  # Box
        ax.axvline(x=120, color='white', lw=2)  # Goal line

        # Plot shots
        shots = self.events[(self.events['type'] == 'Shot') &
                           (self.events['team'] == team_name)]

        for _, shot in shots.iterrows():
            if isinstance(shot['location'], list):
                x, y = shot['location']
                xg = shot.get('shot_statsbomb_xg', 0.1)
                is_goal = shot.get('shot_outcome') == 'Goal'

                ax.scatter(x, y, s=xg*500,
                          c='red' if is_goal else 'steelblue',
                          alpha=0.7, edgecolors='white', linewidths=1)

        total_xg = shots['shot_statsbomb_xg'].sum() if 'shot_statsbomb_xg' in shots.columns else 0
        ax.set_title(f"{team_name} - Shot Map\nTotal xG: {total_xg:.2f}", fontsize=12, fontweight='bold')
        ax.set_xticks([])
        ax.set_yticks([])

        return ax

    def create_full_report(self, output_path='match_report.html'):
        """Generate complete HTML report."""
        # Create visualizations
        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
        self.create_shot_map(self.match_info['home_team'], axes[0])
        self.create_shot_map(self.match_info['away_team'], axes[1])
        plt.tight_layout()
        plt.savefig('shots.png', dpi=150, bbox_inches='tight', facecolor='white')
        plt.close()

        # Build HTML
        html = f"""
<!DOCTYPE html>
<html>
<head>
    <title>Match Report</title>
    <style>
        body {{ font-family: Arial, sans-serif; max-width: 900px; margin: 0 auto; padding: 20px; }}
        .header {{ background: #1B5E20; color: white; padding: 20px; text-align: center; }}
        .section {{ margin: 20px 0; padding: 15px; background: #f5f5f5; border-radius: 5px; }}
        pre {{ white-space: pre-wrap; font-family: inherit; }}
        img {{ max-width: 100%; }}
    </style>
</head>
<body>
    <div class="header">
        <h1>Match Report</h1>
        <h2>{self.match_info['home_team']} vs {self.match_info['away_team']}</h2>
    </div>

    <div class="section">
        <h3>Executive Summary</h3>
        <pre>{self.generate_executive_summary()}</pre>
    </div>

    <div class="section">
        <h3>Shot Maps</h3>
        <img src="shots.png" alt="Shot Maps">
    </div>

    <div class="section">
        <h3>Tactical Analysis</h3>
        <pre>{self.generate_coach_summary()}</pre>
    </div>

    <footer>
        <p>Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}</p>
    </footer>
</body>
</html>
        """

        with open(output_path, 'w') as f:
            f.write(html)

        print(f"Report saved to {output_path}")
        return output_path


# Example usage
print("=== MATCH REPORT GENERATOR ===\n")

# Demo with a sample match
try:
    # Get a sample match
    competitions = sb.competitions()
    la_liga = competitions[competitions['competition_name'] == 'La Liga'].iloc[0]
    matches = sb.matches(competition_id=la_liga['competition_id'],
                         season_id=la_liga['season_id'])
    sample_match = matches.iloc[0]['match_id']

    # Generate report
    reporter = MatchReportGenerator(match_id=sample_match)

    print("EXECUTIVE SUMMARY:")
    print(reporter.generate_executive_summary())

    print("\n" + "="*50 + "\n")

    print("COACH SUMMARY:")
    print(reporter.generate_coach_summary())

    # Create visualizations
    fig, ax = plt.subplots(figsize=(10, 7))
    reporter.create_shot_map(reporter.match_info['home_team'], ax)
    plt.savefig('sample_shot_map.png', dpi=150, bbox_inches='tight')
    plt.show()

except Exception as e:
    print(f"Demo output (sample data not available): {e}")
    print("\nTo use: reporter = MatchReportGenerator(match_id=12345)")
    print("reporter.generate_executive_summary()")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Patch
from scipy import stats
import warnings
warnings.filterwarnings('ignore')

class PlayerComparisonDashboard:
    """Interactive dashboard for comparing player performance."""

    def __init__(self, player_data):
        """
        Initialize with player data DataFrame.

        Expected columns: player_id, player_name, position, minutes,
                         goals_p90, assists_p90, xg_p90, xa_p90, etc.
        """
        self.player_data = player_data
        self.metrics = ['goals_p90', 'assists_p90', 'xg_p90', 'xa_p90',
                       'passes_p90', 'key_passes_p90', 'dribbles_p90']

    def calculate_percentiles(self, player_ids, position='Forward', min_minutes=900):
        """Calculate percentile rankings against position peers."""

        # Filter benchmark population
        benchmark = self.player_data[
            (self.player_data['position'] == position) &
            (self.player_data['minutes'] >= min_minutes)
        ]

        # Get selected players
        selected = self.player_data[
            self.player_data['player_id'].isin(player_ids)
        ].copy()

        # Calculate percentiles
        for metric in self.metrics:
            if metric in benchmark.columns:
                selected[f'{metric}_pct'] = selected[metric].apply(
                    lambda x: stats.percentileofscore(benchmark[metric].dropna(), x)
                )

        return selected

    def create_radar_chart(self, percentile_data, ax=None):
        """Create radar chart comparing players."""

        if ax is None:
            fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(projection='polar'))

        # Prepare data
        pct_cols = [f'{m}_pct' for m in self.metrics if f'{m}_pct' in percentile_data.columns]
        labels = [m.replace('_p90', '').replace('_', ' ').title() for m in self.metrics]

        # Number of variables
        num_vars = len(pct_cols)
        angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
        angles += angles[:1]  # Complete the loop

        # Colors for each player
        colors = ['#1B5E20', '#C62828', '#1565C0', '#FF8F00']

        for idx, (_, player) in enumerate(percentile_data.iterrows()):
            values = player[pct_cols].values.tolist()
            values += values[:1]  # Complete the loop

            ax.plot(angles, values, 'o-', linewidth=2,
                   label=player['player_name'], color=colors[idx % len(colors)])
            ax.fill(angles, values, alpha=0.15, color=colors[idx % len(colors)])

        # Configure chart
        ax.set_xticks(angles[:-1])
        ax.set_xticklabels(labels, size=10)
        ax.set_ylim(0, 100)
        ax.set_yticks([25, 50, 75, 90])
        ax.set_yticklabels(['25%', '50%', '75%', '90%'], size=8)
        ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1.0))
        ax.set_title('Player Comparison - Percentile Rankings', size=14, fontweight='bold', y=1.08)

        return ax

    def create_percentile_bars(self, percentile_data, ax=None):
        """Create horizontal bar chart of percentile rankings."""

        if ax is None:
            fig, ax = plt.subplots(figsize=(10, 8))

        pct_cols = [f'{m}_pct' for m in self.metrics if f'{m}_pct' in percentile_data.columns]
        labels = [m.replace('_p90_pct', '').replace('_', ' ').title() for m in pct_cols]

        x = np.arange(len(labels))
        width = 0.25
        colors = ['#1B5E20', '#C62828', '#1565C0']

        for idx, (_, player) in enumerate(percentile_data.iterrows()):
            values = player[pct_cols].values
            offset = (idx - len(percentile_data) / 2 + 0.5) * width
            ax.barh(x + offset, values, width, label=player['player_name'],
                   color=colors[idx % len(colors)], alpha=0.8)

        # Add reference lines
        for pct in [25, 50, 75, 90]:
            ax.axvline(pct, color='gray', linestyle='--', alpha=0.5, linewidth=1)

        ax.set_yticks(x)
        ax.set_yticklabels(labels)
        ax.set_xlabel('Percentile')
        ax.set_xlim(0, 100)
        ax.legend(loc='lower right')
        ax.set_title('Percentile Rankings by Metric', fontweight='bold')

        # Add tier labels
        ax.text(12.5, len(labels), 'Poor', ha='center', va='bottom', fontsize=8, color='gray')
        ax.text(37.5, len(labels), 'Below\nAvg', ha='center', va='bottom', fontsize=8, color='gray')
        ax.text(62.5, len(labels), 'Avg', ha='center', va='bottom', fontsize=8, color='gray')
        ax.text(82.5, len(labels), 'Above\nAvg', ha='center', va='bottom', fontsize=8, color='gray')
        ax.text(95, len(labels), 'Elite', ha='center', va='bottom', fontsize=8, color='gray')

        return ax

    def generate_summary(self, percentile_data):
        """Generate text summary of comparison."""

        pct_cols = [f'{m}_pct' for m in self.metrics if f'{m}_pct' in percentile_data.columns]

        summary = "PLAYER COMPARISON SUMMARY\n"
        summary += "=" * 25 + "\n\n"

        for _, player in percentile_data.iterrows():
            values = {col.replace('_p90_pct', ''): player[col]
                     for col in pct_cols if col in player.index}

            # Sort to find strengths and weaknesses
            sorted_metrics = sorted(values.items(), key=lambda x: x[1], reverse=True)

            strengths = sorted_metrics[:2]
            weaknesses = sorted_metrics[-2:]

            summary += f"{player['player_name']}\n"
            summary += f"Strengths: {strengths[0][0]} ({strengths[0][1]:.0f}%), "
            summary += f"{strengths[1][0]} ({strengths[1][1]:.0f}%)\n"
            summary += f"Weaknesses: {weaknesses[0][0]} ({weaknesses[0][1]:.0f}%), "
            summary += f"{weaknesses[1][0]} ({weaknesses[1][1]:.0f}%)\n\n"

        return summary

    def create_full_dashboard(self, player_ids, position='Forward'):
        """Create complete comparison dashboard."""

        # Calculate percentiles
        percentile_data = self.calculate_percentiles(player_ids, position)

        # Create figure with subplots
        fig = plt.figure(figsize=(16, 10))

        # Radar chart
        ax1 = fig.add_subplot(121, projection='polar')
        self.create_radar_chart(percentile_data, ax1)

        # Percentile bars
        ax2 = fig.add_subplot(122)
        self.create_percentile_bars(percentile_data, ax2)

        plt.suptitle(f'Player Comparison Dashboard - {position}s', fontsize=16, fontweight='bold', y=1.02)
        plt.tight_layout()

        # Print summary
        print(self.generate_summary(percentile_data))

        return fig, percentile_data


# Demo with simulated data
np.random.seed(42)

# Create sample player data
n_players = 100
player_data = pd.DataFrame({
    'player_id': range(1, n_players + 1),
    'player_name': [f'Player_{i}' for i in range(1, n_players + 1)],
    'position': np.random.choice(['Forward', 'Midfielder', 'Defender'], n_players,
                                  p=[0.3, 0.4, 0.3]),
    'minutes': np.random.randint(500, 3000, n_players),
    'goals_p90': np.abs(np.random.normal(0.3, 0.15, n_players)),
    'assists_p90': np.abs(np.random.normal(0.2, 0.1, n_players)),
    'xg_p90': np.abs(np.random.normal(0.35, 0.12, n_players)),
    'xa_p90': np.abs(np.random.normal(0.18, 0.08, n_players)),
    'passes_p90': np.abs(np.random.normal(40, 10, n_players)),
    'key_passes_p90': np.abs(np.random.normal(1.5, 0.5, n_players)),
    'dribbles_p90': np.abs(np.random.normal(2, 0.8, n_players))
})

# Name specific players
player_data.loc[0, 'player_name'] = 'Messi Jr.'
player_data.loc[14, 'player_name'] = 'Ronaldo Jr.'
player_data.loc[41, 'player_name'] = 'Mbappe Jr.'

# Create dashboard
print("=== PLAYER COMPARISON DASHBOARD ===\n")

dashboard = PlayerComparisonDashboard(player_data)
fig, percentile_data = dashboard.create_full_dashboard(
    player_ids=[1, 15, 42],
    position='Forward'
)

plt.savefig('player_comparison_dashboard.png', dpi=150, bbox_inches='tight')
plt.show()

# Show the comparison data
print("\nPercentile Rankings:")
pct_cols = [col for col in percentile_data.columns if '_pct' in col]
print(percentile_data[['player_name'] + pct_cols].round(1).to_string(index=False))

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

class ScoutReportGenerator:
    """Automated opposition scout report generator."""

    def __init__(self, match_data, player_data):
        self.match_data = match_data
        self.player_data = player_data

    def generate_report(self, team_name):
        """Generate comprehensive scout report for opposition team."""

        report = {
            'team': team_name,
            'generated': datetime.now()
        }

        # Filter to team's recent matches
        team_matches = self.match_data[
            self.match_data['team'] == team_name
        ].sort_values('date', ascending=False).head(5)

        # Calculate team profile
        report['profile'] = self._calculate_team_profile(team_matches)

        # Key players
        report['key_players'] = self._identify_key_players(team_name)

        # Tactical patterns
        report['tactics'] = self._analyze_tactical_patterns(team_matches)

        # Recommendations
        report['recommendations'] = self._generate_recommendations(report)

        return report

    def _calculate_team_profile(self, matches):
        """Calculate team's recent profile."""

        recent_form = {
            'wins': (matches['result'] == 'W').sum(),
            'draws': (matches['result'] == 'D').sum(),
            'losses': (matches['result'] == 'L').sum(),
            'goals_for': matches['goals_for'].sum(),
            'goals_against': matches['goals_against'].sum(),
            'xg_for': matches['xg_for'].sum(),
            'xg_against': matches['xg_against'].sum(),
            'avg_possession': matches['possession'].mean()
        }

        style = {
            'avg_ppda': matches['ppda'].mean(),
            'avg_passes': matches['passes'].mean(),
            'avg_shots': matches['shots'].mean(),
            'avg_crosses': matches['crosses'].mean(),
            'pass_completion': matches['pass_completion'].mean(),
            'directness': (matches['direct_attacks'] / matches['passes'] * 100).mean()
        }

        return {'recent_form': recent_form, 'style': style}

    def _identify_key_players(self, team_name, top_n=5):
        """Identify most dangerous players."""

        team_players = self.player_data[
            (self.player_data['team'] == team_name) &
            (self.player_data['minutes'] >= 450)
        ].copy()

        # Calculate contribution score
        team_players['contribution_score'] = (
            team_players['goals'] * 3 +
            team_players['assists'] * 2 +
            team_players['key_passes'] * 0.5 +
            team_players['successful_dribbles'] * 0.3 +
            team_players['tackles_won'] * 0.2
        )

        # Assign threat level
        team_players = team_players.sort_values('contribution_score', ascending=False).head(top_n)

        threshold_high = team_players['contribution_score'].quantile(0.8)
        threshold_med = team_players['contribution_score'].quantile(0.5)

        team_players['threat_level'] = team_players['contribution_score'].apply(
            lambda x: 'High' if x > threshold_high else ('Medium' if x > threshold_med else 'Monitor')
        )

        return team_players[['player_name', 'position', 'minutes', 'goals', 'assists',
                            'xg', 'xa', 'key_passes', 'contribution_score', 'threat_level']]

    def _analyze_tactical_patterns(self, matches):
        """Analyze team's tactical patterns."""

        # Primary formation
        formation = matches['formation'].mode().iloc[0] if len(matches) > 0 else '4-3-3'

        # Build-up style
        if matches['passes'].mean() > 500 and matches['possession'].mean() > 55:
            build_up = 'Possession-based'
        elif matches['direct_attacks'].mean() > 20:
            build_up = 'Direct/Counter'
        else:
            build_up = 'Balanced'

        # Pressing style
        avg_ppda = matches['ppda'].mean()
        if avg_ppda < 10:
            pressing = 'High Press'
        elif avg_ppda > 15:
            pressing = 'Low Block'
        else:
            pressing = 'Mid Block'

        # Attack zones
        attack_zones = {
            'left_wing': matches['attacks_left'].mean(),
            'center': matches['attacks_center'].mean(),
            'right_wing': matches['attacks_right'].mean()
        }
        primary_attack = max(attack_zones, key=attack_zones.get)

        return {
            'formation': formation,
            'build_up_style': build_up,
            'pressing_style': pressing,
            'primary_attack_zone': primary_attack,
            'attack_zones': attack_zones,
            'set_piece_threat': matches['set_piece_goals'].mean() > 0.5
        }

    def _generate_recommendations(self, report):
        """Generate tactical recommendations based on analysis."""

        recs = {}

        # Based on pressing style
        if report['tactics']['pressing_style'] == 'High Press':
            recs['against_press'] = {
                'recommendation': 'Play through or over the press',
                'detail': 'They press high - use quick passing combinations or long balls behind',
                'supporting_data': f"PPDA: {report['profile']['style']['avg_ppda']:.1f}"
            }
        elif report['tactics']['pressing_style'] == 'Low Block':
            recs['against_block'] = {
                'recommendation': 'Patient build-up, exploit wide areas',
                'detail': 'They sit deep - circulate ball and stretch them horizontally',
                'supporting_data': f"PPDA: {report['profile']['style']['avg_ppda']:.1f}"
            }

        # Based on build-up style
        if report['tactics']['build_up_style'] == 'Possession-based':
            recs['disrupt_possession'] = {
                'recommendation': 'Press their build-up triggers',
                'detail': 'Target their center-backs and defensive midfielder when receiving',
                'supporting_data': f"Avg passes: {report['profile']['style']['avg_passes']:.0f}"
            }

        # Based on attack zones
        zones = report['tactics']['attack_zones']
        if report['tactics']['primary_attack_zone'] == 'left_wing':
            recs['defend_flank'] = {
                'recommendation': 'Reinforce right defensive side',
                'detail': 'Their primary threat comes down the left - double up if needed',
                'supporting_data': f"{zones['left_wing']:.1f}% attacks from left"
            }
        elif report['tactics']['primary_attack_zone'] == 'right_wing':
            recs['defend_flank'] = {
                'recommendation': 'Reinforce left defensive side',
                'detail': 'Their primary threat comes down the right - double up if needed',
                'supporting_data': f"{zones['right_wing']:.1f}% attacks from right"
            }

        # Key player focus
        key_player = report['key_players'].iloc[0]
        recs['key_man'] = {
            'recommendation': f"Man-mark or limit service to {key_player['player_name']}",
            'detail': f"Their most dangerous player with {int(key_player['goals'])}G and {int(key_player['assists'])}A",
            'supporting_data': f"Contribution score: {key_player['contribution_score']:.1f}"
        }

        return recs

    def format_report(self, report):
        """Format report for display."""

        output = f"""
═══════════════════════════════════════════════
  OPPOSITION SCOUT REPORT: {report['team'].upper()}
═══════════════════════════════════════════════

RECENT FORM (Last 5 Matches)
──────────────────────────────
Record: {report['profile']['recent_form']['wins']}W-{report['profile']['recent_form']['draws']}D-{report['profile']['recent_form']['losses']}L
Goals: {report['profile']['recent_form']['goals_for']} scored, {report['profile']['recent_form']['goals_against']} conceded
xG: {report['profile']['recent_form']['xg_for']:.2f} for, {report['profile']['recent_form']['xg_against']:.2f} against
Avg Possession: {report['profile']['recent_form']['avg_possession']:.1f}%

TACTICAL PROFILE
──────────────────────────────
Formation: {report['tactics']['formation']}
Build-up: {report['tactics']['build_up_style']}
Defensive: {report['tactics']['pressing_style']}
Primary Attack: {report['tactics']['primary_attack_zone']}

KEY PLAYERS TO WATCH
──────────────────────────────"""

        for idx, (_, player) in enumerate(report['key_players'].head(3).iterrows(), 1):
            output += f"""
{idx}. {player['player_name']} ({player['position']})
   {int(player['goals'])}G, {int(player['assists'])}A | Threat: {player['threat_level']}"""

        output += """

TACTICAL RECOMMENDATIONS
──────────────────────────────"""

        for rec_name, rec in report['recommendations'].items():
            output += f"""
▸ {rec['recommendation']}
  {rec['detail']}
  [{rec['supporting_data']}]
"""

        output += f"""
═══════════════════════════════════════════════
Generated: {report['generated'].strftime('%Y-%m-%d %H:%M')}
"""

        return output


# Demo with simulated data
np.random.seed(42)

# Create simulated match data
dates = [datetime.now() - timedelta(days=x*4) for x in range(20)]

match_data = pd.DataFrame({
    'match_id': range(1, 21),
    'date': dates,
    'team': ['Barcelona'] * 10 + ['Real Madrid'] * 10,
    'opponent': ['Real Madrid'] * 10 + ['Barcelona'] * 10,
    'result': np.random.choice(['W', 'D', 'L'], 20, p=[0.5, 0.25, 0.25]),
    'goals_for': np.random.randint(0, 5, 20),
    'goals_against': np.random.randint(0, 4, 20),
    'xg_for': np.random.uniform(0.8, 2.5, 20),
    'xg_against': np.random.uniform(0.5, 2.0, 20),
    'possession': np.random.uniform(45, 70, 20),
    'passes': np.random.randint(400, 600, 20),
    'pass_completion': np.random.uniform(75, 90, 20),
    'shots': np.random.randint(8, 20, 20),
    'crosses': np.random.randint(10, 30, 20),
    'ppda': np.random.uniform(8, 18, 20),
    'direct_attacks': np.random.randint(10, 25, 20),
    'attacks_left': np.random.uniform(25, 40, 20),
    'attacks_center': np.random.uniform(20, 35, 20),
    'attacks_right': np.random.uniform(25, 40, 20),
    'set_piece_goals': np.random.randint(0, 3, 20),
    'formation': np.random.choice(['4-3-3', '4-4-2', '3-5-2'], 20, p=[0.6, 0.3, 0.1])
})

# Create simulated player data
player_data = pd.DataFrame({
    'player_name': ['Lewandowski', 'Pedri', 'Gavi', 'Araujo', 'Raphinha',
                   'Vinicius Jr.', 'Bellingham', 'Rodrygo', 'Valverde', 'Modric'],
    'team': ['Barcelona'] * 5 + ['Real Madrid'] * 5,
    'position': ['Forward', 'Midfielder', 'Midfielder', 'Defender', 'Forward',
                'Forward', 'Midfielder', 'Forward', 'Midfielder', 'Midfielder'],
    'minutes': np.random.randint(800, 2500, 10),
    'goals': [15, 5, 3, 2, 8, 12, 10, 7, 4, 3],
    'assists': [4, 8, 6, 1, 5, 7, 6, 5, 8, 9],
    'xg': [12.5, 4.2, 2.8, 1.5, 7.2, 10.8, 8.5, 6.2, 3.5, 2.8],
    'xa': [3.2, 7.5, 5.8, 0.8, 4.5, 6.2, 5.5, 4.8, 7.2, 8.5],
    'key_passes': [25, 65, 48, 12, 42, 55, 52, 38, 58, 62],
    'successful_dribbles': [18, 35, 42, 8, 52, 85, 45, 55, 28, 22],
    'tackles_won': [12, 45, 52, 85, 18, 15, 42, 20, 55, 38]
})

# Generate report
print("=== OPPOSITION SCOUT REPORT GENERATOR ===\n")

generator = ScoutReportGenerator(match_data, player_data)
report = generator.generate_report('Real Madrid')
formatted_report = generator.format_report(report)
print(formatted_report)