#| label: maturity-assessment-py
#| message: false
#| warning: false

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Analytics maturity assessment framework
maturity_dimensions = {
    'People': {1: 'No dedicated staff', 2: '1-2 analysts',
               3: '3-5 team members', 4: '6-10+ specialists',
               5: '15+ with sub-departments'},
    'Data': {1: 'Spreadsheets only', 2: 'Basic database',
             3: 'Integrated system', 4: 'Data warehouse',
             5: 'Real-time platform'},
    'Tools': {1: 'Excel/Google Sheets', 2: 'R or Python',
              3: 'Multiple platforms', 4: 'Custom tools',
              5: 'Proprietary systems'},
    'Processes': {1: 'Ad hoc requests', 2: 'Regular reports',
                  3: 'Defined workflows', 4: 'Automated pipelines',
                  5: 'Continuous integration'},
    'Integration': {1: 'Ignored', 2: 'Occasional input',
                    3: 'Regular consultation', 4: 'Embedded in decisions',
                    5: 'Drives strategy'},
    'Culture': {1: 'Resistant', 2: 'Skeptical', 3: 'Accepting',
                4: 'Embracing', 5: 'Analytics-first'},
    'Impact': {1: 'None measured', 2: 'Anecdotal',
               3: 'Tracked metrics', 4: 'ROI demonstrated',
               5: 'Competitive advantage'}
}

class MaturityAssessment:
    """Assess and visualize analytics maturity"""

    def __init__(self):
        self.weights = {
            'People': 0.20,
            'Data': 0.15,
            'Tools': 0.10,
            'Processes': 0.15,
            'Integration': 0.20,
            'Culture': 0.10,
            'Impact': 0.10
        }

    def assess(self, scores):
        """
        Assess maturity based on dimension scores

        Parameters:
        -----------
        scores : dict
            Dictionary with dimension names and stage (1-5)

        Returns:
        --------
        pd.DataFrame with assessment details
        """
        assessment = pd.DataFrame({
            'dimension': list(scores.keys()),
            'stage': list(scores.values())
        })

        assessment['weight'] = assessment['dimension'].map(self.weights)
        assessment['weighted_score'] = assessment['stage'] * assessment['weight']

        def get_status(stage):
            if stage <= 2:
                return 'Needs Development'
            elif stage == 3:
                return 'Developing'
            else:
                return 'Advanced'

        assessment['status'] = assessment['stage'].apply(get_status)

        return assessment

    def overall_score(self, assessment):
        """Calculate overall maturity score"""
        return assessment['weighted_score'].sum()

    def plot_radar(self, scores, title="Analytics Maturity Profile"):
        """Create radar chart of maturity dimensions"""
        dimensions = list(scores.keys())
        values = list(scores.values())

        # Number of dimensions
        N = len(dimensions)

        # Compute angle for each dimension
        angles = [n / float(N) * 2 * np.pi for n in range(N)]
        values += values[:1]  # Complete the circle
        angles += angles[:1]

        # Create plot
        fig, ax = plt.subplots(figsize=(8, 8), subplot_kw=dict(projection='polar'))

        # Plot data
        ax.plot(angles, values, 'o-', linewidth=2, color='#2E86AB')
        ax.fill(angles, values, alpha=0.25, color='#2E86AB')

        # Fix axis to go in the right order and start at 12 o'clock
        ax.set_theta_offset(np.pi / 2)
        ax.set_theta_direction(-1)

        # Draw axis lines for each dimension
        ax.set_xticks(angles[:-1])
        ax.set_xticklabels(dimensions, size=10)

        # Set y-axis limits
        ax.set_ylim(0, 5)
        ax.set_yticks([1, 2, 3, 4, 5])
        ax.set_yticklabels(['1', '2', '3', '4', '5'], size=8)
        ax.set_rlabel_position(0)

        # Add grid
        ax.grid(True, linestyle='--', alpha=0.7)

        plt.title(title, size=14, fontweight='bold', pad=20)
        plt.tight_layout()

        return fig, ax

# Example: Assess a typical college program
example_scores = {
    'People': 2,
    'Data': 2,
    'Tools': 3,
    'Processes': 2,
    'Integration': 2,
    'Culture': 2,
    'Impact': 1
}

