#!/usr/bin/env python3
"""
Analyze RETRY patterns in GameBuilder project
Collect statistics on error locations, RETRY counts, RETRY rates, etc.
"""

import os
import re
from pathlib import Path
from collections import defaultdict
import json
import csv

# Define base path and model list
BASE_DIR = Path("/Users/wzr/TOSEM-2025/RESULTS")
MODELS = [
    "DeepSeek-R1",
    "DeepSeek-V3-1",
    "GPT-4o-mini",
    "GPT-5",
    "Gemini-2.5-flash",
    "Gemini-2.5-flash-nothinking",
    "Qwen3-235b",
]
PROJECT_NAME = "GameBuilder"


def extract_error_info(line: str) -> dict:
    """Extract error information from error line

    Returns:
        {'has_error': bool, 'node_type': str, 'node_name': str, 'error_msg': str}
    """
    # Remove tree structure characters
    clean = re.sub(r"^[│├└\-\s]+", "", line).strip()

    # Check if there is an error marker
    if "❌" not in clean:
        return {"has_error": False}

    # Remove error marker
    clean = clean.split("❌", 1)[1].lstrip()

    # Extract node type and name
    node_match = re.match(
        r"\[(SPAN|Chain|AGENT|Tool|LLM)\]\s+([^\[\]]+?)(?:\s+\[ERROR:(.*))?$",
        clean,
    )
    if not node_match:
        return {
            "has_error": True,
            "node_type": "Unknown",
            "node_name": "Unknown",
            "error_msg": "",
        }

    node_type = node_match.group(1)
    node_name = node_match.group(2).strip()
    error_msg = node_match.group(3).strip() if node_match.group(3) else ""

    # Clean node name
    if node_type == "AGENT":
        node_name = re.sub(r"\._execute_core$", "", node_name)
    elif node_type == "Tool":
        node_name = re.sub(r"\._use$", "", node_name)
    elif node_type == "Chain":
        node_name = re.sub(r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", node_name)

    return {
        "has_error": True,
        "node_type": node_type,
        "node_name": node_name,
        "error_msg": error_msg,
    }


def extract_retry_info(line: str) -> dict:
    """Extract RETRY information from RETRY line

    Returns:
        {'is_retry': bool, 'retry_number': int, 'node_type': str, 'node_name': str}
    """
    # Remove tree structure characters
    clean = re.sub(r"^[│├└\-\s]+", "", line).strip()

    # Check if contains RETRY marker: (retry N) or [RETRYN]
    retry_match = re.search(r"\(retry\s+(\d+)\)", clean)
    if not retry_match:
        retry_match = re.search(r"\[RETRY(\d+)\]", clean)

    if not retry_match:
        return {"is_retry": False}

    retry_number = int(retry_match.group(1))

    # Extract node type and name
    node_match = re.match(
        r"\[(SPAN|Chain|AGENT)\]\s+([^\[\]]+?)(?:\s+\(retry\s+\d+\))?(?:\s+\[RETRY\d+\])?\s*(?:\[.*)?$",
        clean,
    )
    if not node_match:
        return {
            "is_retry": True,
            "retry_number": retry_number,
            "node_type": "Unknown",
            "node_name": "Unknown",
        }

    node_type = node_match.group(1)
    node_name = node_match.group(2).strip()

    return {
        "is_retry": True,
        "retry_number": retry_number,
        "node_type": node_type,
        "node_name": node_name,
    }


def analyze_session(md_file: str) -> dict:
    """Analyze execution_path.md for a single session

    Returns:
        {
            'has_error': bool,
            'has_retry': bool,
            'max_retry_number': int,
            'total_retries': int,
            'errors': [{'node_type': str, 'node_name': str, 'error_msg': str}, ...],
            'retries': [{'retry_number': int, 'node_type': str, 'node_name': str}, ...]
        }
    """
    if not os.path.exists(md_file):
        return None

    with open(md_file, "r", encoding="utf-8") as f:
        content = f.read()

    # Extract Execution Path Tree section
    tree_match = re.search(
        r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL
    )
    if not tree_match:
        return None

    tree_content = tree_match.group(1)

    errors = []
    retries = []

    for line in tree_content.split("\n"):
        if not line.strip():
            continue

        # Check for errors
        error_info = extract_error_info(line)
        if error_info["has_error"]:
            errors.append(
                {
                    "node_type": error_info.get("node_type", "Unknown"),
                    "node_name": error_info.get("node_name", "Unknown"),
                    "error_msg": error_info.get("error_msg", ""),
                }
            )

        # Check for RETRY
        retry_info = extract_retry_info(line)
        if retry_info["is_retry"]:
            retries.append(
                {
                    "retry_number": retry_info["retry_number"],
                    "node_type": retry_info["node_type"],
                    "node_name": retry_info["node_name"],
                }
            )

    max_retry = max([r["retry_number"] for r in retries]) if retries else 0

    return {
        "has_error": len(errors) > 0,
        "has_retry": len(retries) > 0,
        "max_retry_number": max_retry,
        "total_retries": len(retries),
        "errors": errors,
        "retries": retries,
    }


def collect_model_stats(model_name: str) -> dict:
    """Collect RETRY statistics for a single model

    Returns:
        {
            'model': str,
            'total_sessions': int,
            'sessions_with_error': int,
            'sessions_with_retry': int,
            'total_retry_attempts': int,
            'retry_rate': float,
            'error_by_agent': {agent_name: count},
            'error_types': {error_msg: count},
            'max_retry_number': int,
            'session_details': [...]
        }
    """
    test_results_dir = BASE_DIR / model_name / PROJECT_NAME / "test_results"

    if not test_results_dir.exists():
        return None

    stats = {
        "model": model_name,
        "total_sessions": 0,
        "sessions_with_error": 0,
        "sessions_with_retry": 0,
        "total_retry_attempts": 0,
        "error_by_agent": defaultdict(int),
        "error_by_node_type": defaultdict(int),
        "error_types": defaultdict(int),
        "max_retry_number": 0,
        "session_details": [],
    }

    for session_dir in sorted(test_results_dir.iterdir()):
        if not session_dir.is_dir():
            continue

        exec_path_file = session_dir / "execution_path.md"
        if not exec_path_file.exists():
            continue

        stats["total_sessions"] += 1

        analysis = analyze_session(str(exec_path_file))
        if not analysis:
            continue

        # Collect error and RETRY statistics
        if analysis["has_error"]:
            stats["sessions_with_error"] += 1

        if analysis["has_retry"]:
            stats["sessions_with_retry"] += 1
            stats["total_retry_attempts"] += analysis["total_retries"]
            stats["max_retry_number"] = max(
                stats["max_retry_number"], analysis["max_retry_number"]
            )

        # Collect error locations
        for error in analysis["errors"]:
            if error["node_type"] == "AGENT":
                stats["error_by_agent"][error["node_name"]] += 1
            stats["error_by_node_type"][error["node_type"]] += 1

            # Extract short description of error type
            error_msg = error["error_msg"]
            if error_msg:
                # Take first 100 characters as error type identifier
                error_type = (
                    error_msg[:100]
                    if len(error_msg) <= 100
                    else error_msg[:100] + "..."
                )
                stats["error_types"][error_type] += 1

        # Save session details
        stats["session_details"].append(
            {
                "session": session_dir.name,
                "has_error": analysis["has_error"],
                "has_retry": analysis["has_retry"],
                "retry_count": analysis["total_retries"],
                "errors": analysis["errors"],
                "retries": analysis["retries"],
            }
        )

    # Calculate RETRY rate
    stats["retry_rate"] = (
        (stats["sessions_with_retry"] / stats["total_sessions"] * 100)
        if stats["total_sessions"] > 0
        else 0
    )
    stats["error_rate"] = (
        (stats["sessions_with_error"] / stats["total_sessions"] * 100)
        if stats["total_sessions"] > 0
        else 0
    )

    # Convert defaultdict to regular dict
    stats["error_by_agent"] = dict(stats["error_by_agent"])
    stats["error_by_node_type"] = dict(stats["error_by_node_type"])
    stats["error_types"] = dict(stats["error_types"])

    return stats


def print_summary(all_stats):
    """Print statistical summary"""
    print("\n" + "=" * 100)
    print(f"RETRY Pattern Analysis Summary - {PROJECT_NAME}")
    print("=" * 100 + "\n")

    # Overall statistics table
    print("## Model Statistics\n")
    print(
        f"{'Model':<35} {'Total Sessions':<12} {'Error Rate':<12} {'RETRY Rate':<12} {'Total RETRYs':<12} {'Max RETRY':<10}"
    )
    print("-" * 100)

    for stats in all_stats:
        if stats:
            print(
                f"{stats['model']:<35} {stats['total_sessions']:<12} "
                f"{stats['error_rate']:>10.1f}% {stats['retry_rate']:>10.1f}% "
                f"{stats['total_retry_attempts']:<12} {stats['max_retry_number']:<10}"
            )

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

    # Detailed information for each model
    for stats in all_stats:
        if not stats or stats["sessions_with_error"] == 0:
            continue

        print(f"\n### 📊 {stats['model']}\n")
        print(f"- **Total Sessions**: {stats['total_sessions']}")
        print(
            f"- **Sessions with Errors**: {stats['sessions_with_error']} ({stats['error_rate']:.1f}%)"
        )
        print(
            f"- **Sessions with RETRY**: {stats['sessions_with_retry']} ({stats['retry_rate']:.1f}%)"
        )
        print(f"- **Total RETRY Attempts**: {stats['total_retry_attempts']}")
        print(f"- **Max RETRY Number**: {stats['max_retry_number']}")

        if stats["error_by_agent"]:
            print(f"\n**Errors by AGENT**:")
            for agent, count in sorted(
                stats["error_by_agent"].items(), key=lambda x: x[1], reverse=True
            ):
                print(f"  - {agent}: {count} times")

        if stats["error_by_node_type"]:
            print(f"\n**Errors by Node Type**:")
            for node_type, count in sorted(
                stats["error_by_node_type"].items(), key=lambda x: x[1], reverse=True
            ):
                print(f"  - {node_type}: {count} times")

        if stats["error_types"]:
            print(f"\n**Error Types (Top 5)**:")
            for error_type, count in sorted(
                stats["error_types"].items(), key=lambda x: x[1], reverse=True
            )[:5]:
                print(f"  - [{count} times] {error_type}")

        print("\n" + "-" * 100)


def save_results(all_stats):
    """Save results to files"""
    output_dir = Path(__file__).parent

    # Save detailed JSON
    json_file = output_dir / "retry_analysis.json"
    json_data = []
    for stats in all_stats:
        if stats:
            json_data.append(stats)

    with open(json_file, "w", encoding="utf-8") as f:
        json.dump(json_data, f, indent=2, ensure_ascii=False)
    print(f"\n✅ Detailed JSON results saved: {json_file}")

    # Save CSV summary
    csv_file = output_dir / "retry_summary.csv"
    with open(csv_file, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(
            [
                "Model",
                "Total_Sessions",
                "Sessions_With_Error",
                "Error_Rate(%)",
                "Sessions_With_Retry",
                "Retry_Rate(%)",
                "Total_Retry_Attempts",
                "Max_Retry_Number",
            ]
        )

        for stats in all_stats:
            if stats:
                writer.writerow(
                    [
                        stats["model"],
                        stats["total_sessions"],
                        stats["sessions_with_error"],
                        f"{stats['error_rate']:.2f}",
                        stats["sessions_with_retry"],
                        f"{stats['retry_rate']:.2f}",
                        stats["total_retry_attempts"],
                        stats["max_retry_number"],
                    ]
                )

    print(f"✅ CSV summary saved: {csv_file}")

    # Save error location statistics
    error_csv_file = output_dir / "error_by_agent.csv"
    with open(error_csv_file, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["Model", "Agent_Name", "Error_Count"])

        for stats in all_stats:
            if stats and stats["error_by_agent"]:
                for agent, count in sorted(
                    stats["error_by_agent"].items(), key=lambda x: x[1], reverse=True
                ):
                    writer.writerow([stats["model"], agent, count])

    print(f"✅ Error location statistics saved: {error_csv_file}")


if __name__ == "__main__":
    print(f"Starting RETRY pattern analysis - {PROJECT_NAME}...")

    all_stats = []
    for model in MODELS:
        print(f"\n📊 Analyzing model: {model}")
        stats = collect_model_stats(model)
        if stats:
            all_stats.append(stats)
            print(
                f"  ✅ Completed: {stats['total_sessions']} sessions, "
                f"{stats['sessions_with_error']} errors, "
                f"{stats['sessions_with_retry']} retries"
            )
        else:
            print(f"  ⚠️  Skipped (directory not found)")

    print_summary(all_stats)
    save_results(all_stats)

    print("\n" + "=" * 100)
    print("✅ Analysis completed!")
    print("=" * 100)