data/processed/RQ1/BookWriter-MCP/evaluate_trajectory.py

#!/usr/bin/env python3
"""
Trajectory evaluation script - BookWriter-A2A project

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

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: ['Tool'].
                          Supported: '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 action 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 the 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 while keeping node content
            clean_line = re.sub(r"^[│├└─\s]+", "", line).strip()
            if not clean_line:
                continue

            # Remove error marker ❌
            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 (keep node type/name, drop the [ERROR:...] part)
            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 info from a line.

        Note: the input line should have already removed ❌, retry markers, and ERROR details.

        Returns:
            {'type': str, 'action': str} or None
        """
        # SPAN node: [SPAN] span_name [stats]
        # In A2A, SPAN names may include chapter titles (e.g., a2a_call_chapter_writer_(chapter_title)).
        # Use wildcard matching.
        span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if span_match:
            span_name = span_match.group(1).strip()
            # Wildcard: a2a_call_chapter_writer_(any title) -> a2a_call_chapter_writer_*
            span_name = re.sub(
                r"a2a_call_chapter_writer_\([^)]+\)",
                "a2a_call_chapter_writer_*",
                span_name,
            )
            return {"type": "SPAN", "action": f"SPAN: {span_name}"}

        # Chain node: [Chain] chain_name [stats] [optional extras]
        # For Crew_xxx.kickoff, use wildcard Crew***.kickoff
        # Note: in A2A, Chain lines may contain BATCH markers (e.g., 📚BATCH1 (chapter title))
        chain_match = re.match(r"\[Chain\]\s+([^\[\s]+(?:\.[^\[\s]+)?)", line)
        if chain_match:
            chain_name = chain_match.group(1).strip()
            # Wildcard: 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 ._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 [time]
        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 ._use suffix
            tool_name = re.sub(r"\._use$", "", tool_name)
            return {"type": "Tool", "action": f"Tool: {tool_name}"}

        # LLM node: [LLM] model_name (tokens) [time]
        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] [time]
        task_match = re.match(r"\[Task Created\]", line)
        if task_match:
            return {"type": "Task Created", "action": "Task Created"}

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

        return None