assessor = MaturityAssessment()
assessment_result = assessor.assess(example_scores)
overall = assessor.overall_score(assessment_result)

print("Analytics Maturity Assessment")
print("=" * 60)
print(assessment_result.to_string(index=False))
print("\n" + "=" * 60)
print(f"Overall Maturity Score: {overall:.2f} (Stage {round(overall)})")

#| label: fig-maturity-radar-py
#| fig-cap: "Analytics maturity profile visualization - Python"
#| fig-width: 8
#| fig-height: 8
#| message: false
#| warning: false

# Create radar chart for maturity assessment
fig, ax = assessor.plot_radar(
    example_scores,
    title="Analytics Maturity Profile\nExample Organization"
)
plt.show()

#| label: org-structure-py
#| message: false
#| warning: false

# Define analytics team roles and structure
roles_data = {
    'Level': ['Leadership', 'Leadership', 'Senior', 'Senior',
              'Mid-Level', 'Mid-Level', 'Junior', 'Support', 'Support'],
    'Role': ['Director of Analytics', 'Senior Manager',
             'Senior Data Scientist', 'Senior Analyst',
             'Data Scientist', 'Football Analyst',
             'Analytics Associate', 'Data Engineer', 'Software Developer'],
    'Salary_Range': ['$150k-300k+', '$120k-200k', '$100k-180k', '$90k-150k',
                     '$80k-130k', '$70k-120k', '$50k-80k',
                     '$90k-150k', '$90k-150k'],
    'Key_Responsibilities': [
        'Strategy, stakeholder management, team leadership',
        'Project management, methodology, quality assurance',
        'Advanced modeling, research, mentorship',
        'Complex analysis, visualization, reporting',
        'Predictive models, statistical analysis',
        'Game analysis, opponent scouting, reporting',
        'Data collection, basic analysis, support',
        'Infrastructure, pipelines, data quality',
        'Tool development, dashboards, applications'
    ],
    'Required_Skills': [
        '10+ years experience, leadership, football knowledge',
        '7+ years experience, technical expertise, communication',
        '5+ years, ML/AI, statistical modeling, R/Python',
        '5+ years, football expertise, data visualization',
        '3+ years, statistics, programming, ML basics',
        '3+ years, football knowledge, SQL, data analysis',
        '0-2 years, programming, statistics, eagerness to learn',
        '3+ years, databases, cloud platforms, ETL',
        '3+ years, web development, APIs, UX design'
    ]
}

analytics_roles_df = pd.DataFrame(roles_data)

print("Analytics Team Role Structure")
print("=" * 80)
print("\nTypical roles in mature football analytics departments:\n")
print(analytics_roles_df[['Level', 'Role', 'Salary_Range', 'Key_Responsibilities']].to_string(index=False))

#| label: infrastructure-design-py
#| message: false
#| warning: false

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch

