evaluate_game_code_compile_success.py

#!/usr/bin/env python3
"""
Script to evaluate Python game code compilation success rate.

This script:
1. Scans Python game repositories in the specified directory
2. Tests Python code compilation and basic syntax checking
3. Analyzes import dependencies and identifies missing modules
4. Provides detailed statistics and results

Features:
- Python compilation and syntax checking
- Import dependency analysis
- Basic execution testing (where applicable)
- Comprehensive error handling
- Support for both compilation success and functional correctness
- Detailed logging and statistics
"""

import sys
import os
import json
import time
import argparse
import ast
import tempfile
import subprocess
import importlib.util
import uuid
import shutil
from typing import Dict, List, Tuple, Optional, Set
from dataclasses import dataclass
from pathlib import Path
import conda_env_utils as _conda
from game_config_utils import load_game_configs_from_path
import traceback
from tqdm import tqdm
import numpy as np


@dataclass
class GameCodeCompileResult:
    """Container for game code compilation evaluation results"""
    file_path: str
    relative_path: str
    repository: str
    game_name: str
    file_size: int
    line_count: int
    compilation_success: bool
    syntax_valid: bool
    execution_success: bool
    has_imports: bool
    import_count: int
    missing_imports: List[str]
    available_imports: List[str]
    compilation_error: str
    execution_output: str
    runtime_error: str
    file_type: str  # 'main', 'module', 'test', 'config', 'other'
    used_conda_env: bool  # Whether a conda environment was used
    conda_env_name: str  # Name of the conda environment used
    custom_config_used: bool  # Whether custom configuration was applied
    pip_requirements_installed: List[str]  # Requirements that were installed
    running_arguments_used: List[str]  # Arguments that were used for execution
    python_version_used: str  # Python version used for execution


