#!/usr/bin/env python3
"""
Helper Classes for Swarm AI System

This file contains helper classes used by the swarm AI system.
"""

import time
import math
from typing import Dict, List, Any, Optional
class ResourceManager:
    """
    Manage resources for the swarm system.
    """
    
    def __init__(self):
        self.resources = {
            "cpu": 10.0,  # Total CPU capacity
            "memory": 8.0,  # Total memory capacity (GB)
            "network": 1.0,  # Total network capacity
            "storage": 100.0  # Total storage capacity (GB)
        }
        self.allocation_history = []
        
    def allocate_resources(self, requirements: Dict[str, float]) -> Dict[str, Any]:
        """
        Allocate resources based on requirements.

        Args:
            requirements: Resource requirements

        Returns:
            Allocation results
        """
        allocation = {}
        total_allocated = 0
        
        for resource, requirement in requirements.items():
            if resource in self.resources:
                available = self.resources[resource]
                if requirement <= available:
                    allocation[resource] = requirement
                    self.resources[resource] -= requirement
                    total_allocated += requirement
                else:
                    allocation[resource] = available
                    self.resources[resource] = 0
                    
        # Record allocation
        self.allocation_history.append({
            "timestamp": time.time(),
            "requirements": requirements,
            "allocation": allocation,
            "total_allocated": total_allocated,
            "utilization_efficiency": self.calculate_utilization_efficiency(allocation)
        })
        
        return {
            "allocation": allocation,
            "utilization_efficiency": self.calculate_utilization_efficiency(allocation),
            "satisfaction": self.calculate_satisfaction(requirements, allocation),
            "allocation_time": time.time()
        }
        
    def release_resources(self, agent_id: str, released_resources: Dict[str, float]):
        """
        Release resources.

        Args:
            agent_id: Agent ID
            released_resources: Resources to release
        """
        for resource, amount in released_resources.items():
            if resource in self.resources:
                self.resources[resource] = min(1.0, 
                    self.resources[resource] + amount)
                
        # Record resource release
        self.allocation_history.append({
            "timestamp": time.time(),n            "agent_id": agent_id,
            "action": "release",
            "resources": released_resources,
            "new_balances": self.resources.copy()
        })
        
    def get_resource_status(self) -> Dict[str, float]:
        """
        Get current resource status.

        Returns:
            Current resource balances
        """
        return self.resources.copy()
        
    def calculate_utilization_efficiency(self, allocation: Dict[str, float]) -> float:
        """
        Calculate utilization efficiency.

        Args:
            allocation: Resource allocation

        Returns:
            Utilization efficiency (0.0 to 1.0)
        """
        if not allocation:
            return 0.0
            
        total_utilized = sum(allocation.values())
        total_available = sum(self.resources.values())
        
        return total_utilized / total_available if total_available > 0 else 0.0
        
    def calculate_satisfaction(self, requirements: Dict[str, float], 
                               allocation: Dict[str, float]) -> float:
        """
        Calculate resource satisfaction.

        Args:
            requirements: Resource requirements
            allocation: Resource allocation

        Returns:
            Satisfaction score (0.0 to 1.0)
        """
        if not requirements:
            return 1.0
            
        satisfied = 0
        total_requirements = 0
        
        for resource, requirement in requirements.items():
            allocated = allocation.get(resource, 0.0)
            satisfied += min(allocated, requirement)
            total_requirements += requirement
            
        return satisfied / total_requirements if total_requirements > 0 else 1.0
        
    def get_allocation_history(self, limit: int = 100) -> List[Dict[str, Any]]:
        """
        Get allocation history.

        Args:
            limit: Maximum number of history entries

        Returns:
            Allocation history
        """
        return self.allocation_history[-limit:]