def create_infrastructure_diagram():
    """Create data infrastructure visualization"""

    fig, ax = plt.subplots(figsize=(12, 10))
    ax.set_xlim(0, 10)
    ax.set_ylim(0, 10)
    ax.axis('off')

    # Define colors for each layer
    colors = {
        'source': '#E8F4F8',
        'ingestion': '#C6E5F2',
        'storage': '#A4D6EB',
        'processing': '#82C7E5',
        'application': '#60B8DE',
        'users': '#FFE5CC'
    }

    # Helper function to draw boxes
    def draw_box(x, y, width, height, text, color):
        box = FancyBboxPatch(
            (x, y), width, height,
            boxstyle="round,pad=0.05",
            facecolor=color,
            edgecolor='#333333',
            linewidth=1.5
        )
        ax.add_patch(box)
        ax.text(x + width/2, y + height/2, text,
               ha='center', va='center', fontsize=8,
               fontweight='bold')

    # Data Sources Layer
    y = 8.5
    sources = ['Play-by-Play', 'Tracking', 'Video', 'Scouting', 'Other']
    for i, source in enumerate(sources):
        draw_box(i*1.8 + 0.5, y, 1.5, 0.8, source, colors['source'])

    ax.text(5, y + 1.2, 'DATA SOURCES', ha='center', fontsize=11,
           fontweight='bold', style='italic')

    # Ingestion Layer
    y = 7
    draw_box(1.5, y, 2.5, 0.7, 'Data Ingestion\nPipelines', colors['ingestion'])
    draw_box(6, y, 2.5, 0.7, 'ETL\nProcesses', colors['ingestion'])

    # Storage Layer
    y = 5.5
    draw_box(1, y, 2, 0.7, 'Data\nWarehouse', colors['storage'])
    draw_box(4, y, 2, 0.7, 'Data\nLake', colors['storage'])
    draw_box(7, y, 2, 0.7, 'Video\nStorage', colors['storage'])

    # Processing Layer
    y = 4
    draw_box(1, y, 2.2, 0.7, 'Analytics\nEngine', colors['processing'])
    draw_box(4, y, 2.2, 0.7, 'ML\nPlatform', colors['processing'])
    draw_box(7, y, 2.2, 0.7, 'Reporting\nSystem', colors['processing'])

    # Application Layer
    y = 2.5
    draw_box(0.5, y, 1.8, 0.7, 'Dashboards', colors['application'])
    draw_box(3, y, 1.8, 0.7, 'Custom\nApps', colors['application'])
    draw_box(5.5, y, 1.8, 0.7, 'Reports', colors['application'])
    draw_box(8, y, 1.8, 0.7, 'APIs', colors['application'])

    # Users Layer
    y = 0.8
    users = ['Coaches', 'Scouts', 'Executives', 'Analysts']
    for i, user in enumerate(users):
        circle = plt.Circle((i*2.2 + 1.5, y), 0.4,
                          facecolor=colors['users'],
                          edgecolor='#333333',
                          linewidth=1.5)
        ax.add_patch(circle)
        ax.text(i*2.2 + 1.5, y, user, ha='center', va='center',
               fontsize=8, fontweight='bold')

    plt.title('Football Analytics Infrastructure Architecture',
             fontsize=14, fontweight='bold', pad=20)
    plt.tight_layout()

    return fig, ax

fig, ax = create_infrastructure_diagram()
plt.show()

#| label: data-governance-py
#| message: false
#| warning: false

# Data governance framework
def create_governance_checklist():
    """Create comprehensive governance checklist"""

    governance_data = {
        'category': [
            'Data Quality', 'Data Quality', 'Data Quality', 'Data Quality',
            'Access Control', 'Access Control', 'Access Control', 'Access Control',
            'Documentation', 'Documentation', 'Documentation', 'Documentation',
            'Ownership', 'Ownership', 'Ownership', 'Ownership'
        ],
        'item': [
            'Define quality metrics', 'Implement validation rules',
            'Create quality dashboards', 'Establish resolution process',
            'Define user roles', 'Implement permissions system',
            'Set up audit logging', 'Document access policies',
            'Create data dictionary', 'Document data lineage',
            'Build metadata repository', 'Version control setup',
            'Assign data owners', 'Define steward responsibilities',
            'Create escalation process', 'Establish change procedures'
        ],
        'priority': [
            'High', 'High', 'Medium', 'High',
            'High', 'High', 'Medium', 'High',
            'High', 'Medium', 'Medium', 'High',
            'High', 'High', 'Medium', 'Medium'
        ],
        'complexity': [
            'Medium', 'Medium', 'Low', 'Low',
            'Low', 'High', 'Medium', 'Low',
            'Medium', 'Medium', 'High', 'Low',
            'Low', 'Low', 'Low', 'Medium'
        ]
    }

    return pd.DataFrame(governance_data)

governance_df = create_governance_checklist()

# Map text values to numeric scores
priority_map = {'High': 3, 'Medium': 2, 'Low': 1}
complexity_map = {'High': 3, 'Medium': 2, 'Low': 1}

governance_df['priority_score'] = governance_df['priority'].map(priority_map)
governance_df['complexity_score'] = governance_df['complexity'].map(complexity_map)

# Visualize governance priorities
plt.figure(figsize=(10, 8))

categories = governance_df['category'].unique()
colors_map = {'Data Quality': '#e41a1c', 'Access Control': '#377eb8',
              'Documentation': '#4daf4a', 'Ownership': '#984ea3'}