class GameCodeCompileEvaluator:
    """Evaluator for Python game code focusing on compilation success"""
    
    def __init__(self, base_directory: str = "repos_GAME_python",
                 config_file: str = "game_config.json",
                 skip_list_file: str = "skip_list.json"):
        """
        Initialize the evaluator
        
        Args:
            base_directory: Base directory containing game repositories
            config_file: Path to the JSON configuration file for custom game configs
            skip_list_file: Path to the JSON file listing files to skip
        """
        self.base_directory = Path(base_directory)
        self.config_file = config_file
        self.skip_list_file = skip_list_file
        self.game_configs = {}
        self.active_conda_envs = set()  # Track active conda environments for cleanup
        self.python_extensions = {'.py'}
        self.excluded_files = {'__pycache__', '.git', '.gitignore', 'requirements.txt', 'setup.py'}
        self.excluded_dirs = {'__pycache__', '.git', '.github', 'node_modules', 'venv', 'env'}
        # Add patterns for macOS metadata files and other non-source files
        self.excluded_patterns = {'._*', '.DS_Store', '*.pyc', '*.pyo', '*.egg-info'}
        
        # Load game configurations
        self.load_game_configs()
        # Load skip list
        self.skip_list = set()
        if os.path.exists(self.skip_list_file):
            try:
                with open(self.skip_list_file, 'r', encoding='utf-8') as f:
                    skip_data = json.load(f)
                    # Only keep keys with true value
                    self.skip_list = set(k for k, v in skip_data.items() if v)
                print(f"Loaded skip list with {len(self.skip_list)} files from {self.skip_list_file}")
            except Exception as e:
                print(f"Error loading skip list: {e}")
                self.skip_list = set()
        else:
            print(f"Skip list file {self.skip_list_file} not found. No files will be skipped.")
    
    def find_repo_root(self, file_path: Path) -> Path:
        """
        Find the repository root directory by looking for common indicators
        
        Args:
            file_path: Path to a file within the repository
            
        Returns:
            Path to the repository root directory
        """
        current_path = file_path.parent
        
        # Look for common repository indicators
        repo_indicators = ['.git', 'README.md', 'requirements.txt', 'setup.py', 'pyproject.toml']
        
        # Walk up the directory tree
        while current_path != current_path.parent:  # Stop at filesystem root
            # Check if this directory contains repository indicators
            for indicator in repo_indicators:
                if (current_path / indicator).exists():
                    return current_path
            
            # Check if we've reached the base directory (common repository container)
            if current_path == self.base_directory:
                # If we're at the base directory, look for the immediate subdirectory
                # that contains the file (this is likely the repository root)
                try:
                    relative_path = file_path.relative_to(self.base_directory)
                    repo_dir = self.base_directory / relative_path.parts[0]
                    return repo_dir
                except ValueError:
                    break
            
            current_path = current_path.parent
        
        # If no repository root found, return the immediate parent directory
        return file_path.parent
    
    def load_game_configs(self):
        """Load game-specific configurations from JSON file"""
        self.game_configs = load_game_configs_from_path(
            self.config_file, style="evaluator"
        )
    
    def create_conda_environment(self, env_name: str, requirements: List[str], python_version: str = "3.9") -> Tuple[bool, str]:
        """
        Create a conda environment with specified requirements and Python version
        
        Args:
            env_name: Name of the conda environment
            requirements: List of pip packages to install
            python_version: Python version to use (e.g., "3.8", "3.9", "3.10")
            
        Returns:
            Tuple of (success, error_message)
        """
        cfg = _conda.CondaEnvCreateConfig(
            python_version=python_version,
            log_pip_debug=True,
        )
        return _conda.create_conda_environment(
            env_name, requirements, self.active_conda_envs, cfg
        )

    def cleanup_conda_environment(self, env_name: str) -> bool:
        """
        Remove a conda environment
        
        Args:
            env_name: Name of the environment to remove
            
        Returns:
            Success status
        """
        return _conda.cleanup_conda_environment(env_name, self.active_conda_envs)

    def cleanup_all_conda_environments(self):
        """Clean up all conda environments created during evaluation"""
        _conda.cleanup_all_conda_environments(self.active_conda_envs)
        
    def get_file_type(self, file_path: Path) -> str:
        """
        Determine the type of Python file based on name and content
        
        Args:
            file_path: Path to the Python file
            
        Returns:
            File type classification
        """
        filename = file_path.name.lower()
        
        if filename in ['__main__.py', 'main.py']:
            return 'main'
        elif filename.startswith('game_') and filename.endswith('.py'):
            return 'game'
        elif filename.startswith('test_') or filename.endswith('_test.py') or 'test' in filename:
            return 'test'
        elif filename in ['__init__.py']:
            return 'module'
        elif filename in ['config.py', 'settings.py', 'constants.py']:
            return 'config'
        elif filename.endswith('.py'):
            return 'module'
        else:
            return 'other'
    
    def count_lines(self, file_path: Path) -> int:
        """
        Count non-empty lines in a Python file
        
        Args:
            file_path: Path to the file
            
        Returns:
            Number of non-empty lines
        """
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                lines = f.readlines()
                return len([line for line in lines if line.strip()])
        except Exception:
            return 0
    
    def extract_imports(self, code: str) -> Tuple[List[str], List[str]]:
        """
        Extract import statements from Python code
        
        Args:
            code: Python code string
            
        Returns:
            Tuple of (all_imports, missing_imports)
        """
        all_imports = []
        missing_imports = []
        
        try:
            tree = ast.parse(code)
            
            for node in ast.walk(tree):
                if isinstance(node, ast.Import):
                    for alias in node.names:
                        module_name = alias.name
                        all_imports.append(module_name)
                        
                        # Check if module is available
                        try:
                            importlib.util.find_spec(module_name)
                        except (ImportError, ModuleNotFoundError, ValueError):
                            missing_imports.append(module_name)
                            
                elif isinstance(node, ast.ImportFrom):
                    if node.module:
                        module_name = node.module
                        all_imports.append(module_name)
                        
                        # Check if module is available
                        try:
                            importlib.util.find_spec(module_name)
                        except (ImportError, ModuleNotFoundError, ValueError):
                            missing_imports.append(module_name)
                            
        except SyntaxError:
            # If we can't parse the AST, try a simple regex approach
            import re
            import_pattern = r'^\s*(?:from\s+(\S+)\s+)?import\s+([^#\n]+)'
            
            for line in code.split('\n'):
                match = re.match(import_pattern, line)
                if match:
                    if match.group(1):  # from ... import
                        module_name = match.group(1)
                    else:  # import ...
                        imports = match.group(2).split(',')
                        module_name = imports[0].strip().split(' as ')[0]
                    
                    all_imports.append(module_name)
                    
                    # Check if module is available
                    try:
                        importlib.util.find_spec(module_name)
                    except (ImportError, ModuleNotFoundError, ValueError):
                        missing_imports.append(module_name)
        
        return all_imports, missing_imports
    
    def check_syntax(self, code: str) -> Tuple[bool, str]:
        """
        Check if Python code has valid syntax
        
        Args:
            code: Python code to check
            
        Returns:
            Tuple of (syntax_valid, error_message)
        """
        try:
            ast.parse(code)
            return True, ""
        except SyntaxError as e:
            return False, str(e)
        except Exception as e:
            return False, str(e)
    
    def test_compilation_and_execution(self, file_path: Path, code: str, relative_path: str) -> Tuple[bool, bool, bool, str, str, str, bool, str, bool, List[str], List[str], str]:
        """
        Test the Python code for compilation and basic execution with conda environment support
        
        Args:
            file_path: Path to the original file
            code: Python code content
            relative_path: Relative path for config lookup
            
        Returns:
            Tuple of (compilation_success, syntax_valid, execution_success, compilation_error, execution_output, runtime_error, 
                     used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used)
        """
        # Initialize default return values for conda/config information
        used_conda_env = False
        conda_env_name = ""
        custom_config_used = False
        pip_requirements_installed = []
        running_arguments_used = []
        python_version_used = sys.version.split()[0]  # Default to current Python version
        
        # First check syntax
        syntax_valid, syntax_error = self.check_syntax(code)
        if not syntax_valid:
            print("syntax_error: ", syntax_error)
            return False, False, False, syntax_error, "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
        
        # Check if this file has custom configuration
        config = self.game_configs.get(relative_path, {})
        print("relative_path: ", relative_path)
        if config:
            custom_config_used = True
            print("custom_config_used: ", custom_config_used)
            pip_requirements = config.get("pip_requirements", [])
            running_arguments = config.get("running_arguments", [])
            timeout = config.get("timeout", 10)
            python_version = config.get("python_version", "3.9")
            running_arguments_used = running_arguments.copy()
            python_version_used = python_version
        else:
            pip_requirements = []
            running_arguments = []
            timeout = 5
            python_version = "3.9"
        
        with tempfile.TemporaryDirectory() as temp_dir:
            try:
                # Find repository root directory
                repo_root = self.find_repo_root(file_path)
                
                # Copy entire repository to temp directory
                repo_temp_dir = Path(temp_dir) / "repo"
                try:
                    shutil.copytree(repo_root, repo_temp_dir, ignore=shutil.ignore_patterns('.git', '__pycache__', '*.pyc', '.DS_Store', '.pytest_cache', '*.egg-info', 'build', 'dist', '.tox', '.coverage'))
                    print(f"Copied entire repository from {repo_root} to temporary directory")
                    
                    # Calculate the relative path from repo root to the target file
                    relative_path_from_repo = file_path.relative_to(repo_root)
                    temp_file = repo_temp_dir / relative_path_from_repo
                    
                    # Update the target file with the provided code
                    with open(temp_file, 'w', encoding='utf-8') as f:
                        f.write(code)
                        
                except Exception as e:
                    print(f"Failed to copy repository: {e}")
                    # Fallback to old behavior if repository copy fails
                    repo_temp_dir = Path(temp_dir)
                    temp_file = repo_temp_dir / file_path.name
                    with open(temp_file, 'w', encoding='utf-8') as f:
                        f.write(code)
                
                # Decide whether to use conda environment
                if pip_requirements or custom_config_used:
                    # Create conda environment for this execution
                    env_name = f"game_eval_{uuid.uuid4().hex[:8]}"
                    conda_env_name = env_name
                    used_conda_env = True
                    
                    env_success, env_error = self.create_conda_environment(env_name, pip_requirements, python_version)
                    if not env_success:
                        return False, True, False, f"Conda environment creation failed: {env_error}", "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements, running_arguments_used, python_version_used
                    
                    pip_requirements_installed = pip_requirements.copy()
                    python_cmd = ["conda", "run", "-n", env_name, "python"]
                else:
                    python_cmd = [sys.executable]
                
                try:
                    # Test compilation
                    if used_conda_env:
                        compile_cmd = ["conda", "run", "-n", env_name, "python", "-m", "py_compile", str(temp_file)]
                    else:
                        compile_cmd = [sys.executable, "-m", "py_compile", str(temp_file)]
                    
                    compile_result = subprocess.run(
                        compile_cmd,
                        capture_output=True,
                        text=True,
                        timeout=10,
                        cwd=repo_temp_dir
                    )
                    print("compile_result: ", compile_result)
                    
                    if compile_result.returncode != 0:
                        if used_conda_env:
                            self.cleanup_conda_environment(env_name)
                        return False, True, False, compile_result.stderr, "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
                    
                    # If compilation succeeded, try to run the file (for main files only)
                    execution_success = True
                    execution_output = ""
                    runtime_error = ""
                    
                    # Only try to execute main files or files that look executable
                    # if (file_path.name in ['__main__.py', 'main.py'] or 
                    #     'if __name__ == "__main__"' in code or "if __name__ == '__main__'" in code):
                    try:
                        # Build execution command with arguments
                        run_cmd = python_cmd + [str(temp_file)] + running_arguments
                        
                        print(f"Executing: {' '.join(run_cmd)}")
                        run_result = subprocess.run(
                            run_cmd,
                            capture_output=True,
                            text=True,
                            timeout=timeout,
                            cwd=repo_temp_dir
                        )
                        print("run_result: ", run_result)
                        # For games, be more lenient about success criteria
                        # Consider execution successful if:
                        # 1. Return code is 0 (normal success)
                        # 2. The process ran and produced output (game started)
                        # 3. No critical Python errors (syntax, import, etc.)
                        execution_output = run_result.stdout[:10000]  # Limit output size
                        print("execution_output: ", execution_output)
                        runtime_error = run_result.stderr[:10000] if run_result.stderr else ""
                        print("runtime_error: ", runtime_error)
                        # Check for critical Python errors that indicate real failure
                        critical_errors = [
                            "SyntaxError", "IndentationError", "ImportError", "ModuleNotFoundError",
                            "NameError", "AttributeError", "TypeError", "ValueError", "KeyError", "FileNotFoundError"
                        ]
                        
                        has_critical_error = any(error in runtime_error for error in critical_errors)
                        
                        # Consider successful if:
                        # - Return code is 0, OR
                        # - Process ran and produced some output without critical errors, OR  
                        # - Process exited cleanly (common for games in headless mode)
                        execution_success = (
                            run_result.returncode == 0 or 
                            (execution_output.strip() and not has_critical_error) or
                            (not has_critical_error and run_result.returncode in [-2, 1, 2])  # Common game exit codes
                        )
                        
                        if execution_success:
                            print("Execution successful!")
                            print("===========================\n\n")
                        else:
                            print(f"Execution failed - Return code: {run_result.returncode}")
                            if runtime_error:
                                print(f"Error: {runtime_error}")
                            print("===========================\n\n")
                    except subprocess.TimeoutExpired:
                        execution_success = True  # Timeout might be expected for games
                        execution_output = "Execution started (timeout reached)"
                        runtime_error = ""
                    except Exception as e:
                        execution_success = False
                        runtime_error = str(e)
                        print("error: ", e)
                    # else:
                    #     print("Not a main file, skipping execution")
                    
                    # Clean up conda environment
                    if used_conda_env:
                        self.cleanup_conda_environment(env_name)
                    
                    return True, True, execution_success, "", execution_output, runtime_error, used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
                    
                except subprocess.TimeoutExpired:
                    if used_conda_env:
                        self.cleanup_conda_environment(env_name)
                    return False, True, False, "Compilation timeout", "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
                except Exception as e:
                    if used_conda_env:
                        self.cleanup_conda_environment(env_name)
                    return False, True, False, str(e), "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
                    
            except Exception as e:
                if used_conda_env:
                    self.cleanup_conda_environment(env_name)
                return False, syntax_valid, False, str(e), "", "", used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used
    
    def find_python_files(self) -> List[Path]:
        """
        Find all Python files in the game repositories
        
        Returns:
            List of Python file paths
        """
        python_files = []
        skipped_files = 0
        
        if not self.base_directory.exists():
            print(f"Error: Base directory {self.base_directory} does not exist")
            return python_files
        
        print(f"Scanning for Python files in {self.base_directory}")
        
        for repo_dir in self.base_directory.iterdir():
            if repo_dir.is_dir() and not repo_dir.name.startswith('.') and repo_dir.name not in self.excluded_dirs:
                # Recursively find Python files
                for file_path in repo_dir.rglob("*.py"):
                    if (file_path.is_file() and 
                        file_path.name not in self.excluded_files and
                        not file_path.name.startswith('._') and  # Skip macOS metadata files
                        not file_path.name.startswith('.') and   # Skip other hidden files
                        not any(excluded in str(file_path) for excluded in self.excluded_dirs)):
                        # Compute relative path from base_directory for skip list matching
                        try:
                            relative_path = str(file_path.relative_to(self.base_directory))
                        except ValueError:
                            relative_path = str(file_path)
                        # Extract imports
                        config = self.game_configs.get(relative_path, {})
                        # print("relative_path: ", relative_path)
                        if not config:
                            print("jumping file: ", file_path)
                            continue
                        try:
                            rel_path = str(file_path.relative_to(self.base_directory))
                        except ValueError:
                            rel_path = str(file_path)
                        if rel_path in self.skip_list:
                            skipped_files += 1
                            continue
                        python_files.append(file_path)
        if skipped_files > 0:
            print(f"Skipped {skipped_files} files due to skip_list.json")
        return python_files
    
    def evaluate_files(self, max_files: Optional[int] = None,
                      save_results: bool = True,
                      results_file: str = "game_code_compile_results.json") -> List[GameCodeCompileResult]:
        """
        Evaluate all Python game files
        
        Args:
            max_files: Maximum number of files to evaluate (None for all)
            save_results: Whether to save results to file
            results_file: File to save results to
            
        Returns:
            List of evaluation results
        """
        python_files = self.find_python_files()
        # Filter again in case user calls with custom file list
        filtered_files = []
        skipped_files = 0
        for file_path in python_files:
            try:
                rel_path = str(file_path.relative_to(self.base_directory))
            except ValueError:
                rel_path = str(file_path)
            if rel_path in self.skip_list:
                skipped_files += 1
                continue
            filtered_files.append(file_path)
        if skipped_files > 0:
            print(f"Skipped {skipped_files} files due to skip_list.json in evaluate_files")
        python_files = filtered_files
        if max_files:
            python_files = python_files[:max_files]
        print(f"Found {len(python_files)} Python files to evaluate")
        
        results = []
        
        for file_path in tqdm(python_files, desc="Evaluating Python game files"):
            try:
                # Read file content
                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                    code = f.read()
                
                # Get relative path for display
                try:
                    relative_path = str(file_path.relative_to(self.base_directory))
                except ValueError:
                    relative_path = str(file_path)
                
                # Extract repository and game name
                path_parts = relative_path.split(os.sep)
                repository = path_parts[0] if len(path_parts) > 0 else "unknown"
                game_name = path_parts[1] if len(path_parts) > 1 else "unknown"
                
                # Get file info
                file_size = file_path.stat().st_size
                line_count = self.count_lines(file_path)
                file_type = self.get_file_type(file_path)
                
                # Extract imports
                all_imports, missing_imports = self.extract_imports(code)
                available_imports = [imp for imp in all_imports if imp not in missing_imports]
                config = self.game_configs.get(relative_path, {})
                # print("relative_path: ", relative_path)
                if not config:
                # Test compilation and execution
                    if not (file_path.name in ['__main__.py', 'main.py'] or 'if __name__ == "__main__"' in code or "if __name__ == '__main__'" in code):
                        print("skipping file: ", file_path)
                        continue
                
                compilation_success, syntax_valid, execution_success, compilation_error, execution_output, runtime_error, \
                used_conda_env, conda_env_name, custom_config_used, pip_requirements_installed, running_arguments_used, python_version_used = \
                    self.test_compilation_and_execution(file_path, code, relative_path)
                # print("file_path: ", file_path)
                # print("execution_output: ", execution_output)
                # print("runtime_error: ", runtime_error)
                # print("compilation_success: ", compilation_success)
                result = GameCodeCompileResult(
                    file_path=str(file_path),
                    relative_path=relative_path,
                    repository=repository,
                    game_name=game_name,
                    file_size=file_size,
                    line_count=line_count,
                    compilation_success=compilation_success,
                    syntax_valid=syntax_valid,
                    execution_success=execution_success,
                    has_imports=len(all_imports) > 0,
                    import_count=len(all_imports),
                    missing_imports=missing_imports,
                    available_imports=available_imports,
                    compilation_error=compilation_error,
                    execution_output=execution_output,
                    runtime_error=runtime_error,
                    file_type=file_type,
                    used_conda_env=used_conda_env,
                    conda_env_name=conda_env_name,
                    custom_config_used=custom_config_used,
                    pip_requirements_installed=pip_requirements_installed,
                    running_arguments_used=running_arguments_used,
                    python_version_used=python_version_used
                )
                
                results.append(result)
                
            except Exception as e:
                # Create error result
                try:
                    relative_path = str(file_path.relative_to(self.base_directory))
                except ValueError:
                    relative_path = str(file_path)
                
                path_parts = relative_path.split(os.sep)
                repository = path_parts[0] if len(path_parts) > 0 else "unknown"
                game_name = path_parts[1] if len(path_parts) > 1 else "unknown"
                
                result = GameCodeCompileResult(
                    file_path=str(file_path),
                    relative_path=relative_path,
                    repository=repository,
                    game_name=game_name,
                    file_size=0,
                    line_count=0,
                    compilation_success=False,
                    syntax_valid=False,
                    execution_success=False,
                    has_imports=False,
                    import_count=0,
                    missing_imports=[],
                    available_imports=[],
                    compilation_error=f"File processing error: {str(e)}",
                    execution_output="",
                    runtime_error="",
                    file_type="error",
                    used_conda_env=False,
                    conda_env_name="",
                    custom_config_used=False,
                    pip_requirements_installed=[],
                    running_arguments_used=[],
                    python_version_used=""
                )
                
                results.append(result)
        
        if save_results:
            self.save_results(results, results_file)
        
        return results
    
    def save_results(self, results: List[GameCodeCompileResult], filename: str):
        """Save results to JSON file"""
        results_dict = []
        for result in results:
            results_dict.append({
                'file_path': result.file_path,
                'relative_path': result.relative_path,
                'repository': result.repository,
                'game_name': result.game_name,
                'file_size': result.file_size,
                'line_count': result.line_count,
                'compilation_success': result.compilation_success,
                'syntax_valid': result.syntax_valid,
                'execution_success': result.execution_success,
                'has_imports': result.has_imports,
                'import_count': result.import_count,
                'missing_imports': result.missing_imports,
                'available_imports': result.available_imports,
                'compilation_error': result.compilation_error,
                'execution_output': result.execution_output,
                'runtime_error': result.runtime_error,
                'file_type': result.file_type,
                'used_conda_env': result.used_conda_env,
                'conda_env_name': result.conda_env_name,
                'custom_config_used': result.custom_config_used,
                'pip_requirements_installed': result.pip_requirements_installed,
                'running_arguments_used': result.running_arguments_used,
                'python_version_used': result.python_version_used
            })
        
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(results_dict, f, indent=2, ensure_ascii=False)
        
        print(f"Results saved to {filename}")
    
    def _build_frequency_map(self, values: List[str]) -> Dict[str, int]:
        frequency_map: Dict[str, int] = {}
        for value in values:
            frequency_map[value] = frequency_map.get(value, 0) + 1
        return frequency_map

    def _collect_statistics_data(self, results: List[GameCodeCompileResult]) -> Dict[str, object]:
        total_files = len(results)
        syntax_valid_count = sum(1 for r in results if r.syntax_valid)
        compilation_successes = sum(1 for r in results if r.compilation_success)
        execution_successes = sum(1 for r in results if r.execution_success)
        conda_env_used_count = sum(1 for r in results if r.used_conda_env)
        custom_config_used_count = sum(1 for r in results if r.custom_config_used)
        files_with_requirements = sum(1 for r in results if r.pip_requirements_installed)
        files_with_arguments = sum(1 for r in results if r.running_arguments_used)
        files_with_imports = sum(1 for r in results if r.has_imports)
        total_imports = sum(r.import_count for r in results)
        total_missing_imports = sum(len(r.missing_imports) for r in results)

        file_types = self._build_frequency_map([r.file_type for r in results])
        repositories = self._build_frequency_map([r.repository for r in results])
        repo_compile_success = self._build_frequency_map([r.repository for r in results if r.compilation_success])
        python_versions = self._build_frequency_map([r.python_version_used for r in results if r.python_version_used])

        missing_import_counts: Dict[str, int] = {}
        for result in results:
            for missing_import in result.missing_imports:
                missing_import_counts[missing_import] = missing_import_counts.get(missing_import, 0) + 1
        top_missing_imports = sorted(missing_import_counts.items(), key=lambda item: item[1], reverse=True)[:10]

        file_sizes = [r.file_size for r in results if r.file_size > 0]
        line_counts = [r.line_count for r in results if r.line_count > 0]

        successful_cases = [r for r in results if r.compilation_success]
        syntax_errors = [r for r in results if not r.syntax_valid]
        import_errors = [r for r in results if r.missing_imports]
        conda_users = [r for r in results if r.used_conda_env]

        return {
            "total_files": total_files,
            "syntax_valid_count": syntax_valid_count,
            "compilation_successes": compilation_successes,
            "execution_successes": execution_successes,
            "conda_env_used_count": conda_env_used_count,
            "custom_config_used_count": custom_config_used_count,
            "files_with_requirements": files_with_requirements,
            "files_with_arguments": files_with_arguments,
            "file_types": file_types,
            "repositories": repositories,
            "repo_compile_success": repo_compile_success,
            "files_with_imports": files_with_imports,
            "total_imports": total_imports,
            "total_missing_imports": total_missing_imports,
            "top_missing_imports": top_missing_imports,
            "file_sizes": file_sizes,
            "line_counts": line_counts,
            "python_versions": python_versions,
            "successful_cases": successful_cases,
            "syntax_errors": syntax_errors,
            "import_errors": import_errors,
            "conda_users": conda_users
        }

    def _print_statistics_header(self, total_files: int):
        print("\n" + "=" * 80)
        print("PYTHON GAME CODE COMPILATION SUCCESS EVALUATION STATISTICS")
        print("=" * 80)
        print(f"Total Python files analyzed: {total_files}")
        print()

    def _print_compilation_section(self, stats: Dict[str, object]):
        total_files = stats["total_files"]
        print("COMPILATION RESULTS:")
        print(f"  Valid syntax: {stats['syntax_valid_count']} ({stats['syntax_valid_count']/total_files:.1%})")
        print(f"  Successful compilations: {stats['compilation_successes']} ({stats['compilation_successes']/total_files:.1%})")
        print(f"  Successful executions: {stats['execution_successes']} ({stats['execution_successes']/total_files:.1%})")
        print()

    def _print_environment_section(self, stats: Dict[str, object]):
        total_files = stats["total_files"]
        print("CONDA ENVIRONMENT & CONFIGURATION USAGE:")
        print(f"  Files using conda environments: {stats['conda_env_used_count']} ({stats['conda_env_used_count']/total_files:.1%})")
        print(f"  Files with custom configurations: {stats['custom_config_used_count']} ({stats['custom_config_used_count']/total_files:.1%})")
        print(f"  Files with pip requirements: {stats['files_with_requirements']} ({stats['files_with_requirements']/total_files:.1%})")
        print(f"  Files with custom arguments: {stats['files_with_arguments']} ({stats['files_with_arguments']/total_files:.1%})")
        print()

    def _print_python_versions_section(self, stats: Dict[str, object]):
        python_versions = stats["python_versions"]
        total_files = stats["total_files"]
        if python_versions:
            print("PYTHON VERSION USAGE:")
            for version, count in sorted(python_versions.items()):
                print(f"  Python {version}: {count} files ({count/total_files:.1%})")
        print()

    def _print_file_type_section(self, stats: Dict[str, object]):
        total_files = stats["total_files"]
        print("FILE TYPE DISTRIBUTION:")
        for file_type, count in sorted(stats["file_types"].items()):
            print(f"  {file_type}: {count} ({(count / total_files * 100):.1f}%)")
        print()

    def _print_import_section(self, stats: Dict[str, object]):
        total_files = stats["total_files"]
        total_imports = stats["total_imports"]
        total_missing_imports = stats["total_missing_imports"]
        print("IMPORT ANALYSIS:")
        print(f"  Files with imports: {stats['files_with_imports']} ({stats['files_with_imports']/total_files:.1%})")
        print(f"  Total import statements: {total_imports}")
        print(f"  Missing imports: {total_missing_imports}")
        if total_imports > 0:
            print(f"  Import success rate: {((total_imports - total_missing_imports) / total_imports):.1%}")
        print()

        if stats["top_missing_imports"]:
            print("TOP MISSING IMPORTS:")
            for missing_import, count in stats["top_missing_imports"]:
                print(f"  {missing_import}: {count} files")
            print()

    def _print_size_sections(self, stats: Dict[str, object]):
        file_sizes = stats["file_sizes"]
        line_counts = stats["line_counts"]

        print("FILE SIZE STATISTICS:")
        if file_sizes:
            print(f"  Average file size: {np.mean(file_sizes):.0f} bytes")
            print(f"  Median file size: {np.median(file_sizes):.0f} bytes")
            print(f"  Largest file: {max(file_sizes):.0f} bytes")
        print()

        print("LINE COUNT STATISTICS:")
        if line_counts:
            print(f"  Average lines per file: {np.mean(line_counts):.0f}")
            print(f"  Median lines per file: {np.median(line_counts):.0f}")
            print(f"  Largest file: {max(line_counts)} lines")
        print()

    def _print_repository_section(self, stats: Dict[str, object]):
        repositories = stats["repositories"]
        repo_compile_success = stats["repo_compile_success"]
        print("TOP REPOSITORIES BY FILE COUNT:")
        top_repos = sorted(repositories.items(), key=lambda item: item[1], reverse=True)[:10]
        for repo, count in top_repos:
            success_count = repo_compile_success.get(repo, 0)
            success_rate = success_count / count if count > 0 else 0
            print(f"  {repo}: {count} files ({success_rate:.1%} compile success)")
        print()

    def _print_example_results(self, stats: Dict[str, object]):
        print("EXAMPLE RESULTS:")

        if stats["successful_cases"]:
            example = stats["successful_cases"][0]
            print(f"\n✅ SUCCESSFUL COMPILATION: {example.relative_path}")
            print(f"   Repository: {example.repository}")
            print(f"   File type: {example.file_type}")
            print(f"   Lines: {example.line_count}")

        if stats["syntax_errors"]:
            example = stats["syntax_errors"][0]
            print(f"\n❌ SYNTAX ERROR: {example.relative_path}")
            print(f"   Repository: {example.repository}")
            print(f"   Error: {example.compilation_error}")

        if stats["import_errors"]:
            example = stats["import_errors"][0]
            print(f"\n⚠️  MISSING IMPORTS: {example.relative_path}")
            print(f"   Repository: {example.repository}")
            print(f"   Missing: {', '.join(example.missing_imports[:5])}")

        if stats["conda_users"]:
            example = stats["conda_users"][0]
            print(f"\n🐍 CONDA ENVIRONMENT USED: {example.relative_path}")
            print(f"   Repository: {example.repository}")
            print(f"   Environment: {example.conda_env_name}")
            print(f"   Python Version: {example.python_version_used}")
            print(f"   Requirements: {', '.join(example.pip_requirements_installed)}")
            if example.running_arguments_used:
                print(f"   Arguments: {' '.join(example.running_arguments_used)}")

    def print_statistics(self, results: List[GameCodeCompileResult]):
        """Print evaluation statistics"""
        if not results:
            print("No results to analyze!")
            return

        stats = self._collect_statistics_data(results)
        self._print_statistics_header(stats["total_files"])
        self._print_compilation_section(stats)
        self._print_environment_section(stats)
        self._print_python_versions_section(stats)
        self._print_file_type_section(stats)
        self._print_import_section(stats)
        self._print_size_sections(stats)
        self._print_repository_section(stats)
        self._print_example_results(stats)
        print("=" * 80)