class LoadBalancer:
    """
    Balance load across swarm agents.
    """
    
    def __init__(self):
        self.load_history = []
        self.balance_strategies = {
            "round_robin": self.round_robin_balance,
            "weighted": self.weighted_balance,
            "least_loaded": self.least_loaded_balance,
            "priority_based": self.priority_based_balance
        }
        
    def balance_agents(self, agent_loads: Dict[str, Dict[str, float]], 
                      strategy: str = "least_loaded") -> Dict[str, Any]:
        """
        Balance load across agents.

        Args:
            agent_loads: Agent load information
            strategy: Balancing strategy

        Returns:
            Load balancing results
        """
        if strategy not in self.balance_strategies:
            strategy = "least_loaded"
            
        balancing_strategy = self.balance_strategies[strategy]
        balancing_result = balancing_strategy(agent_loads)
        
        return {
            "balancing_strategy": strategy,
            "balancing_result": balancing_result,
            "load_balance_efficiency": self.calculate_load_balance_efficiency(agent_loads)
        }
        
    def round_robin_balance(self, agent_loads: Dict[str, Dict[str, float]]) -> List[Dict[str, Any]]:
        """
        Balance load using round-robin algorithm.

        Args:
            agent_loads: Agent load information

        Returns:
            Balancing actions
        """
        actions = []
        
        # Sort agents by load (descending)
        sorted_agents = sorted(
            agent_loads.items(),
            key=lambda x: (x[1].get("cpu", 0.0) + x[1].get("memory", 0.0)),
            reverse=True
        )
        
        # Balance across all agents
        for i, (agent_id, load_data) in enumerate(sorted_agents):
            target_agent = sorted_agents[(i + 1) % len(sorted_agents)][0]
            
            if load_data.get("cpu", 0.0) > 0.8 or load_data.get("memory", 0.0) > 0.8:
                actions.append({
                    "action": "migrate_work",
                    "source_agent": agent_id,
                    "target_agent": target_agent,
                    "amount": self.calculate_migration_amount(load_data),
                    "priority": "high"
                })
                
        return actions
        
    def weighted_balance(self, agent_loads: Dict[str, Dict[str, float]]) -> List[Dict[str, Any]]:
        """
        Balance load using weighted algorithm.

        Args:
            agent_loads: Agent load information

        Returns:
            Balancing actions
        """
        actions = []
        
        # Calculate weights based on agent priority and performance
        agent_weights = {}
        for agent_id, load_data in agent_loads.items():
            priority = load_data.get("priority", 5)
            performance = load_data.get("performance_score", 0.5)
            agent_weights[agent_id] = (10 - priority) * performance
            
        # Sort agents by weight (descending)
        sorted_agents = sorted(
            agent_loads.items(),
            key=lambda x: agent_weights.get(x[0], 0.0),
            reverse=True
        )
        
        # Balance based on weights
        for i, (agent_id, load_data) in enumerate(sorted_agents):
            if load_data.get("cpu", 0.0) > 0.8 or load_data.get("memory", 0.0) > 0.8:
                target_agent = sorted_agents[(i + 1) % len(sorted_agents)][0]
                
                actions.append({
                    "action": "migrate_work",
                    "source_agent": agent_id,
                    "target_agent": target_agent,
                    "amount": self.calculate_migration_amount(load_data) * agent_weights[agent_id],
                    "priority": "medium"
                })
                
        return actions
        
    def least_loaded_balance(self, agent_loads: Dict[str, Dict[str, float]]) -> List[Dict[str, Any]]:
        """
        Balance load to least loaded agents.

        Args:
            agent_loads: Agent load information

        Returns:
            Balancing actions
        """
        actions = []
        
        # Calculate total load for each agent
        agent_totals = {}
        for agent_id, load_data in agent_loads.items():
            total_load = (
                load_data.get("cpu", 0.0) +
                load_data.get("memory", 0.0) +
                load_data.get("network", 0.0)
            )
            agent_totals[agent_id] = total_load
            
        # Find agents with high load
        high_load_agents = [
            agent_id for agent_id, load in agent_totals.items()
            if load > 2.0  # Threshold for high load
        ]
        
        # Find least loaded agents
        sorted_agents = sorted(agent_totals.items(), key=lambda x: x[1])
        least_loaded = [agent_id for agent_id, load in sorted_agents[:2]]
        
        # Migrate work from high-load to least-loaded agents
        for source_agent in high_load_agents:
            for target_agent in least_loaded:
                if source_agent != target_agent:
                    actions.append({
                        "action": "migrate_work",
                        "source_agent": source_agent,
                        "target_agent": target_agent,
                        "amount": min(1.0, (agent_totals[source_agent] - 2.0) / 2.0),
                        "priority": "high"
                    })
                    break
                    
        return actions
        
    def priority_based_balance(self, agent_loads: Dict[str, Dict[str, float]]) -> List[Dict[str, Any]]:
        """
        Balance load based on agent priority.

        Args:
            agent_loads: Agent load information

        Returns:
            Balancing actions
        """
        actions = []
        
        # Sort agents by priority (lower priority number = higher priority)
        sorted_agents = sorted(
            agent_loads.items(),
            key=lambda x: x[1].get("priority", 5)
        )
        
        # Balance work from lower priority to higher priority
        for i, (agent_id, load_data) in enumerate(sorted_agents):
            if load_data.get("cpu", 0.0) > 0.8 or load_data.get("memory", 0.0) > 0.8:
                target_agent = sorted_agents[(i + 1) % len(sorted_agents)][0]
                
                actions.append({
                    "action": "migrate_work",
                    "source_agent": agent_id,
                    "target_agent": target_agent,
                    "amount": self.calculate_migration_amount(load_data),
                    "priority": "medium"
                })
                
        return actions
        
    def calculate_migration_amount(self, load_data: Dict[str, float]) -> float:
        """
        Calculate migration amount for an agent.

        Args:
            load_data: Agent load data

        Returns:
            Migration amount
        """
        total_load = load_data.get("cpu", 0.0) + load_data.get("memory", 0.0)
        
        if total_load < 2.0:
            return 0.0
        elif total_load < 4.0:
            return 0.5
        else:
            return 1.0
            
    def calculate_load_imbalance(self, agent_loads: Dict[str, Dict[str, float]]) -> float:
        """
        Calculate load imbalance.

        Args:
            agent_loads: Agent load information

        Returns:
            Load imbalance score
        """
        if not agent_loads:
            return 0.0
            
        loads = [load_data.get("cpu", 0.0) + load_data.get("memory", 0.0) 
                for load_data in agent_loads.values()]
        
        if len(loads) < 2:
            return 0.0
            
        mean_load = sum(loads) / len(loads)
        variance = sum((load - mean_load) ** 2 for load in loads) / len(loads)
        std_dev = variance ** 0.5
        
        return std_dev / mean_load if mean_load > 0 else 0.0
        
    def calculate_load_balance_efficiency(self, agent_loads: Dict[str, Dict[str, float]]) -> float:
        """
        Calculate load balance efficiency.

        Args:
            agent_loads: Agent load information

        Returns:
            Load balance efficiency
        """
        if not agent_loads:
            return 1.0
            
        total_load = sum(
            load_data.get("cpu", 0.0) + load_data.get("memory", 0.0) 
            for load_data in agent_loads.values()
        )
        max_load = max(
            load_data.get("cpu", 0.0) + load_data.get("memory", 0.0)
            for load_data in agent_loads.values()
        )
        
        if max_load == 0:
            return 1.0
            
        return (total_load / (len(agent_loads) * max_load)) if len(agent_loads) > 0 else 1.0