for category in categories:
    data = governance_df[governance_df['category'] == category]
    plt.scatter(data['complexity_score'], data['priority_score'],
               label=category, color=colors_map[category],
               s=100, alpha=0.7)

plt.xlabel('Implementation Complexity', fontsize=12)
plt.ylabel('Priority', fontsize=12)
plt.title('Data Governance Implementation Priorities\nPriority vs. Complexity',
         fontsize=14, fontweight='bold')

plt.xticks([1, 2, 3], ['Low', 'Medium', 'High'])
plt.yticks([1, 2, 3], ['Low', 'Medium', 'High'])
plt.xlim(0.5, 3.5)
plt.ylim(0.5, 3.5)

plt.grid(True, alpha=0.3, linestyle='--')
plt.legend(title='Category', loc='best')
plt.tight_layout()
plt.show()

print("\nGovernance Checklist Summary:")
print("=" * 60)
print(governance_df[['category', 'item', 'priority', 'complexity']].to_string(index=False))

#| label: tool-evaluation-py
#| message: false
#| warning: false

def evaluate_analytics_tools():
    """Evaluate analytics tools across key criteria"""

    tools = ["R/RStudio", "Python/Jupyter", "Tableau", "Power BI",
             "Custom Dashboard", "Excel/Google Sheets"]

    criteria = ["Functionality", "Usability", "Integration",
                "Scalability", "Cost", "Support", "Security"]

    # Scoring matrix (1-5 scale)
    scores = np.array([
        [5, 3, 4, 5, 5, 5, 4],  # R/RStudio
        [5, 3, 5, 5, 5, 5, 4],  # Python/Jupyter
        [4, 5, 4, 4, 2, 4, 4],  # Tableau
        [4, 5, 5, 4, 3, 4, 4],  # Power BI
        [5, 3, 5, 5, 1, 2, 3],  # Custom Dashboard
        [2, 5, 5, 2, 5, 5, 3]   # Excel/Sheets
    ])

    # Create DataFrame
    df = pd.DataFrame(scores, columns=criteria)
    df.insert(0, 'Tool', tools)

    # Calculate weighted score
    weights = np.array([0.20, 0.15, 0.15, 0.15, 0.15, 0.10, 0.10])
    df['Weighted_Score'] = np.dot(scores, weights)

    df = df.sort_values('Weighted_Score', ascending=False)

    return df

tool_scores_df = evaluate_analytics_tools()

print("Analytics Tool Evaluation")
print("=" * 80)
print("\nScored on 1-5 scale across key criteria:\n")
print(tool_scores_df.to_string(index=False))

# Visualize tool comparison
fig, ax = plt.subplots(figsize=(10, 6))

tools = tool_scores_df['Tool'].values
scores = tool_scores_df['Weighted_Score'].values

bars = ax.barh(tools, scores, color='#2E86AB', alpha=0.7)

# Add score labels
for i, (tool, score) in enumerate(zip(tools, scores)):
    ax.text(score + 0.05, i, f'{score:.2f}',
           va='center', fontsize=10, fontweight='bold')

ax.set_xlabel('Weighted Score', fontsize=12)
ax.set_title('Analytics Tool Evaluation Summary\nWeighted scores across all criteria',
            fontsize=14, fontweight='bold')
ax.set_xlim(0, 5)
ax.grid(axis='x', alpha=0.3, linestyle='--')

plt.tight_layout()
plt.show()

#| label: workflow-process-py
#| message: false
#| warning: false

def create_request_workflow():
    """Define standard analytics request workflow"""

    workflow_data = {
        'Stage': ['Intake', 'Planning', 'Analysis', 'Review', 'Delivery', 'Follow-up'],
        'Owner': ['Analytics Lead', 'Assigned Analyst', 'Analyst Team',
                 'Senior Analyst', 'Analyst', 'Analytics Lead'],
        'Duration': ['1 day', '2-3 days', '5-10 days', '1-2 days', '1 day', 'Ongoing'],
        'Activities': [
            'Receive request; Initial triage; Scope definition',
            'Requirements gathering; Data assessment; Approach design',
            'Data collection; Analysis; Visualization; QA',
            'Quality review; Methodology check; Insights validation',
            'Presentation; Documentation; Stakeholder briefing',
            'Impact tracking; Feedback collection; Iteration'
        ],
        'Deliverables': [
            'Request ticket; Priority assignment',
            'Project plan; Timeline estimate',
            'Draft analysis; Visualizations',
            'Approved analysis',
            'Final report; Dashboard; Documentation',
            'Impact metrics; Lessons learned'
        ]
    }

    return pd.DataFrame(workflow_data)

