#!/usr/bin/env python3
"""
Generate summary statistics across all tasks and architectures
"""

import pandas as pd
import os
from pathlib import Path


def generate_model_summary(output_dir: Path):
    """Generate a summary comparing models across all tasks and architectures"""

    # Read the task-level statistics
    task_time_df = pd.read_csv(output_dir / "task_time_statistics.csv")
    task_token_df = pd.read_csv(output_dir / "task_token_statistics.csv")

    # Merge time and token data
    merged_df = pd.merge(
        task_time_df,
        task_token_df,
        on=["task", "architecture", "model", "count"],
        suffixes=("_time", "_token"),
    )

    # Group by model to get overall statistics
    model_summary = (
        merged_df.groupby("model")
        .agg(
            {
                "count": "sum",
                "mean_time": "mean",
                "p90_time": "mean",
                "p99_time": "mean",
                "cv_time": "mean",
                "throughput_tasks_per_hour": "mean",
                "mean_total": "mean",
                "cv_total": "mean",
                "mean_input": "mean",
                "cv_input": "mean",
                "mean_output": "mean",
                "cv_output": "mean",
                "mean_reasoning": "mean",
                "cv_reasoning": "mean",
                "mean_result": "mean",
                "cv_result": "mean",
            }
        )
        .round(2)
    )

    # Rename columns for clarity
    model_summary.columns = [
        "total_runs",
        "avg_mean_time_sec",
        "avg_p90_time_sec",
        "avg_p99_time_sec",
        "avg_cv_time_pct",
        "avg_throughput_tasks_per_hour",
        "avg_mean_total_tokens",
        "avg_cv_total_tokens_pct",
        "avg_input_tokens",
        "avg_cv_input_pct",
        "avg_output_tokens",
        "avg_cv_output_pct",
        "avg_reasoning_tokens",
        "avg_cv_reasoning_pct",
        "avg_result_tokens",
        "avg_cv_result_pct",
    ]

    # Sort by average time
    model_summary = model_summary.sort_values("avg_mean_time_sec")

    # Save to CSV
    model_summary.to_csv(output_dir / "model_summary.csv")
    print(f"Model summary saved to {output_dir / 'model_summary.csv'}")
    print("\n" + "=" * 80)
    print("MODEL PERFORMANCE SUMMARY (sorted by average time)")
    print("=" * 80)
    print(model_summary.to_string())

    # Generate task-architecture summary
    task_arch_summary = (
        merged_df.groupby(["task", "architecture"])
        .agg(
            {
                "mean_time": ["min", "max", "mean"],
                "cv_time": "mean",
                "mean_total": ["min", "max", "mean"],
                "cv_total": "mean",
            }
        )
        .round(2)
    )

    task_arch_summary.columns = [
        "time_min",
        "time_max",
        "time_mean",
        "cv_time_pct",
        "tokens_min",
        "tokens_max",
        "tokens_mean",
        "cv_total_pct",
    ]

    task_arch_summary.to_csv(output_dir / "task_architecture_summary.csv")
    print(
        f"\nTask-architecture summary saved to {output_dir / 'task_architecture_summary.csv'}"
    )
    print("\n" + "=" * 80)
    print("TASK-ARCHITECTURE SUMMARY")
    print("=" * 80)
    print(task_arch_summary.to_string())

    # Generate architecture comparison
    arch_summary = (
        merged_df.groupby("architecture")
        .agg(
            {
                "count": "sum",
                "mean_time": "mean",
                "cv_time": "mean",
                "throughput_tasks_per_hour": "mean",
                "mean_total": "mean",
                "cv_total": "mean",
            }
        )
        .round(2)
    )

    arch_summary.columns = [
        "total_runs",
        "avg_time_sec",
        "avg_cv_time_pct",
        "avg_throughput_tasks_per_hour",
        "avg_total_tokens",
        "avg_cv_total_pct",
    ]
    arch_summary.to_csv(output_dir / "architecture_summary.csv")
    print(f"\nArchitecture summary saved to {output_dir / 'architecture_summary.csv'}")
    print("\n" + "=" * 80)
    print("ARCHITECTURE COMPARISON")
    print("=" * 80)
    print(arch_summary.to_string())

    # Generate best/worst performers
    print("\n" + "=" * 80)
    print("BEST PERFORMERS (by mean time)")
    print("=" * 80)
    best_performers = merged_df.nsmallest(10, "mean_time")[
        ["task", "architecture", "model", "mean_time", "mean_total"]
    ]
    print(best_performers.to_string(index=False))

    print("\n" + "=" * 80)
    print("SLOWEST PERFORMERS (by mean time)")
    print("=" * 80)
    worst_performers = merged_df.nlargest(10, "mean_time")[
        ["task", "architecture", "model", "mean_time", "mean_total"]
    ]
    print(worst_performers.to_string(index=False))

    # Token efficiency analysis
    merged_df["tokens_per_second"] = merged_df["mean_total"] / merged_df["mean_time"]

    print("\n" + "=" * 80)
    print("TOKEN THROUGHPUT (tokens per second)")
    print("=" * 80)
    throughput_summary = (
        merged_df.groupby("model")["tokens_per_second"]
        .mean()
        .round(2)
        .sort_values(ascending=False)
    )
    print(throughput_summary.to_string())

    throughput_summary.to_csv(
        output_dir / "token_throughput_by_model.csv", header=["avg_tokens_per_second"]
    )
    print(f"\nToken throughput saved to {output_dir / 'token_throughput_by_model.csv'}")