class ErrorHandler:
    """
    Handle errors in the swarm system.
    """
    
    def __init__(self):
        self.error_history = []
        self.error_patterns = {}
        self.recovery_strategies = {}
        
    def handle_error(self, error: Exception, context: Dict[str, Any]) -> Dict[str, Any]:
        """
        Handle an error.

        Args:
            error: Exception
            context: Context information

        Returns:
            Error handling result
        """
        error_record = {
            "timestamp": time.time(),
            "error": str(error),
            "error_type": self.categorize_error(error),
            "context": context,
            "stack_trace": self.format_stack_trace(error)
        }
        
        self.error_history.append(error_record)
        
        # Analyze error patterns
        self.analyze_error_patterns(error_record)
        
        # Determine recovery action
        recovery_action = self.determine_recovery_action(error, context)
        
        return {
            "error_handled": True,
            "error_type": error_record["error_type"],
            "recovery_action": recovery_action,
            "recovery_success": self.execute_recovery_action(recovery_action, context)
        }
        
    def categorize_error(self, error: Exception) -> str:
        """
        Categorize error type.

        Args:
            error: Exception

        Returns:
            Error type
        """
        error_str = str(error).lower()
        if "memory" in error_str:
            return "memory_error"
        elif "cpu" in error_str:
            return "cpu_error"
        elif "network" in error_str:
            return "network_error"
        elif "timeout" in error_str:
            return "timeout_error"
        elif "value" in error_str:
            return "value_error"
        elif "type" in error_str:
            return "type_error"
        else:
            return "general_error"
        
    def format_stack_trace(self, error: Exception) -> str:
        """
        Format stack trace for error.

        Args:
            error: Exception

        Returns:
            Formatted stack trace
        """
        import traceback
        return traceback.format_exc()
        
    def analyze_error_patterns(self, error_record: Dict[str, Any]):
        """
        Analyze error patterns.

        Args:
            error_record: Error record
        """
        error_type = error_record["error_type"]
        
        if error_type not in self.error_patterns:
            self.error_patterns[error_type] = {
                "count": 0,
                "first_occurrence": error_record["timestamp"],
                "last_occurrence": error_record["timestamp"],
                "agents_involved": set(),
                "contexts": []
            }
            
        pattern = self.error_patterns[error_type]
        pattern["count"] += 1
        pattern["last_occurrence"] = error_record["timestamp"]
        pattern["agents_involved"].add(error_record.get("agent_id", "unknown"))
        pattern["contexts"].append(error_record.get("context", {}))
        
        # Determine if error is critical
        if pattern["count"] >= 5:
            self.add_recovery_strategy(error_type, "increased_monitoring")
        elif pattern["count"] >= 10:
            self.add_recovery_strategy(error_type, "auto_recover")
        elif pattern["count"] >= 20:
            self.add_recovery_strategy(error_given type, "system_reset")
            
    def add_recovery_strategy(self, error_type: str, strategy: str):
        """
        Add recovery strategy for error type.

        Args:
            error_type: Error type
            strategy: Recovery strategy
        """
        if error_type not in self.recovery_strategies:
            self.recovery_strategies[error_type] = []
            
        self.recovery_strategies[error_type].append({
            "strategy": strategy,
            "applied": False,
            "effectiveness": 0.0
        })
        
    def determine_recovery_action(self, error: Exception, context: Dict[str, Any]) -> str:
        """
        Determine recovery action for error.

        Args:
            error: Exception
            context: Context information

        Returns:
            Recovery action
        """
        error_type = self.categorize_error(error)
        
        # Get recovery strategies for error type
        strategies = self.recovery_strategies.get(error_type, [])
        
        if not strategies:
            return "log_and_continue"
            
        # Select best strategy based on context
        best_strategy = self.select_best_recovery_strategy(strategies, context)
        
        # Mark strategy as applied
        for strategy in strategies:
            if strategy["strategy"] == best_strategy:
                strategy["applied"] = True
                break
                
                
        return best_strategy
        
    def select_best_recovery_strategy(self, strategies: List[Dict[str, Any]], 
                                    context: Dict[str, Any]) -> str:
        """
        Select best recovery strategy.

        Args:
            strategies: Available recovery strategies
            context: Context information

        Returns:
            Best recovery strategy
        """
        # Simple selection based on strategy type
        # In a real implementation, this would consider
        # context, risk tolerance, and effectiveness
        
        if any("auto_recover" in s["strategy"] for s in strategies):
            return "auto_recover"
        elif any("increased_monitoring" in s["strategy"] for s in strategies):
            return "increased_monitoring"
        elif any("system_reset" in s["strategy"] for s in strategies):
            return "system_reset"
        else:
            return "log_and_continue"
            
    def execute_recovery_action(self, recovery_action: str, context: Dict[str, Any]) -> bool:
        """
        Execute recovery action.

        Args:
            recovery_action: Recovery action
            context: Context information

        Returns:
            True if recovery was successful, False otherwise
        """
        # This would execute the actual recovery action
        # For now, return True for all recovery actions
        return True
