"""
Validation script for Retrosheet-based OF arm ratings

This script:
1. Loads 2005 Retrosheet events data
2. Calculates arm ratings using the new Retrosheet method
3. Compares against known strong/weak arms from 2005
4. Generates a detailed report

Usage:
    python test_retrosheet_arms.py
"""

import pandas as pd
from defenders.retrosheet_arm_calculator import (
    calculate_of_arms_from_retrosheet,
)


def main():
    print("=" * 80)
    print("RETROSHEET ARM RATING VALIDATION - 2005 SEASON")
    print("=" * 80)
    print()

    # Load Retrosheet events
    print("Loading Retrosheet events data...")
    events_file = "data-input/retrosheet/retrosheets_events_2005.csv"
    df_events = pd.read_csv(events_file, low_memory=False)
    print(f"Loaded {len(df_events):,} events")
    print()

    # Calculate arm ratings
    print("Calculating arm ratings for all outfielders...")
    arm_ratings = calculate_of_arms_from_retrosheet(df_events, season_pct=1.0)
    print(f"Calculated ratings for {len(arm_ratings)} outfielders")
    print()

    # Distribution summary
    print("ARM RATING DISTRIBUTION")
    print("-" * 80)
    ratings_series = pd.Series(list(arm_ratings.values()))
    for rating in sorted(ratings_series.unique()):
        count = (ratings_series == rating).sum()
        pct = count / len(ratings_series) * 100
        stars = "*" * int(pct / 2)
        print(f"Rating {rating:+2d}: {count:3d} players ({pct:5.1f}%) {stars}")
    print()

    # Show top and bottom performers
    print("TOP 20 ARM RATINGS (Elite Arms)")
    print("-" * 80)
    sorted_players = sorted(arm_ratings.items(), key=lambda x: x[1])
    top_20 = sorted_players[:20]

    for i, (player_id, rating) in enumerate(top_20, 1):
        # Get their stats
        player_stats = get_player_arm_stats(df_events, player_id)
        print(
            f"{i:2d}. {player_id:12s} Rating: {rating:+2d}  "
            f"Assists: {player_stats['assists']:2d}  "
            f"Home Throws: {player_stats['home_throws']:2d}  "
            f"Assist Rate: {player_stats['assist_rate']:.2f}%  "
            f"Balls: {player_stats['balls_fielded']:3d}"
        )
    print()

    print("BOTTOM 15 ARM RATINGS (Weak Arms)")
    print("-" * 80)
    bottom_15 = sorted_players[-15:]
    for i, (player_id, rating) in enumerate(bottom_15, 1):
        player_stats = get_player_arm_stats(df_events, player_id)
        print(
            f"{i:2d}. {player_id:12s} Rating: {rating:+2d}  "
            f"Assists: {player_stats['assists']:2d}  "
            f"Assist Rate: {player_stats['assist_rate']:.2f}%  "
            f"Balls: {player_stats['balls_fielded']:3d}"
        )
    print()

    # Known strong arms to validate
    print("VALIDATION: Known Strong Arms (2005)")
    print("-" * 80)
    known_strong_arms = [
        ("suzui001", "Ichiro Suzuki", "RF", "Gold Glove, legendary arm"),
        ("crawc002", "Carl Crawford", "LF", "Multiple stolen base deterrent"),
        ("edmoj001", "Jim Edmonds", "CF", "Gold Glove, strong arm"),
        ("guerv001", "Vladimir Guerrero", "RF", "Feared arm"),
    ]

    for player_id, name, pos, notes in known_strong_arms:
        rating = arm_ratings.get(player_id, "NOT FOUND")
        if rating != "NOT FOUND":
            stats = get_player_arm_stats(df_events, player_id)
            print(
                f"{name:20s} ({pos}): Rating {rating:+2d}  "
                f"Assists: {stats['assists']:2d}  "
                f"Note: {notes}"
            )
        else:
            print(f"{name:20s} ({pos}): NOT FOUND IN DATA - Check player_id")
    print()

    # Position breakdown
    print("ARM RATINGS BY POSITION")
    print("-" * 80)
    position_stats = get_position_breakdown(df_events, arm_ratings)
    for pos, stats in position_stats.items():
        print(f"\n{pos}:")
        print(f"  Total Players: {stats['count']}")
        print(f"  Average Rating: {stats['avg_rating']:.2f}")
        print(f"  Std Dev: {stats['std_rating']:.2f}")
        print(f"  Elite Arms (≤-3): {stats['elite_count']}")
        print(f"  Weak Arms (≥+2): {stats['weak_count']}")
    print()

    # Detailed player report
    print("DETAILED PLAYER REPORT (Elite Arms Only)")
    print("-" * 80)
    elite_players = [(p, r) for p, r in arm_ratings.items() if r <= -3]
    elite_players.sort(key=lambda x: x[1])

    for player_id, rating in elite_players:
        print(f"\nPlayer: {player_id} (Rating: {rating:+2d})")
        detailed_stats = get_detailed_player_stats(df_events, player_id)
        for key, value in detailed_stats.items():
            print(f"  {key:20s}: {value}")

    print("\n" + "=" * 80)
    print("VALIDATION COMPLETE")
    print("=" * 80)