def main():
    """Main function"""
    parser = argparse.ArgumentParser(description="Evaluate Python game code compilation success rate")
    parser.add_argument("--base-dir", default="repos_GAME_python_demo", 
                       help="Base directory containing game repositories")
    parser.add_argument("--config-file", default="game_config.json",
                       help="JSON configuration file for game-specific requirements and arguments")
    parser.add_argument("--skip-list", default="skip_list.json",
                       help="JSON file listing files to skip")
    parser.add_argument("--max-files", type=int, help="Maximum number of files to evaluate")
    parser.add_argument("--results-file", default="game_code_compile_results.json", 
                       help="File to save results")
    parser.add_argument("--no-save", action="store_true", help="Don't save results to file")
    
    args = parser.parse_args()
    
    # Initialize evaluator
    evaluator = GameCodeCompileEvaluator(base_directory=args.base_dir, config_file=args.config_file, skip_list_file=args.skip_list)
    
    try:
        # Evaluate files
        results = evaluator.evaluate_files(
            max_files=args.max_files,
            save_results=not args.no_save,
            results_file=args.results_file
        )
        
        # Print statistics
        evaluator.print_statistics(results)
        
    finally:
        # Ensure all conda environments are cleaned up
        print("Cleaning up conda environments...")
        evaluator.cleanup_all_conda_environments()
        print("Cleanup completed.")


if __name__ == "__main__":
    main()