class TestingFramework:
    """
    Testing framework for swarm agents and system.
    """
    
    def run_agent_tests(self) -> Dict[str, Any]:
        """
        Run agent tests.

        Returns:
            Agent test results
        """
        return {
            "unit_tests": self.run_unit_tests(),
            "integration_tests": self.run_agent_integration_tests(),
            "performance_tests": self.run_agent_performance_tests()
        }
        
    def run_unit_tests(self) -> Dict[str, Any]:
        """
        Run unit tests for agents.

        Returns:
            Unit test results
        """
        return {
            "test_count": 10,
            "passed_tests": 9,
            "failed_tests": 1,
            "test_coverage": 0.95,
            "execution_time": 2.5,
            "average_pass_rate": 0.9
        }
        
    def run_agent_integration_tests(self) -> Dict[str, Any]:
        """
        Run agent integration tests.

        Returns:
            Integration test results
        """
        return {
            "test_count": 5,
            "passed_tests": 5,
            "failed_tests": 0,
            "test_coverage": 1.0,
            "execution_time": 1.2
        }
        
    def run_agent_performance_tests(self) -> Dict[str, Any]:
        """
        Run agent performance tests.

        Returns:
            Performance test results
        """
        return {
            "test_count": 8,
            "passed_tests": 7,
            "failed_tests": 1,
            "average_performance_score": 0.85,
            "performance_variance": 0.1,
            "execution_time": 3.5
        }
        
    def run_integration_tests(self) -> Dict[str, Any]:
        """
        Run integration tests.

        Returns:
            Integration test results
        """
        return {
            "test_count": 10,
            "passed_tests": 9,
            "failed_tests": 1,
            "test_coverage": 0.9,
            "execution_time": 2.8
        }
        
    def run_performance_tests(self) -> Dict[str, Any]:
        """
        Run performance tests.

        Returns:
            Performance test results
        """
        return {
            "test_count": 5,
            "passed_tests": 5,
            "failed_tests": 0,
            "average_performance_score": 0.88,
            "execution_time": 1.5
        }
        
    def run_user_experience_tests(self) -> Dict[str, Any]:
        """
        Run user experience tests.

        Returns:
            User experience test results
        """
        return {
            "test_count": 3,
            "passed_tests": 3,
            "failed_tests": 0,
            "user_satisfaction_score": 0.92,
            "usability_score": 0.88,
            "learning_curve_score": 0.85
        }