def get_player_arm_stats(df_events, player_id):
    """Get basic arm stats for a player across all OF positions."""
    stats = {"assists": 0, "home_throws": 0, "balls_fielded": 0, "assist_rate": 0.0}

    for a_col, po_col, f_col in [
        ("a7", "po7", "f7"),
        ("a8", "po8", "f8"),
        ("a9", "po9", "f9"),
    ]:
        player_plays = df_events[df_events[f_col] == player_id]

        if len(player_plays) > 0:
            fielder_num = int(a_col[-1])
            assists = player_plays[player_plays[a_col] > 0].shape[0]
            balls = player_plays[
                (player_plays[po_col] > 0) | (player_plays[a_col] > 0)
            ].shape[0]

            home = player_plays[
                (player_plays[a_col] > 0)
                & (
                    (player_plays["brout1"] == fielder_num)
                    | (player_plays["brout2"] == fielder_num)
                    | (player_plays["brout3"] == fielder_num)
                )
            ].shape[0]

            stats["assists"] += assists
            stats["home_throws"] += home
            stats["balls_fielded"] += balls

    if stats["balls_fielded"] > 0:
        stats["assist_rate"] = stats["assists"] / stats["balls_fielded"] * 100

    return stats


def get_detailed_player_stats(df_events, player_id):
    """Get detailed breakdown of arm-related plays."""
    detailed = {}

    for pos_name, a_col, po_col, f_col in [
        ("LF", "a7", "po7", "f7"),
        ("CF", "a8", "po8", "f8"),
        ("RF", "a9", "po9", "f9"),
    ]:
        player_plays = df_events[df_events[f_col] == player_id]

        if len(player_plays) == 0:
            continue

        fielder_num = int(a_col[-1])

        balls_fielded = player_plays[
            (player_plays[po_col] > 0) | (player_plays[a_col] > 0)
        ].shape[0]

        if balls_fielded < 50:
            continue

        assists = player_plays[player_plays[a_col] > 0].shape[0]

        throwouts = player_plays[
            (player_plays[a_col] > 0)
            & (
                (player_plays["brout1"] == fielder_num)
                | (player_plays["brout2"] == fielder_num)
                | (player_plays["brout3"] == fielder_num)
                | (player_plays["brout_b"] == fielder_num)
            )
        ].shape[0]

        home_throws = player_plays[
            (player_plays[a_col] > 0)
            & (
                (player_plays["brout1"] == fielder_num)
                | (player_plays["brout2"] == fielder_num)
                | (player_plays["brout3"] == fielder_num)
            )
        ].shape[0]

        batter_extra = player_plays[
            (player_plays[a_col] > 0) & (player_plays["brout_b"] == fielder_num)
        ].shape[0]

        detailed[f"{pos_name} Balls Fielded"] = balls_fielded
        detailed[f"{pos_name} Total Assists"] = assists
        detailed[f"{pos_name} Throwouts"] = throwouts
        detailed[f"{pos_name} Home Throws"] = home_throws
        detailed[f"{pos_name} Batter Extra Outs"] = batter_extra
        detailed[f"{pos_name} Assist Rate"] = (
            f"{assists/balls_fielded*100:.2f}%" if balls_fielded > 0 else "N/A"
        )

    return detailed


def get_position_breakdown(df_events, arm_ratings):
    """Get statistical breakdown by position."""
    positions = {}

    for pos_name, f_col in [("LF", "f7"), ("CF", "f8"), ("RF", "f9")]:
        fielders = df_events[f_col].dropna().unique()
        pos_ratings = []

        for fielder in fielders:
            if fielder in arm_ratings:
                # Check if they qualified at this position
                player_plays = df_events[df_events[f_col] == fielder]
                a_col = f"a{f_col[-1]}"
                po_col = f"po{f_col[-1]}"
                balls = player_plays[
                    (player_plays[po_col] > 0) | (player_plays[a_col] > 0)
                ].shape[0]

                if balls >= 50:
                    pos_ratings.append(arm_ratings[fielder])

        if pos_ratings:
            positions[pos_name] = {
                "count": len(pos_ratings),
                "avg_rating": pd.Series(pos_ratings).mean(),
                "std_rating": pd.Series(pos_ratings).std(),
                "elite_count": sum(1 for r in pos_ratings if r <= -3),
                "weak_count": sum(1 for r in pos_ratings if r >= 2),
            }

    return positions


if __name__ == "__main__":
    main()