def generate_agent_summary(output_dir: Path):
    """Generate summary statistics for agents"""

    # Read agent statistics
    agent_time_df = pd.read_csv(output_dir / "agent_time_statistics.csv")
    agent_token_df = pd.read_csv(output_dir / "agent_token_statistics.csv")

    # Top 10 slowest agents (by mean time)
    print("\n" + "=" * 80)
    print("TOP 10 SLOWEST AGENTS (by mean time)")
    print("=" * 80)
    slowest_agents = agent_time_df.nlargest(10, "mean_time")[
        ["agent", "task", "architecture", "model", "mean_time", "count"]
    ]
    print(slowest_agents.to_string(index=False))
    slowest_agents.to_csv(output_dir / "top_10_slowest_agents.csv", index=False)

    # Top 10 fastest agents (with at least 10 samples)
    print("\n" + "=" * 80)
    print("TOP 10 FASTEST AGENTS (by mean time, min 10 samples)")
    print("=" * 80)
    fastest_agents = agent_time_df[agent_time_df["count"] >= 10].nsmallest(
        10, "mean_time"
    )[["agent", "task", "architecture", "model", "mean_time", "count"]]
    print(fastest_agents.to_string(index=False))
    fastest_agents.to_csv(output_dir / "top_10_fastest_agents.csv", index=False)

    # Merge agent data
    agent_merged = pd.merge(
        agent_time_df,
        agent_token_df,
        on=["task", "architecture", "agent", "model", "count"],
        suffixes=("_time", "_token"),
    )

    # Top 10 most token-hungry agents
    print("\n" + "=" * 80)
    print("TOP 10 MOST TOKEN-HUNGRY AGENTS (by mean total tokens)")
    print("=" * 80)
    token_hungry = agent_merged.nlargest(10, "mean_total")[
        ["agent", "task", "architecture", "model", "mean_total", "mean_time"]
    ]
    print(token_hungry.to_string(index=False))
    token_hungry.to_csv(output_dir / "top_10_token_hungry_agents.csv", index=False)

    # Agent efficiency (tokens per second)
    agent_merged["tokens_per_second"] = (
        agent_merged["mean_total"] / agent_merged["mean_time"]
    )

    print("\n" + "=" * 80)
    print("TOP 10 HIGHEST THROUGHPUT AGENTS (tokens/second)")
    print("=" * 80)
    high_throughput = agent_merged.nlargest(10, "tokens_per_second")[
        [
            "agent",
            "task",
            "architecture",
            "model",
            "tokens_per_second",
            "mean_time",
            "mean_total",
        ]
    ]
    print(high_throughput.to_string(index=False))
    high_throughput.to_csv(
        output_dir / "top_10_high_throughput_agents.csv", index=False
    )


if __name__ == "__main__":
    print("Generating summary statistics...\n")

    # Change to the script directory
    script_dir = os.path.dirname(os.path.abspath(__file__))
    os.chdir(script_dir)

    output_dir = Path(script_dir) / "performance_reports"
    output_dir.mkdir(parents=True, exist_ok=True)

    generate_model_summary(output_dir)
    generate_agent_summary(output_dir)

    print("\n" + "=" * 80)
    print("Summary generation complete!")
    print("=" * 80)