class TrajectoryEvaluator:
    """Trajectory evaluator - implements 6 evaluation metrics."""

    def __init__(
        self,
        reference_trajectory: List[str],
        repeatable_patterns: List[Dict] = None,
        actual_chapter_count: int = None,
    ):
        """
        Args:
            reference_trajectory: Base reference trajectory (ground truth, includes a single-chapter pattern)
            repeatable_patterns: Repeatable patterns list; each has start, end, min, max
            actual_chapter_count: Actual chapter count. If provided, a dynamic reference will be built.
        """
        self.base_reference = reference_trajectory  # Keep the original base reference
        self.repeatable_patterns = repeatable_patterns or []
        self.use_simple_matching = False

        # Build a dynamic reference when chapter count is available
        if actual_chapter_count is not None and self.repeatable_patterns:
            self.reference = self._build_dynamic_reference(actual_chapter_count)
            # When using a dynamic reference, disable special repeatable-pattern matching,
            # because the dynamic reference already contains the correct number of chapters.
            self.use_simple_matching = True
        else:
            self.reference = reference_trajectory
            self.use_simple_matching = False

    @staticmethod
    def detect_chapter_count(predicted: List[str]) -> int:
        """
        Detect the actual number of chapters executed.

        Uses the number of "Chain: Crew***.kickoff" occurrences within the write_chapters SPAN.

        Args:
            predicted: The predicted (actual) execution trajectory

        Returns:
            Chapter count. If detection fails, returns 4 as the default.
        """
        # Locate the write_chapters SPAN
        write_chapters_idx = -1
        review_book_idx = -1

        for i, step in enumerate(predicted):
            if step == "SPAN: write_chapters":
                write_chapters_idx = i
            elif step == "SPAN: review_book":
                review_book_idx = i
                break

        if write_chapters_idx == -1:
            # write_chapters SPAN not found; return default
            return 4

        # Define the search range
        if review_book_idx != -1:
            search_end = review_book_idx
        else:
            search_end = len(predicted)

        # Count occurrences of Chain: Crew***.kickoff
        chapter_count = 0
        for i in range(write_chapters_idx + 1, search_end):
            if predicted[i] == "Chain: Crew***.kickoff":
                chapter_count += 1

        # If detection fails (0 chapters), return the default (4)
        return chapter_count if chapter_count > 0 else 4

    def _build_dynamic_reference(self, chapter_count: int) -> List[str]:
        """
        Build a reference trajectory dynamically based on the detected chapter count.

        Args:
            chapter_count: Chapter count

        Returns:
            The dynamically generated reference trajectory
        """
        if not self.repeatable_patterns:
            return self.base_reference

        pattern = self.repeatable_patterns[0]
        pattern_start = pattern["start"]
        pattern_end = pattern["end"]

        # Split the base reference trajectory
        before_pattern = self.base_reference[:pattern_start]
        pattern_steps = self.base_reference[pattern_start : pattern_end + 1]
        after_pattern = self.base_reference[pattern_end + 1 :]

        # Repeat the chapter pattern based on the detected chapter count.
        # If chapter_count is outside 3-5, fall back to 4.
        if chapter_count < 3 or chapter_count > 5:
            repeat_count = 4
        else:
            repeat_count = chapter_count

        # Build the dynamic reference
        dynamic_reference = before_pattern.copy()
        for _ in range(repeat_count):
            dynamic_reference.extend(pattern_steps)
        dynamic_reference.extend(after_pattern)

        return dynamic_reference

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

        Args:
            predicted_action: Actual executed action
            reference_action: Reference action (may contain wildcards)

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

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

        # Wildcard: SPAN: a2a_call_chapter_writer_* matches any chapter title
        if (
            reference_action == "SPAN: a2a_call_chapter_writer_*"
            and predicted_action.startswith("SPAN: a2a_call_chapter_writer_")
        ):
            return True

        return False

    def exact_match(self, predicted: List[str]) -> int:
        """
        Exact match: predicted trajectory must be identical to the reference (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 must be a subsequence of the predicted trajectory (wildcards supported).
        Extra actions are allowed, but core steps must appear in order.
        Supports repeatable patterns (e.g., per-chapter repetition).

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

        # If using simple matching (dynamic reference already has correct chapter count), use simple logic
        if self.use_simple_matching or not self.repeatable_patterns:
            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
            return 1 if ref_idx == len(self.reference) else 0

        # Matching logic with repeatable patterns
        # Currently only a single repeatable pattern is supported
        pattern = self.repeatable_patterns[0]
        pattern_start = pattern["start"]
        pattern_end = pattern["end"]

        # Split the reference trajectory into 3 parts
        before_pattern = self.reference[:pattern_start]
        pattern_steps = self.reference[pattern_start : pattern_end + 1]
        after_pattern = self.reference[pattern_end + 1 :]

        pred_idx = 0

        # 1) Match the part before the pattern
        for ref_action in before_pattern:
            while pred_idx < len(predicted):
                if self._match_action(predicted[pred_idx], ref_action):
                    pred_idx += 1
                    break
                pred_idx += 1
            else:
                return 0  # No match found

        # 2) Match the repeatable pattern (at least min times, at most max times)
        pattern_matches = 0
        while pattern_matches < pattern["max"]:
            # Try to match one full pattern
            pattern_idx = 0
            start_pred_idx = pred_idx

            for pattern_action in pattern_steps:
                while pred_idx < len(predicted):
                    if self._match_action(predicted[pred_idx], pattern_action):
                        pred_idx += 1
                        pattern_idx += 1
                        break
                    pred_idx += 1
                else:
                    # No match found
                    break

            # Check whether one full pattern was matched
            if pattern_idx == len(pattern_steps):
                pattern_matches += 1
            else:
                # Restore to the position before this attempt
                pred_idx = start_pred_idx
                break

        # Check whether the repetition count meets the requirement
        if pattern_matches < pattern["min"]:
            return 0

        # 3) Match the part after the pattern
        for ref_action in after_pattern:
            while pred_idx < len(predicted):
                if self._match_action(predicted[pred_idx], ref_action):
                    pred_idx += 1
                    break
                pred_idx += 1
            else:
                return 0  # No match found

        return 1

    def diagnose_any_order_match_failure(self, predicted: List[str]) -> dict:
        """
        Diagnose why any_order_match fails.

        Returns:
            {
                'match': bool,
                'failure_stage': str ('before_pattern', 'pattern', 'after_pattern', None),
                'missing_steps': [str],
                'missing_details': str
            }
        """
        if not self.reference:
            return {
                "match": True,
                "failure_stage": None,
                "missing_steps": [],
                "missing_details": "",
            }

        # If using simple matching (dynamic reference already has correct chapter count), use simple logic
        if self.use_simple_matching or not self.repeatable_patterns:
            pred_remaining = predicted.copy()
            missing_steps = []
            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)
                        matched = True
                        break
                if not matched:
                    missing_steps.append(ref_action)

            if missing_steps:
                return {
                    "match": False,
                    "failure_stage": "simple_match",
                    "missing_steps": missing_steps,
                    "missing_details": f"Missing {len(missing_steps)} required steps",
                }
            return {
                "match": True,
                "failure_stage": None,
                "missing_steps": [],
                "missing_details": "",
            }

        # Matching logic with repeatable patterns
        pattern = self.repeatable_patterns[0]
        pattern_start = pattern["start"]
        pattern_end = pattern["end"]

        before_pattern = self.reference[:pattern_start]
        pattern_steps = self.reference[pattern_start : pattern_end + 1]
        after_pattern = self.reference[pattern_end + 1 :]

        pred_remaining = predicted.copy()

        # 1) Check the part before the pattern
        missing_before = []
        for ref_action in before_pattern:
            matched = False
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    pred_remaining.pop(i)
                    matched = True
                    break
            if not matched:
                missing_before.append(ref_action)

        if missing_before:
            return {
                "match": False,
                "failure_stage": "before_pattern",
                "missing_steps": missing_before,
                "missing_details": f"Missing {len(missing_before)} steps in the outline stage",
            }

        # 2) Check the repeatable pattern part
        pattern_missing = []
        for ref_action in pattern_steps:
            required_count = pattern["min"]
            found_count = 0

            i = 0
            while i < len(pred_remaining) and found_count < required_count:
                if self._match_action(pred_remaining[i], ref_action):
                    pred_remaining.pop(i)
                    found_count += 1
                else:
                    i += 1

            if found_count < required_count:
                pattern_missing.append(
                    f"{ref_action} (required {required_count}, found {found_count})"
                )

        if pattern_missing:
            return {
                "match": False,
                "failure_stage": "pattern",
                "missing_steps": pattern_missing,
                "missing_details": f"Missing {len(pattern_missing)} steps in the chapter pattern (min {pattern['min']} per chapter)",
            }

        # 3) Check the part after the pattern
        missing_after = []
        for ref_action in after_pattern:
            matched = False
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    pred_remaining.pop(i)
                    matched = True
                    break
            if not matched:
                missing_after.append(ref_action)

        if missing_after:
            return {
                "match": False,
                "failure_stage": "after_pattern",
                "missing_steps": missing_after,
                "missing_details": f"Missing {len(missing_after)} steps in the review stage",
            }

        return {
            "match": True,
            "failure_stage": None,
            "missing_steps": [],
            "missing_details": "",
        }

    def any_order_match(self, predicted: List[str]) -> int:
        """
        Any-order match: predicted must contain all required actions (wildcards supported).
        Order does not matter; extra actions are allowed.
        Supports repeatable patterns (e.g., per-chapter repetition).

        Returns:
            1 if any-order match, 0 otherwise
        """
        diagnosis = self.diagnose_any_order_match_failure(predicted)
        return 1 if diagnosis["match"] else 0

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

        Precision = TP / (TP + FP)
        TP: Number of correct actions in the prediction
        FP: Number of incorrect/extra actions in the prediction

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

        if not self.reference:
            return 0.0  # Reference is empty but predictions exist: all are incorrect

        # 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 matched item
                    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: fraction of reference actions that are covered by the predicted trajectory (wildcards supported).

        Recall = TP / (TP + FN)
        TP: Number of required actions covered by the prediction
        FN: Number of required actions missing from the prediction

        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 -> recall is 0

        # 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 the predictions
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    pred_remaining.pop(i)  # Remove matched item
                    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 if 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: Tools to check for usage (for single-tool use)

        Returns:
            Dictionary containing all metric values
        """
        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: compute overall usage rate (average over 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: Path to YAML config file that defines the reference trajectory
        """
        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", "BookWriter-A2A")
        # Trajectory extraction types: default extracts Tool only; can be configured to include others.
        self.extract_types = self.config.get("extract_types", ["Tool"])
        # Repeatable pattern config (for handling varying chapter counts)
        self.repeatable_patterns = self.config.get("repeatable_patterns", [])
        # Permutable tool group config (used to generate multiple candidate references)
        self.permutable_tool_groups = self.config.get("permutable_tool_groups", {})

    def _load_config(self) -> Dict:
        """Load YAML config 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 tool-order trajectories based on permutable_tool_groups.

        Args:
            base_trajectory: Base reference trajectory

        Returns:
            All possible permuted trajectories (including the original)
        """
        if not self.permutable_tool_groups:
            # No permutable groups configured; return the original trajectory
            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 group in the base 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 groups 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 of this 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))

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

            # Apply the tool ordering for 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]]:
        """
        Choose the best reference trajectory among multiple candidates.

        Strategy: compute a weighted score for each candidate against the prediction:
        exact_match * 3 + in_order_match * 2 + any_order_match * 1

        Args:
            predicted: Predicted trajectory
            candidate_references: Candidate reference trajectories

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

        for ref_trajectory in candidate_references:
            evaluator = TrajectoryEvaluator(ref_trajectory)

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

            # Weighted score: exact_match has the highest weight, followed by in_order_match
            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 a given model.

        Args:
            model_name: Model name
            base_dir: RESULTS directory path

        Returns:
            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, collect_failure_reasons: bool = False
    ) -> Dict[str, float]:
        """
        Evaluate a single model across all samples.

        Args:
            model_name: Model name
            base_dir: RESULTS directory path
            collect_failure_reasons: Whether to collect any_order_match failure reasons

        Returns:
            Average metrics dictionary
        """
        trajectories = self.collect_execution_paths(model_name, base_dir)

        if not trajectories:
            print(f"⚠️  No trajectory data found for model {model_name}")
            return {}

        # Aggregate metrics over all samples
        all_metrics = defaultdict(list)

        # Store failure reasons (optional)
        if collect_failure_reasons:
            if not hasattr(self, "failure_reasons"):
                self.failure_reasons = []

        for session_id, predicted in trajectories:
            # Detect chapter count for this sample
            chapter_count = TrajectoryEvaluator.detect_chapter_count(predicted)

            # Step 1: build dynamic reference based on chapter count (handles repeatable patterns)
            base_evaluator = TrajectoryEvaluator(
                self.reference_trajectory,
                self.repeatable_patterns,
                actual_chapter_count=chapter_count,
            )
            dynamic_reference = base_evaluator.reference

            # Step 2: generate all permuted reference trajectories
            candidate_references = self._generate_permuted_trajectories(
                dynamic_reference
            )

            # Step 3: choose the best reference trajectory among candidates
            if len(candidate_references) > 1:
                best_reference, best_match_metrics = (
                    self._find_best_reference_trajectory(
                        predicted, candidate_references
                    )
                )
            else:
                # No permutations produced; use the original dynamic reference
                best_reference = dynamic_reference

            # Step 4: evaluate using the chosen best reference
            evaluator = TrajectoryEvaluator(
                best_reference,
                # Note: repeatable_patterns is not needed here since it has already been applied.
                repeatable_patterns=None,
                actual_chapter_count=None,
            )

            metrics = evaluator.evaluate_all(predicted, self.target_tools)

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

            # Collect any_order_match failure reasons
            if collect_failure_reasons and metrics["any_order_match"] == 0:
                diagnosis = evaluator.diagnose_any_order_match_failure(predicted)
                self.failure_reasons.append(
                    {
                        "model": model_name,
                        "session": session_id,
                        "chapter_count": chapter_count,
                        "failure_stage": diagnosis["failure_stage"],
                        "missing_steps_count": len(diagnosis["missing_steps"]),
                        "missing_details": diagnosis["missing_details"],
                        "first_missing_step": (
                            diagnosis["missing_steps"][0]
                            if diagnosis["missing_steps"]
                            else "N/A"
                        ),
                    }
                )

        # 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 sample count
        avg_metrics["num_samples"] = num_samples

        return avg_metrics

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

        Args:
            base_dir: RESULTS directory path (default: two levels above this script)
            collect_failure_reasons: Whether to collect any_order_match failure reasons

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

        results = []

        # Initialize failure reasons list
        if collect_failure_reasons:
            self.failure_reasons = []

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

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

        if not results:
            print("\n❌ No model data available")
            return pd.DataFrame()

        # Create DataFrame
        df = pd.DataFrame(results)

        # Reorder columns: put 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 save_failure_reasons(self, output_file: str = "any_order_match_failures.csv"):
        """
        Save any_order_match failure reasons to a CSV file.

        Args:
            output_file: Output CSV filename
        """
        if not hasattr(self, "failure_reasons") or not self.failure_reasons:
            print("\n⚠️  No failure-reason data collected")
            return

        output_path = Path(__file__).parent / output_file

        # Create DataFrame
        df = pd.DataFrame(self.failure_reasons)

        # Save as CSV
        df.to_csv(output_path, index=False, encoding="utf-8")
        print(f"\n✅ any_order_match failure reasons saved: {output_path}")

        # Summary
        print("\n📊 Failure reason summary:")
        print(f"  Total failed samples: {len(self.failure_reasons)}")

        # By model
        print("\n  By model:")
        model_counts = df["model"].value_counts()
        for model, count in model_counts.items():
            print(f"    {model}: {count} failed samples")

        # By failure stage
        print("\n  By failure stage:")
        stage_counts = df["failure_stage"].value_counts()
        for stage, count in stage_counts.items():
            stage_name = {
                "before_pattern": "Outline stage",
                "pattern": "Chapter pattern stage",
                "after_pattern": "Review stage",
                "simple_match": "Simple match",
            }.get(stage, stage)
            print(f"    {stage_name}: {count}")

        # Intentionally do not generate any Markdown files.


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

    parser = argparse.ArgumentParser(
        description="Evaluate trajectory metrics for the BookWriter-A2A project"
    )
    parser.add_argument(
        "--config",
        type=str,
        default="reference_trajectory.yaml",
        help="Path to the reference trajectory YAML config file",
    )
    parser.add_argument(
        "--base-dir",
        type=str,
        default=None,
        help="RESULTS directory path (default: 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", "markdown", "both"],
        default="both",
        help="Output format: csv, markdown, or both (Markdown is ignored; no .md files are generated)",
    )
    parser.add_argument(
        "--diagnose-failures",
        action="store_true",
        help="Diagnose any_order_match failures (CSV only; no .md files are generated)",
    )

    args = parser.parse_args()

    # If config is a relative 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 - BookWriter-A2A")
    print("=" * 80)
    print(f"\n📁 Config: {config_path}")

    # Create evaluator
    evaluator = DatasetEvaluator(config_path)

    print(f"📋 Project: {evaluator.project_name}")
    print(f"🎯 Reference trajectory: {evaluator.reference_trajectory}")
    print(f"🔧 Target tools: {evaluator.target_tools}")
    print(f"🤖 Models: {evaluator.models}")

    if args.diagnose_failures:
        print("🔍 Failure diagnosis enabled")

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

    if df.empty:
        print("\n❌ Evaluation failed: no data")
        return

    print("\n" + "=" * 80)
    print("📊 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 in ["csv", "both"]:
        csv_file = args.output
        df.to_csv(csv_file, index=False)
        print(f"\n✅ CSV saved: {csv_file}")

    if args.format in ["markdown", "both"]:
        print(
            "⚠️  Markdown output is disabled by design. "
            "Use --format csv to save results."
        )

    # Save failure reasons (if enabled)
    if args.diagnose_failures:
        evaluator.save_failure_reasons()

    print("\n" + "=" * 80)
    print("✅ Done")
    print("=" * 80)


if __name__ == "__main__":
    main()