workflow_df = create_request_workflow()

print("Analytics Request Workflow")
print("=" * 100)
print("\nStandard process for analytics projects:\n")
print(workflow_df.to_string(index=False))

# Create workflow visualization
fig, ax = plt.subplots(figsize=(12, 6))

stages = workflow_df['Stage'].values
durations_text = workflow_df['Duration'].values

# Extract numeric durations (approximate for visualization)
duration_map = {
    '1 day': 1,
    '2-3 days': 2.5,
    '5-10 days': 7.5,
    '1-2 days': 1.5,
    'Ongoing': 3
}
durations = [duration_map[d] for d in durations_text]

# Create horizontal timeline
y_pos = np.arange(len(stages))
bars = ax.barh(y_pos, durations, color='#2E86AB', alpha=0.7)

# Add labels
ax.set_yticks(y_pos)
ax.set_yticklabels(stages)
ax.set_xlabel('Typical Duration (days)', fontsize=12)
ax.set_title('Analytics Request Workflow Timeline',
            fontsize=14, fontweight='bold')

# Add duration labels
for i, (stage, dur_text, dur_num) in enumerate(zip(stages, durations_text, durations)):
    ax.text(dur_num + 0.2, i, dur_text,
           va='center', fontsize=9)

ax.grid(axis='x', alpha=0.3, linestyle='--')
plt.tight_layout()
plt.show()

#| label: integration-calendar-py
#| message: false
#| warning: false

def create_analytics_calendar(season_phase='in_season'):
    """Create analytics meeting calendar by season phase"""

    if season_phase == 'in_season':
        calendar_data = {
            'Day': ['Monday', 'Monday', 'Tuesday', 'Wednesday',
                   'Thursday', 'Friday', 'Sunday'],
            'Time': ['8:00 AM', '2:00 PM', '10:00 AM', '1:00 PM',
                    '9:00 AM', '3:00 PM', 'Halftime'],
            'Meeting': ['Game Review', 'Opponent Prep Kickoff',
                       'Analytics Deep Dive', 'Game Plan Review',
                       'Situational Prep', 'Final Analytics Brief',
                       'Live Adjustments'],
            'Participants': ['Coaches, Analysts', 'Scouts, Analysts',
                            'Coaches, Analysts', 'Offensive staff, Analysts',
                            'Special teams, Analysts', 'All coaches, Analysts',
                            'Coordinators, Analyst'],
            'Duration': ['2 hours', '1 hour', '1.5 hours', '1 hour',
                        '1 hour', '30 min', '10 min'],
            'Outputs': ['Performance report; Key insights',
                       'Initial scouting report',
                       'Tendency analysis; Personnel insights',
                       'Play selection guidance',
                       '4th down chart; 2-pt scenarios',
                       'Game day recommendations',
                       'Real-time insights']
        }
    else:  # offseason
        calendar_data = {
            'Day': ['Monday', 'Tuesday', 'Wednesday', 'Thursday'],
            'Time': ['10:00 AM', '2:00 PM', '11:00 AM', '1:00 PM'],
            'Meeting': ['Draft Prep', 'Analytics Research',
                       'Free Agency Review', 'Strategic Planning'],
            'Participants': ['Scouts, Analysts, GM', 'Analysts only',
                            'Personnel, Analysts', 'Leadership, Analysts'],
            'Duration': ['2 hours', '3 hours', '1.5 hours', '2 hours'],
            'Outputs': ['Player evaluations; Board updates',
                       'New models; Process improvements',
                       'Contract analysis; Market comps',
                       'Long-term initiatives']
        }

    return pd.DataFrame(calendar_data)

# Display in-season calendar
in_season_cal = create_analytics_calendar('in_season')

print("In-Season Analytics Calendar")
print("=" * 100)
print("\nRegular touchpoints and meetings during game weeks:\n")
print(in_season_cal.to_string(index=False))