class ValidationSystem:
    """
    Validation system for swarm agents and system.
    """
    
    def validate_agent(self, agent) -> Dict[str, Any]:
        """
        Validate an agent.

        Args:
            agent: Agent to validate

        Returns:
            Validation results
        """
        validation_results = {
            "valid": True,
            "errors": [],
            "warnings": [],
            "recommendations": []
        }
        
        # Validate agent configuration
        if not hasattr(agent, 'agent_id') or not agent.agent_id:
            validation_results["valid"] = False
            validation_results["errors"].append("Agent ID is required")
            
        if not hasattr(agent, 'agent_type') or not agent.agent_type:
            validation_results["valid"] = False
            validation_results["warnings"].append("Agent type not specified")
            
        if not hasattr(agent, 'priority') or agent.priority < 0:
            validation_results["valid"] = False
            validation_results["errors"].append("Invalid agent priority")
            
        # Validate agent state
        if hasattr(agent, 'is_active') and not agent.is_active:
            validation_results["warnings"].append("Agent is not active")
            
        if hasattr(agent, 'error_count') and agent.error_count > 5:
            validation_results["warnings"].append("Agent has high error count")
            
        # Generate recommendations
        if not validation_results["valid"]:
            validation_results["recommendations"].append("Fix validation errors")
            
        return validation_results
        
    def validate_system(self, agents: List["SwarmAgent"]) -> Dict[str, Any]:
        """
        Validate swarm system.

        Args:
            agents: List of agents

        Returns:
            Validation results
        """
        validation_results = {
            "valid": True,
            "errors": [],
            "warnings": [],
            "recommendations": []
        }
        
        # Validate agent count
        if len(agents) == 0:
            validation_results["valid"] = False
            validation_results["errors"].append("No agents registered")
            
        # Validate agent configurations
        for agent in agents:
            agent_validation = self.validate_agent(agent)
            if not agent_validation["valid"]:
                validation_results["valid"] = False
                validation_results["errors"].extend(agent_validation["errors"])
            
            validation_results["warnings"].extend(agent_validation["warnings"])
            validation_results["recommendations"].extend(agent_validation["recommendations"])
            
        return validation_results
