#!/usr/bin/env python3
"""
Trajectory evaluation script for the SocialMediaManager-MCP project.

Evaluates 6 trajectory metrics:
1. Exact match
2. In-order match
3. Any-order match
4. Precision
5. Recall
6. Single-tool use

Features:
- Dynamic reference trajectories: tool calls within each AGENT can be permuted
- Automatically selects the best reference trajectory based on a combined score of
  exact_match, in_order_match, and any_order_match
"""

import os
import re
import yaml
from pathlib import Path
from typing import List, Dict, Tuple, Set
from collections import defaultdict
import pandas as pd
import math
from itertools import permutations, product


class TrajectoryParser:
    """Parse an execution_path.md file and extract the full execution trajectory."""

    def __init__(self, md_file_path: str, extract_types: List[str] = None):
        """
        Args:
            md_file_path: Path to execution_path.md
            extract_types: Node types to extract. Default is ['Tool'].
                          Supported types: 'SPAN', 'Chain', 'Tool', 'AGENT', 'LLM',
                          'Task Created', 'Crew Created'
        """
        self.md_file_path = md_file_path
        self.extract_types = extract_types or ["Tool"]
        self.trajectory = []

    def parse(self) -> List[str]:
        """Parse the file and return the trajectory sequence."""
        if not os.path.exists(self.md_file_path):
            return []

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

        # Extract the "Execution Path Tree" section (inside a fenced code block)
        tree_match = re.search(
            r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL
        )
        if not tree_match:
            return []

        tree_content = tree_match.group(1)
        trajectory = []

        for line in tree_content.split("\n"):
            # Remove tree drawing characters and keep the node content
            clean_line = re.sub(r"^[│├└─\s]+", "", line).strip()
            if not clean_line:
                continue

            # Remove the error marker (❌) - translation artifact only
            clean_line = re.sub(r"^❌\s+", "", clean_line)

            # Remove retry markers: "(retry N)" and "[RETRYN]"
            clean_line = re.sub(r"\s*\(retry\s+\d+\)", "", clean_line)
            clean_line = re.sub(r"\s*\[RETRY\d+\]", "", clean_line)

            # Remove ERROR details while keeping the node type and name
            clean_line = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean_line)

            # Extract node info
            node_info = self._extract_node_info(clean_line)

            if node_info and node_info["type"] in self.extract_types:
                trajectory.append(node_info["action"])

        self.trajectory = trajectory
        return trajectory

    def _extract_node_info(self, line: str) -> dict:
        """Extract node information from a single line.

        Note: the input line should already have the error marker (❌),
              retry markers, and ERROR information removed.

        Returns:
            {'type': str, 'action': str} or None
        """
        # SPAN node: [SPAN] span_name [stats]
        # Use a more tolerant regex to handle potential trailing special characters
        span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if span_match:
            span_name = span_match.group(1).strip()
            return {"type": "SPAN", "action": f"SPAN: {span_name}"}

        # Chain node: [Chain] chain_name [stats]
        # For Crew_xxx.kickoff, normalize to the wildcard Crew***.kickoff
        chain_match = re.match(r"\[Chain\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if chain_match:
            chain_name = chain_match.group(1).strip()
            # Wildcard normalization: Crew_UUID.kickoff -> Crew***.kickoff
            chain_name = re.sub(
                r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", chain_name
            )
            return {"type": "Chain", "action": f"Chain: {chain_name}"}

        # AGENT node: [AGENT] agent_name._execute_core [stats]
        agent_match = re.match(r"\[AGENT\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if agent_match:
            agent_name = agent_match.group(1).strip()
            # Remove the ._execute_core suffix
            agent_name = re.sub(r"\._execute_core$", "", agent_name)
            return {"type": "Agent", "action": f"Agent: {agent_name}"}

        # Tool node: [Tool] tool_name._use [duration]
        tool_match = re.match(
            r"\[Tool\]\s+([^\[\]]+?)(?:\s+\[[\d.]+(?:ms|s)\])?(?:\s*@@@)?\s*$", line
        )
        if tool_match:
            tool_name = tool_match.group(1).strip()
            # Remove the ._use suffix
            tool_name = re.sub(r"\._use$", "", tool_name)
            return {"type": "Tool", "action": f"Tool: {tool_name}"}

        # LLM node: [LLM] model_name (tokens) [duration]
        llm_match = re.match(r"\[LLM\]\s+([^\(\[]+)", line)
        if llm_match:
            model_name = llm_match.group(1).strip()
            return {"type": "LLM", "action": f"LLM: {model_name}"}

        # Task Created node: [Task Created] [duration]
        task_match = re.match(r"\[Task Created\]", line)
        if task_match:
            return {"type": "Task Created", "action": "Task Created"}

        # Crew Created node: [Crew Created] [duration]
        crew_match = re.match(r"\[Crew Created\]", line)
        if crew_match:
            return {"type": "Crew Created", "action": "Crew Created"}

        return None


class TrajectoryEvaluator:
    """Trajectory evaluator implementing 6 evaluation metrics."""

    def __init__(self, reference_trajectory: List[str]):
        """
        Args:
            reference_trajectory: Reference trajectory (ground truth)
        """
        self.reference = reference_trajectory

    def _match_action(self, predicted_action: str, reference_action: str) -> bool:
        """
        Match two actions with wildcard support.

        Args:
            predicted_action: Predicted action
            reference_action: Reference action (may contain wildcards)

        Returns:
            True if match, False otherwise
        """
        # Exact match
        if predicted_action == reference_action:
            return True

        # Wildcard match: "LLM: *" matches any "LLM: <model_name>"
        if reference_action == "LLM: *" and predicted_action.startswith("LLM: "):
            return True

        return False

    def exact_match(self, predicted: List[str]) -> int:
        """
        Exact match: predicted trajectory must match the reference exactly (wildcards supported).

        Returns:
            1 if exact match, 0 otherwise
        """
        if len(predicted) != len(self.reference):
            return 0

        for i in range(len(predicted)):
            if not self._match_action(predicted[i], self.reference[i]):
                return 0

        return 1

    def in_order_match(self, predicted: List[str]) -> int:
        """
        In-order match: the reference trajectory must be a subsequence of the predicted
        trajectory (wildcards supported). Extra actions are allowed, but core steps must
        appear in order.

        Returns:
            1 if in-order match, 0 otherwise
        """
        if not self.reference:
            return 1  # An empty reference always matches

        ref_idx = 0
        for pred_action in predicted:
            if ref_idx < len(self.reference) and self._match_action(
                pred_action, self.reference[ref_idx]
            ):
                ref_idx += 1

        # Check whether all reference steps were matched in order
        return 1 if ref_idx == len(self.reference) else 0

    def any_order_match(self, predicted: List[str]) -> int:
        """
        Any-order match: predicted trajectory must contain all required actions
        (wildcards supported). Order does not matter and extra actions are allowed.

        Returns:
            1 if any-order match, 0 otherwise
        """
        if not self.reference:
            return 1

        # Copy predicted actions for matching
        pred_remaining = predicted.copy()

        # For each reference action, try to find a match in the predicted sequence
        for ref_action in self.reference:
            matched = False
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    pred_remaining.pop(i)  # Remove the matched action
                    matched = True
                    break

            if not matched:
                return 0  # Some reference action was not found

        return 1

    def precision(self, predicted: List[str]) -> float:
        """
        Precision: how many predicted actions are considered correct by the reference
        (wildcards supported).

        Precision = TP / (TP + FP)
        TP: Number of correct predicted actions
        FP: Number of incorrect or extra predicted actions

        Returns:
            precision value (0.0 - 1.0)
        """
        if not predicted:
            return 1.0  # No predictions, no false positives

        if not self.reference:
            return 0.0  # Empty reference but has predictions: all are false positives

        # Copy reference actions for matching
        ref_remaining = self.reference.copy()

        tp = 0  # True Positives
        for pred_action in predicted:
            # Try to find a match in the reference
            for i, ref_action in enumerate(ref_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    ref_remaining.pop(i)  # Remove the matched action
                    break

        fp = len(predicted) - tp  # False Positives

        return tp / (tp + fp) if (tp + fp) > 0 else 0.0

    def recall(self, predicted: List[str]) -> float:
        """
        Recall: how many reference actions are covered by the predicted trajectory
        (wildcards supported).

        Recall = TP / (TP + FN)
        TP: Number of reference actions covered by the predicted trajectory
        FN: Number of reference actions not covered by the predicted trajectory

        Returns:
            recall value (0.0 - 1.0)
        """
        if not self.reference:
            return 1.0  # Empty reference: nothing to recall

        if not predicted:
            return 0.0  # No predictions

        # Copy predicted actions for matching
        pred_remaining = predicted.copy()

        tp = 0  # True Positives
        for ref_action in self.reference:
            # Try to find a match in predictions
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    pred_remaining.pop(i)  # Remove the matched action
                    break

        fn = len(self.reference) - tp  # False Negatives

        return tp / (tp + fn) if (tp + fn) > 0 else 0.0

    def single_tool_use(self, predicted: List[str], tool_name: str) -> int:
        """
        Single-tool use: check whether a specific tool appears in the trajectory
        (wildcards supported).

        Args:
            predicted: Predicted trajectory
            tool_name: Target tool name

        Returns:
            1 if tool is used, 0 otherwise
        """
        # Check whether any predicted action matches the target tool
        for pred_action in predicted:
            if self._match_action(pred_action, tool_name):
                return 1
        return 0

    def evaluate_all(
        self, predicted: List[str], target_tools: List[str] = None
    ) -> Dict[str, float]:
        """
        Evaluate all metrics.

        Args:
            predicted: Predicted trajectory
            target_tools: List of target tools for single-tool use evaluation

        Returns:
            A dict of all evaluation metrics
        """
        results = {
            "exact_match": self.exact_match(predicted),
            "in_order_match": self.in_order_match(predicted),
            "any_order_match": self.any_order_match(predicted),
            "precision": self.precision(predicted),
            "recall": self.recall(predicted),
        }

        # Single-tool use: overall usage rate (average across all target tools)
        if target_tools:
            tool_usage_count = sum(
                self.single_tool_use(predicted, tool) for tool in target_tools
            )
            results["single_tool_use"] = (
                tool_usage_count / len(target_tools) if target_tools else 0.0
            )

        return results


class DatasetEvaluator:
    """Dataset-level evaluator."""

    def __init__(self, config_file: str):
        """
        Args:
            config_file: YAML config file path containing the reference trajectory definition
        """
        self.config_file = config_file
        self.config = self._load_config()
        self.reference_trajectory = self.config.get("reference_trajectory", [])
        self.target_tools = self.config.get("target_tools", [])
        self.models = self.config.get("models", [])
        self.project_name = self.config.get("project_name", "SocialMediaManager-MCP")
        # Trajectory extraction types: default is only Tool; can be configured to include
        # ['Tool', 'AGENT', 'Task Created'], etc.
        self.extract_types = self.config.get("extract_types", ["Tool"])
        # Permutable tool group configuration
        self.permutable_tool_groups = self.config.get("permutable_tool_groups", {})

    def _load_config(self) -> Dict:
        """Load the YAML configuration file."""
        if not os.path.exists(self.config_file):
            print(f"Config file not found: {self.config_file}")
            return {}

        with open(self.config_file, "r", encoding="utf-8") as f:
            return yaml.safe_load(f)

    def _generate_permuted_trajectories(
        self, base_trajectory: List[str]
    ) -> List[List[str]]:
        """
        Generate all possible permuted trajectories based on permutable_tool_groups.

        Args:
            base_trajectory: Base reference trajectory

        Returns:
            A list of all possible permuted trajectories (including the original one)
        """
        if not self.permutable_tool_groups:
            # No permutable tool groups configured
            return [base_trajectory]

        # Collect permutable tool groups and their positions in the trajectory
        tool_groups_positions = []

        for group_name, tools in self.permutable_tool_groups.items():
            # Find positions of this tool group in the trajectory
            positions = []
            tool_indices = {}

            for i, action in enumerate(base_trajectory):
                for tool in tools:
                    if action == tool:
                        positions.append(i)
                        tool_indices[i] = tool
                        break

            # Only permute when all tools in the group are found
            if len(positions) == len(tools):
                # Record positions and tools
                tools_at_positions = [tool_indices[pos] for pos in positions]
                tool_groups_positions.append((positions, tools_at_positions))

        if not tool_groups_positions:
            # No complete permutable tool group found
            return [base_trajectory]

        # Generate all possible permutation combinations
        all_trajectories = []

        # Generate permutations for each tool group
        group_permutations = []
        for positions, tools in tool_groups_positions:
            # Generate all permutations for this tool group
            perms = list(permutations(tools))
            group_permutations.append([(positions, perm) for perm in perms])

        # Cartesian product: combine permutations across groups
        all_group_combinations = list(product(*group_permutations))

        # Create a new trajectory for each combination
        for combination in all_group_combinations:
            new_trajectory = base_trajectory.copy()

            # Apply all tool permutations in this combination
            for positions, perm in combination:
                for pos, tool in zip(positions, perm):
                    new_trajectory[pos] = tool

            all_trajectories.append(new_trajectory)

        return all_trajectories

    def _find_best_reference_trajectory(
        self, predicted: List[str], candidate_references: List[List[str]]
    ) -> Tuple[List[str], Dict[str, float]]:
        """
        Select the best reference trajectory from multiple candidates.

        Args:
            predicted: Predicted trajectory
            candidate_references: List of candidate reference trajectories

        Returns:
            (best reference trajectory, corresponding match metrics)
        """
        best_reference = candidate_references[0]
        best_score = -1
        best_metrics = {}

        for ref_trajectory in candidate_references:
            evaluator = TrajectoryEvaluator(ref_trajectory)

            # Compute three key matching metrics
            exact = evaluator.exact_match(predicted)
            in_order = evaluator.in_order_match(predicted)
            any_order = evaluator.any_order_match(predicted)

            # Combined score: exact_match has the highest weight, then in_order_match.
            # Weighted sum: exact*3 + in_order*2 + any_order*1
            score = exact * 3 + in_order * 2 + any_order * 1

            if score > best_score:
                best_score = score
                best_reference = ref_trajectory
                best_metrics = {
                    "exact_match": exact,
                    "in_order_match": in_order,
                    "any_order_match": any_order,
                }

        return best_reference, best_metrics

    def collect_execution_paths(
        self, model_name: str, base_dir: str
    ) -> List[Tuple[str, List[str]]]:
        """
        Collect and parse all execution_path.md files for the given model.

        Args:
            model_name: Model name
            base_dir: RESULTS directory

        Returns:
            A list of (session_id, trajectory)
        """
        model_dir = Path(base_dir) / model_name / self.project_name / "test_results"

        if not model_dir.exists():
            print(f"Model directory not found: {model_dir}")
            return []

        results = []

        # Iterate over all session subdirectories
        for session_dir in sorted(model_dir.iterdir()):
            if not session_dir.is_dir():
                continue

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

            # Parse trajectory (using configured extraction types)
            parser = TrajectoryParser(
                str(exec_path_file), extract_types=self.extract_types
            )
            trajectory = parser.parse()

            results.append((session_dir.name, trajectory))

        return results

    def evaluate_model(self, model_name: str, base_dir: str) -> Dict[str, float]:
        """
        Evaluate a single model across all samples.

        Args:
            model_name: Model name
            base_dir: RESULTS directory

        Returns:
            A dict of average metrics
        """
        model_dir = Path(base_dir) / model_name / self.project_name / "test_results"

        if not model_dir.exists():
            print(f"No trajectory data found for model: {model_name}")
            return {}

        # Accumulate metrics across samples
        all_metrics = defaultdict(list)
        trajectories = []

        # Iterate over all sessions
        for session_dir in sorted(model_dir.iterdir()):
            if not session_dir.is_dir():
                continue

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

            # Parse trajectory
            parser = TrajectoryParser(
                str(exec_path_file), extract_types=self.extract_types
            )
            predicted = parser.parse()

            # Use the base reference trajectory
            base_reference = self.reference_trajectory

            # Generate all permuted candidate reference trajectories
            candidate_references = self._generate_permuted_trajectories(base_reference)

            # Select the best reference trajectory among candidates
            if len(candidate_references) > 1:
                reference, _ = self._find_best_reference_trajectory(
                    predicted, candidate_references
                )
            else:
                reference = base_reference

            # Evaluate using the best reference trajectory
            evaluator = TrajectoryEvaluator(reference)
            metrics = evaluator.evaluate_all(predicted, self.target_tools)

            for key, value in metrics.items():
                all_metrics[key].append(value)

            trajectories.append((session_dir.name, predicted))

        # Compute averages
        avg_metrics = {}
        for key, values in all_metrics.items():
            avg_metrics[key] = sum(values) / len(values) if values else 0.0

        num_samples = len(trajectories)

        if num_samples > 0:
            path_counter = defaultdict(int)
            for session_id, predicted in trajectories:
                path_key = tuple(predicted)
                path_counter[path_key] += 1

            unique_paths = len(path_counter)
            unique_path_ratio = unique_paths / num_samples if num_samples > 0 else 0.0

            probs = [count / num_samples for count in path_counter.values()]
            H = -sum(p * math.log(p) for p in probs if p > 0)
            if len(probs) > 1:
                path_entropy = H / math.log(len(probs))
            else:
                path_entropy = 0.0
        else:
            unique_path_ratio = 0.0
            path_entropy = 0.0

        avg_metrics["unique_path_ratio"] = unique_path_ratio
        avg_metrics["path_entropy"] = path_entropy

        # Add number of samples
        avg_metrics["num_samples"] = num_samples

        return avg_metrics

    def evaluate_all_models(self, base_dir: str = None) -> pd.DataFrame:
        """
        Evaluate all models and return a summary DataFrame.

        Args:
            base_dir: RESULTS directory. Defaults to two levels above this script.

        Returns:
            DataFrame containing evaluation results for all models
        """
        if base_dir is None:
            # Default path: two levels above this script
            base_dir = Path(__file__).parent.parent.parent

        results = []

        for model_name in self.models:
            print(f"\nEvaluating model: {model_name}")
            metrics = self.evaluate_model(model_name, str(base_dir))

            if metrics:
                metrics["model"] = model_name
                results.append(metrics)
                print(f"  Done. Samples: {metrics['num_samples']}")
            else:
                print(f"  Skipped (no data)")

        if not results:
            print("\nNo model data found")
            return pd.DataFrame()

        # Create DataFrame
        df = pd.DataFrame(results)

        # Reorder columns: model first
        cols = [
            "model",
            "num_samples",
            "exact_match",
            "in_order_match",
            "any_order_match",
            "precision",
            "recall",
            "single_tool_use",
            "unique_path_ratio",
            "path_entropy",
        ]

        # Keep only existing columns
        cols = [col for col in cols if col in df.columns]

        df = df[cols]

        return df


def main():
    """Main entry point."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Evaluate trajectory metrics for the SocialMediaManager-MCP project"
    )
    parser.add_argument(
        "--config",
        type=str,
        default="reference_trajectory.yaml",
        help="Path to the reference trajectory config file (YAML)",
    )
    parser.add_argument(
        "--base-dir",
        type=str,
        default=None,
        help="RESULTS directory (defaults to two levels above this script)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="evaluation_results.csv",
        help="Output CSV file path",
    )
    parser.add_argument(
        "--format",
        type=str,
        choices=["csv"],
        default="csv",
        help="Output format (only CSV is supported)",
    )

    args = parser.parse_args()

    # If config is not an absolute path, resolve it relative to this script
    config_path = args.config
    if not os.path.isabs(config_path):
        config_path = os.path.join(os.path.dirname(__file__), config_path)

    print("=" * 80)
    print("Trajectory Evaluation Tool - SocialMediaManager-MCP")
    print("=" * 80)
    print(f"\nConfig file: {config_path}")

    # Create evaluator
    evaluator = DatasetEvaluator(config_path)

    print(f"Project: {evaluator.project_name}")
    print(f"Reference trajectory length: {len(evaluator.reference_trajectory)} steps")
    print(f"Target tools: {evaluator.target_tools}")
    print(f"Models: {evaluator.models}")

    # Show permutation configuration info
    if evaluator.permutable_tool_groups:
        print("\nDynamic tool permutation optimization: enabled")
        total_permutations = 1
        for group_name, tools in evaluator.permutable_tool_groups.items():
            num_perms = math.factorial(len(tools))
            total_permutations *= num_perms
            print(f"   - {group_name}: {len(tools)} tools, {num_perms} permutations")
        print(f"   - Total combinations: {total_permutations}")
        print(
            "   - Strategy: select the best-matching permutation per sample as the reference"
        )
    else:
        print("\nDynamic tool permutation optimization: disabled")

    # Evaluate all models
    df = evaluator.evaluate_all_models(args.base_dir)

    if df.empty:
        print("\nEvaluation failed: no data")
        return

    print("\n" + "=" * 80)
    print("Evaluation Summary")
    print("=" * 80)

    # Display formatting
    pd.set_option("display.max_columns", None)
    pd.set_option("display.width", None)
    pd.set_option("display.float_format", lambda x: f"{x:.4f}")

    print("\n" + df.to_string(index=False))

    # Save results
    output_dir = os.path.dirname(args.output) or "."
    os.makedirs(output_dir, exist_ok=True)

    if args.format == "csv":
        csv_file = args.output
        df.to_csv(csv_file, index=False)
        print(f"\nCSV saved: {csv_file}")

    print("\n" + "=" * 80)
    print("Evaluation complete")
    print("=" * 80)


if __name__ == "__main__":
    main()