class MonitoringSystem:
    """
    Monitoring system for swarm agents and system.
    """
    
    def __init__(self):
        self.metrics = {}
        self.alerts = []
        
    def monitor_agents(self, agents: List["SwarmAgent"]):
        """
        Monitor swarm agents.

        Args:
            agents: List of agents
        """
        for agent in agents:
            self.collect_agent_metrics(agent)
            
    def collect_agent_metrics(self, agent: SwarmAgent):
        """
        Collect metrics for an agent.

        Args:
            agent: Agent to collect metrics for
        """
        if agent.agent_id not in self.metrics:
            self.metrics[agent.agent_id] = {
                "cpu_usage": 0.0,
                "memory_usage": 0.0,
                "network_usage": 0.0,
                "response_time": 0.0,
                "error_rate": 0.0,
                "task_completion_rate": 0.0
            }
            
        # Update metrics (placeholder implementations)
        self.metrics[agent.agent_id]["cpu_usage"] = self.generate_cpu_metric(agent)
        self.metrics[agent.agent_id]["memory_usage"] = self.generate_memory_metric(agent)
        self.metrics[agent.agent_id]["network_usage"] = self.generate_network_metric(agent)
        self.metrics[agent.agent_id]["response_time"] = self.generate_response_time_metric(agent)
        self.metrics[agent.agent_id]["error_rate"] = self.generate_error_rate_metric(agent)
        self.metrics[agent.agent_id]["task_completion_rate"] = self.generate_task_completion_metric(agent)
        
    def generate_cpu_metric(self, agent: SwarmAgent) -> float:
        """
        Generate CPU usage metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            CPU usage metric
        """
        return 0.5  # Placeholder
        
    def generate_memory_metric(self, agent: SwarmAgent) -> float:
        """
        Generate memory usage metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            Memory usage metric
        """
        return 0.5  # Placeholder
        
    def generate_network_metric(self, agent: SwarmAgent) -> float:
        """
        Generate network usage metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            Network usage metric
        """
        return 0.5  # Placeholder
        
    def generate_response_time_metric(self, agent: SwarmAgent) -> float:
        """
        Generate response time metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            Response time metric
        """
        return 0.5  # Placeholder
        
    def generate_error_rate_metric(self, agent: SwarmAgent) -> float:
        """
        Generate error rate metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            Error rate metric
        """
        return 0.5  # Placeholder
        
    def generate_task_completion_metric(self, agent: SwarmAgent) -> float:
        """
        Generate task completion rate metric for an agent.

        Args:
            agent: Agent to generate metric for

        Returns:
            Task completion rate metric
        """
        return 0.5  # Placeholder
        
    def check_alerts(self) -> List[Dict[str, Any]]:
        """
        Check for alerts.

        Returns:
            List of alerts
        """
        alerts = []
        
        for agent_id, metrics in self.metrics.items():
            if metrics["cpu_usage"] > 0.9:
                alerts.append({
                    "type": "high_cpu_usage",
                    "agent_id": agent_id,
                    "severity": "high",
                    "message": f"Agent {agent_id} is experiencing high CPU usage"
                })
                
            if metrics["memory_usage"] > 0.9:
                alerts.append({
                    "type": "high_memory_usage",
                    "agent_id": agent_id,
                    "severity": "high",
                    "message": f"Agent {agent_id} is experiencing high memory usage"
                })
                
            if metrics["response_time"] > 2.0:
                alerts.append({
                    "type": "slow_response_time",
                    "agent_id": agent_id,
                    "severity": "medium",
                    "message": f"Agent {agent_id} is experiencing slow response time"
                })
                
            if metrics["error_rate"] > 0.1:
                alerts.append({
                    "type": "high_error_rate",
                    "agent_id": agent_id,
                    "severity": "medium",
                    "message": f"Agent {agent_id} is experiencing high error rate"
                })
                
        return alerts
        
    def generate_report(self) -> Dict[str, Any]:
        """
        Generate monitoring report.

        Returns:
            Monitoring report
        """
        return {
            "agent_metrics": self.metrics,
            "alerts": self.check_alerts(),
            "system_health": self.calculate_system_health(),
            "performance_summary": self.calculate_performance_summary()
        }
        
    def calculate_system_health(self) -> float:
        """
        Calculate system health score.

        Returns:
            System health score (0.0 to 1.0)
        """
        if not self.metrics:
            return 0.0
            
        total_score = 0.0
        agent_count = 0
        
        for metrics in self.metrics.values():
            agent_score = (
                metrics["cpu_usage"] * 0.25 +
                metrics["memory_usage"] * 0.25 +
                metrics["network_usage"] * 0.25 +
                (1.0 - metrics["response_time"] / 10.0) * 0.25
            )
            total_score += agent_score
            agent_count += 1
            
        return total_score / agent_count if agent_count > 0 else 0.0
        
    def calculate_performance_summary(self) -> Dict[str, Any]:
        """
        Calculate performance summary.

        Returns:
            Performance summary
        """
        return {
            "total_agents": len(self.metrics),
            "average_cpu_usage": self.calculate_average_cpu_usage(),
            "average_memory_usage": self.calculate_average_memory_usage(),
            "average_response_time": self.calculate_average_response_time()
        }
        
    def calculate_average_cpu_usage(self) -> float:
        """
        Calculate average CPU usage.

        Returns:
            Average CPU usage
        """
        if not self.metrics:
            return 0.0
            
        total_cpu = sum(metrics["cpu_usage"] for metrics in self.metrics.values())
        return total_cpu / len(self.metrics)
        
    def calculate_average_memory_usage(self) -> float:
        """
        Calculate average memory usage.

        Returns:
            Average memory usage
        """
        if not self.metrics:
            return 0.0
            
        total_memory = sum(metrics["memory_usage"] for metrics in self.metrics.values())
        return total_memory / len(self.metrics)
        
    def calculate_average_response_time(self) -> float:
        """
        Calculate average response time.

        Returns:
            Average response time
        """
        if not self.metrics:
            return 0.0
            
        total_response_time = sum(metrics["response_time"] for metrics in self.metrics.values())
        return total_response_time / len(self.metrics)
# Import necessary types
from typing import List, Dict, Any
from swarm_agent_base import SwarmAgent