/**
 * Swarm Intelligence - Collective intelligence and distributed coordination
 *
 * Implements swarm-based decision making, consensus algorithms, and adaptive
 * topology management for optimal agent coordination and task execution.
 */

import { EventEmitter } from 'eventemitter3';

import {
  SwarmConfig,
  SwarmTopology,
  TopologyType,
  Agent,
  Task,
  MemoryContext,
  OperationResult,
  Bottleneck,
} from '../types';

export class SwarmIntelligence extends EventEmitter {
  private config: SwarmConfig;
  private activeSwarms: Map<string, SwarmInstance> = new Map();
  private topologyTemplates: Map<TopologyType, SwarmTopology> = new Map();
  private consensusEngine: ConsensusEngine;
  private adaptiveManager: AdaptiveTopologyManager;
  private collectiveMemory: Map<string, any> = new Map();

  constructor(config: SwarmConfig) {
    super();
    this.config = config;
    this.consensusEngine = new ConsensusEngine(config);
    this.adaptiveManager = new AdaptiveTopologyManager(config);
    this.initializeTopologyTemplates();
  }

  async initialize(): Promise<OperationResult> {
    try {
      // Initialize topology templates
      this.initializeTopologyTemplates();

      // Setup consensus engine
      await this.consensusEngine.initialize();

      // Initialize adaptive management
      await this.adaptiveManager.initialize();

      // Setup collective memory
      this.initializeCollectiveMemory();

      return {
        success: true,
        message: 'Swarm Intelligence system initialized successfully',
      };
    } catch (error) {
      return {
        success: false,
        message: `Swarm Intelligence initialization failed: ${error.message}`,
        error: error,
      };
    }
  }

  private initializeTopologyTemplates(): void {
    // Mesh Topology - Full connectivity, high fault tolerance
    this.topologyTemplates.set('mesh', {
      type: 'mesh',
      maxAgents: 12,
      connectionPattern: 'full-mesh',
      coordinationStyle: 'peer-to-peer',
      faultTolerance: 'high',
      metadata: {
        algorithm: 'mesh-consensus',
        parameters: { connectionDensity: 'full' },
        constraints: { maxNodes: 10 },
        optimizations: ['fault-tolerance', 'consensus'],
        communicationOverhead: 0.8,
        decisionSpeed: 0.6,
        scalability: 0.3,
        optimalFor: ['consensus-critical', 'fault-tolerance', 'small-teams'],
      },
    });

    // Hierarchical Topology - Tree structure, centralized coordination
    this.topologyTemplates.set('hierarchical', {
      type: 'hierarchical',
      maxAgents: 50,
      connectionPattern: 'tree',
      coordinationStyle: 'top-down',
      faultTolerance: 'medium',
      metadata: {
        algorithm: 'hierarchical-tree',
        parameters: { depth: 3, branchingFactor: 5 },
        constraints: { maxDepth: 4 },
        optimizations: ['scalability', 'performance'],
        communicationOverhead: 0.2,
        decisionSpeed: 0.9,
        scalability: 0.9,
        optimalFor: ['large-projects', 'structured-tasks', 'command-control'],
      },
    });

    // Adaptive Topology - Dynamic structure, context-aware
    this.topologyTemplates.set('adaptive', {
      type: 'adaptive',
      maxAgents: 25,
      connectionPattern: 'dynamic',
      coordinationStyle: 'adaptive',
      faultTolerance: 'high',
      metadata: {
        algorithm: 'adaptive-swarm',
        parameters: { adaptationRate: 0.1, learningFactor: 0.05 },
        constraints: { minAgents: 2, maxAgents: 20 },
        optimizations: ['adaptation', 'learning'],
        communicationOverhead: 0.5,
        decisionSpeed: 0.7,
        scalability: 0.6,
        optimalFor: [
          'complex-projects',
          'changing-requirements',
          'optimization',
        ],
      },
    });

    // Ring Topology - Circular connectivity, distributed load
    this.topologyTemplates.set('ring', {
      type: 'ring',
      maxAgents: 20,
      connectionPattern: 'circular',
      coordinationStyle: 'distributed',
      faultTolerance: 'medium',
      metadata: {
        algorithm: 'ring-topology',
        parameters: { ringSize: 10 },
        constraints: { maxRingSize: 15 },
        optimizations: ['balanced-load', 'predictability'],
        communicationOverhead: 0.5,
        decisionSpeed: 0.6,
        scalability: 0.6,
        optimalFor: [
          'pipeline-tasks',
          'sequential-processing',
          'load-balancing',
        ],
      },
    });

    // Star Topology - Central hub, spoke coordination
    this.topologyTemplates.set('star', {
      type: 'star',
      maxAgents: 30,
      connectionPattern: 'hub-spoke',
      coordinationStyle: 'centralized',
      faultTolerance: 'low',
      metadata: {
        algorithm: 'star-central',
        parameters: { centralNode: 'coordinator' },
        constraints: { maxSpokes: 20 },
        optimizations: ['performance', 'speed'],
        communicationOverhead: 0.1,
        decisionSpeed: 0.95,
        scalability: 0.9,
        optimalFor: ['coordination-intensive', 'real-time', 'simple-tasks'],
      },
    });
  }

  private initializeCollectiveMemory(): void {
    // Initialize shared knowledge bases
    this.collectiveMemory.set('successful-patterns', new Map());
    this.collectiveMemory.set('failure-patterns', new Map());
    this.collectiveMemory.set('optimization-history', []);
    this.collectiveMemory.set('consensus-decisions', []);
    this.collectiveMemory.set('performance-metrics', new Map());
  }

  /**
   * Select optimal topology for task and agents
   */
  async selectOptimalTopology(
    agentTypes: string[],
    task: string
  ): Promise<SwarmTopology> {
    const analysis = await this.analyzeTaskRequirements(agentTypes, task);

    // Score each topology
    const topologyScores = new Map<TopologyType, number>();

    for (const [type, template] of this.topologyTemplates.entries()) {
      const score = this.calculateTopologyScore(template, analysis);
      topologyScores.set(type, score);
    }

    // Select best topology
    const bestTopology = Array.from(topologyScores.entries()).sort(
      ([, a], [, b]) => b - a
    )[0];

    const selectedTemplate = this.topologyTemplates.get(bestTopology[0])!;

    // Customize topology for specific requirements
    const customizedTopology = await this.customizeTopology(
      selectedTemplate,
      analysis
    );

    this.emit('topology-selected', {
      topology: customizedTopology,
      score: bestTopology[1],
      analysis: analysis,
    });

    return customizedTopology;
  }

  private async analyzeTaskRequirements(
    agentTypes: string[],
    task: string
  ): Promise<any> {
    return {
      agentCount: agentTypes.length,
      taskComplexity: this.estimateTaskComplexity(task),
      coordinationNeeds: this.assessCoordinationNeeds(agentTypes),
      faultToleranceRequirement: this.assessFaultToleranceNeed(task),
      scalabilityRequirement: this.assessScalabilityNeed(agentTypes, task),
      timeConstraints: this.assessTimeConstraints(task),
      resourceConstraints: this.assessResourceConstraints(agentTypes),
    };
  }

  private estimateTaskComplexity(task: string): number {
    // Simple complexity estimation based on task description
    let complexity = 1;

    const indicators = {
      refactor: 3,
      migrate: 4,
      implement: 2,
      test: 2,
      review: 1,
      optimize: 3,
      debug: 2,
      deploy: 2,
      design: 3,
      analyze: 2,
    };

    for (const [indicator, weight] of Object.entries(indicators)) {
      if (task.toLowerCase().includes(indicator)) {
        complexity += weight;
      }
    }

    // Length-based complexity
    complexity += Math.min(task.length / 100, 2);

    return Math.min(complexity, 10);
  }

  private assessCoordinationNeeds(agentTypes: string[]): string {
    const coordinationHeavyAgents = [
      'hierarchical-coordinator',
      'mesh-coordinator',
      'collective-intelligence-coordinator',
      'consensus-builder',
    ];

    const hasCoordinationAgents = agentTypes.some(type =>
      coordinationHeavyAgents.includes(type)
    );

    if (hasCoordinationAgents || agentTypes.length > 5) {
      return 'high';
    } else if (agentTypes.length > 2) {
      return 'medium';
    } else {
      return 'low';
    }
  }

  private assessFaultToleranceNeed(task: string): string {
    const criticalKeywords = [
      'production',
      'deploy',
      'release',
      'critical',
      'emergency',
    ];
    const hasCriticalKeywords = criticalKeywords.some(keyword =>
      task.toLowerCase().includes(keyword)
    );

    return hasCriticalKeywords ? 'high' : 'medium';
  }

  private assessScalabilityNeed(agentTypes: string[], task: string): string {
    if (
      agentTypes.length > 10 ||
      task.toLowerCase().includes('monorepo') ||
      task.toLowerCase().includes('large-scale')
    ) {
      return 'high';
    } else if (agentTypes.length > 5) {
      return 'medium';
    } else {
      return 'low';
    }
  }

  private assessTimeConstraints(task: string): string {
    if (
      task.toLowerCase().includes('urgent') ||
      task.toLowerCase().includes('asap')
    ) {
      return 'tight';
    } else if (
      task.toLowerCase().includes('quick') ||
      task.toLowerCase().includes('fast')
    ) {
      return 'medium';
    } else {
      return 'relaxed';
    }
  }

  private assessResourceConstraints(agentTypes: string[]): string {
    const resourceHeavyAgents = [
      'ml-developer',
      'performance-benchmarker',
      'perf-analyzer',
    ];
    const hasResourceHeavyAgents = agentTypes.some(type =>
      resourceHeavyAgents.includes(type)
    );

    return hasResourceHeavyAgents ? 'high' : 'medium';
  }

  private calculateTopologyScore(
    topology: SwarmTopology,
    analysis: any
  ): number {
    let score = 0;

    // Agent count fit
    if (analysis.agentCount <= topology.maxAgents) {
      score += 20;
    } else {
      score -= (analysis.agentCount - topology.maxAgents) * 2;
    }

    // Fault tolerance match
    const faultToleranceScore = {
      low: { high: -5, medium: 0, low: 10 },
      medium: { high: 5, medium: 15, low: 5 },
      high: { high: 20, medium: 10, low: -5 },
    };
    score +=
      faultToleranceScore[analysis.faultToleranceRequirement]?.[
        topology.faultTolerance
      ] || 0;

    // Scalability match
    const scalabilityBonus = {
      high: (topology.metadata?.scalability || 0) > 0.7 ? 15 : 0,
      medium:
        (topology.metadata?.scalability || 0) > 0.4 &&
        (topology.metadata?.scalability || 0) <= 0.7
          ? 10
          : 0,
      low: (topology.metadata?.scalability || 0) <= 0.4 ? 5 : 0,
    };
    score += scalabilityBonus[analysis.scalabilityRequirement] || 0;

    // Time constraints consideration
    if (analysis.timeConstraints === 'tight') {
      const speedBonus = {
        'very-fast': 15,
        fast: 10,
        medium: 5,
        adaptive: 0,
      };
      score += speedBonus[topology.metadata?.decisionSpeed] || 0;
    }

    // Task complexity fit
    if (analysis.taskComplexity > 7 && topology.type === 'adaptive') {
      score += 10; // Adaptive topology better for complex tasks
    }

    return score;
  }

  private async customizeTopology(
    template: SwarmTopology,
    analysis: any
  ): Promise<SwarmTopology> {
    const customized = { ...template };

    // Adjust max agents based on actual needs
    customized.maxAgents = Math.min(
      Math.max(analysis.agentCount * 1.5, template.maxAgents * 0.7),
      template.maxAgents
    );

    // Add specific metadata
    customized.metadata = {
      ...customized.metadata,
      customizedFor: analysis,
      createdAt: new Date().toISOString(),
      optimizations: this.suggestOptimizations(template, analysis),
    };

    return customized;
  }

  private suggestOptimizations(
    topology: SwarmTopology,
    analysis: any
  ): string[] {
    const optimizations: string[] = [];

    if (
      analysis.faultToleranceRequirement === 'high' &&
      topology.faultTolerance !== 'high'
    ) {
      optimizations.push('Consider redundant communication paths');
    }

    if (
      analysis.timeConstraints === 'tight' &&
      (topology.metadata?.decisionSpeed || 0) >= 0.5 &&
      (topology.metadata?.decisionSpeed || 0) < 0.8
    ) {
      optimizations.push('Enable fast-track decision making');
    }

    if (analysis.agentCount > topology.maxAgents * 0.8) {
      optimizations.push('Consider agent load balancing');
    }

    return optimizations;
  }

  /**
   * Execute task using swarm intelligence
   */
  async executeTask(
    task: Task,
    agents: Agent[],
    tools: any[],
    memoryContext: MemoryContext
  ): Promise<OperationResult> {
    try {
      // Create swarm instance
      const swarmId = this.generateSwarmId();
      const swarm = await this.createSwarmInstance(swarmId, agents, task);

      // Initialize collective intelligence
      await this.initializeCollectiveIntelligence(swarm, memoryContext);

      // Coordinate task execution
      const result = await this.coordinateExecution(swarm, task, tools);

      // Process collective learning
      await this.processCollectiveLearning(swarm, task, result);

      // Cleanup swarm
      await this.cleanupSwarm(swarmId);

      return result;
    } catch (error) {
      return {
        success: false,
        message: `Swarm execution failed: ${error.message}`,
        error: error,
      };
    }
  }

  private async createSwarmInstance(
    swarmId: string,
    agents: Agent[],
    task: Task
  ): Promise<SwarmInstance> {
    const topology = await this.selectOptimalTopology(
      agents.map(a => a.type),
      task.description
    );

    const swarm: SwarmInstance = {
      id: swarmId,
      agents: new Map(agents.map(agent => [agent.id, agent])),
      topology: topology,
      task: task,
      status: 'initializing',
      createdAt: new Date(),
      communication: new CommunicationMatrix(agents, topology),
      consensus: { decisions: [], currentDecision: null },
      performance: { startTime: new Date(), metrics: {} },
    };

    this.activeSwarms.set(swarmId, swarm);
    this.emit('swarm-created', swarm);

    return swarm;
  }

  private async initializeCollectiveIntelligence(
    swarm: SwarmInstance,
    memoryContext: MemoryContext
  ): Promise<void> {
    // Initialize swarm collective memory
    swarm.collectiveKnowledge = {
      sharedMemory: memoryContext,
      patterns: this.collectiveMemory.get('successful-patterns'),
      decisions: [],
      insights: [],
    };

    // Establish communication protocols
    await swarm.communication.initialize();

    // Setup consensus mechanisms
    await this.consensusEngine.setupSwarmConsensus(swarm);

    swarm.status = 'ready';
    this.emit('swarm-intelligence-initialized', swarm);
  }

  private async coordinateExecution(
    swarm: SwarmInstance,
    task: Task,
    tools: any[]
  ): Promise<OperationResult> {
    swarm.status = 'executing';

    try {
      // Break down task into sub-tasks
      const subTasks = await this.decomposeTask(task, swarm.agents.size);

      // Distribute sub-tasks using swarm intelligence
      const taskDistribution = await this.distributeSubTasks(
        subTasks,
        swarm,
        tools
      );

      // Coordinate parallel execution
      const results = await this.executeInParallel(taskDistribution, swarm);

      // Reach consensus on results
      const consensusResult = await this.consensusEngine.reachConsensus(
        swarm,
        results
      );

      // Aggregate and optimize results
      const finalResult = await this.aggregateResults(consensusResult, swarm);

      swarm.status = 'completed';
      return {
        success: true,
        message: 'Swarm execution completed successfully',
        data: finalResult,
      };
    } catch (error) {
      swarm.status = 'failed';
      throw error;
    }
  }

  private async decomposeTask(
    task: Task,
    _agentCount: number
  ): Promise<SubTask[]> {
    // Intelligent task decomposition based on task type and complexity
    const subTasks: SubTask[] = [];

    switch (task.type) {
      case 'coding':
        subTasks.push(
          {
            id: '1',
            type: 'analysis',
            description: 'Analyze requirements',
            priority: 'high',
          },
          {
            id: '2',
            type: 'design',
            description: 'Design solution',
            priority: 'high',
          },
          {
            id: '3',
            type: 'implementation',
            description: 'Implement code',
            priority: 'high',
          },
          {
            id: '4',
            type: 'testing',
            description: 'Write and run tests',
            priority: 'medium',
          },
          {
            id: '5',
            type: 'review',
            description: 'Code review',
            priority: 'medium',
          }
        );
        break;

      case 'review':
        subTasks.push(
          {
            id: '1',
            type: 'structural',
            description: 'Review code structure',
            priority: 'high',
          },
          {
            id: '2',
            type: 'logic',
            description: 'Review business logic',
            priority: 'high',
          },
          {
            id: '3',
            type: 'performance',
            description: 'Performance analysis',
            priority: 'medium',
          },
          {
            id: '4',
            type: 'security',
            description: 'Security review',
            priority: 'high',
          }
        );
        break;

      default:
        // Generic decomposition
        subTasks.push({
          id: '1',
          type: 'execution',
          description: task.description,
          priority: task.priority,
        });
    }

    return subTasks;
  }

  private async distributeSubTasks(
    subTasks: SubTask[],
    swarm: SwarmInstance,
    tools: any[]
  ): Promise<Map<string, Assignment>> {
    const assignments = new Map<string, Assignment>();

    // Use swarm intelligence to optimally assign tasks
    for (const subTask of subTasks) {
      const optimalAgent = await this.selectOptimalAgent(subTask, swarm, tools);
      const relevantTools = tools.filter(tool =>
        this.isToolRelevantForSubTask(tool, subTask)
      );

      assignments.set(subTask.id, {
        subTask,
        agent: optimalAgent,
        tools: relevantTools,
        estimatedTime: this.estimateExecutionTime(subTask, optimalAgent),
        dependencies: this.identifyDependencies(subTask, subTasks),
      });
    }

    return assignments;
  }

  private async selectOptimalAgent(
    subTask: SubTask,
    swarm: SwarmInstance,
    _tools: any[]
  ): Promise<Agent> {
    let bestAgent: Agent | null = null;
    let bestScore = -1;

    for (const agent of swarm.agents.values()) {
      const score = this.calculateAgentTaskFit(agent, subTask);
      if (score > bestScore) {
        bestScore = score;
        bestAgent = agent;
      }
    }

    return bestAgent!;
  }

  private calculateAgentTaskFit(agent: Agent, subTask: SubTask): number {
    let score = 0;

    // Capability match
    const taskCapabilities = this.extractRequiredCapabilities(subTask);
    const matchingCapabilities = agent.capabilities.filter(cap =>
      taskCapabilities.includes(cap)
    ).length;

    score += matchingCapabilities * 10;

    // Agent load consideration
    if (agent.status === 'idle') score += 5;
    if (agent.status === 'busy') score -= 3;

    // Historical performance
    score += agent.metrics.successRate * 3;

    return score;
  }

  private extractRequiredCapabilities(subTask: SubTask): string[] {
    const capabilityMap = {
      analysis: ['analysis', 'research'],
      design: ['architecture', 'design'],
      implementation: ['coding', 'implementation'],
      testing: ['testing', 'validation'],
      review: ['code-review', 'quality-assurance'],
      structural: ['architecture', 'code-review'],
      logic: ['analysis', 'code-review'],
      performance: ['performance', 'optimization'],
      security: ['security', 'code-review'],
    };

    return capabilityMap[subTask.type] || ['general'];
  }

  private isToolRelevantForSubTask(tool: any, subTask: SubTask): boolean {
    // Determine if tool capabilities match sub-task requirements
    const requiredCapabilities = this.extractRequiredCapabilities(subTask);
    return tool.capabilities?.some((cap: string) =>
      requiredCapabilities.includes(cap)
    );
  }

  private estimateExecutionTime(subTask: SubTask, agent: Agent): number {
    let baseTime = 1000; // Base time in ms

    // Adjust based on sub-task complexity
    const complexityMultipliers = {
      analysis: 1.2,
      design: 1.5,
      implementation: 2.0,
      testing: 1.3,
      review: 0.8,
    };

    baseTime *= complexityMultipliers[subTask.type] || 1.0;

    // Adjust based on agent performance
    baseTime *= 2 - agent.metrics.successRate; // Better agents are faster

    return Math.round(baseTime);
  }

  private identifyDependencies(
    subTask: SubTask,
    allSubTasks: SubTask[]
  ): string[] {
    const dependencies: string[] = [];

    // Simple dependency logic based on task types
    if (subTask.type === 'implementation') {
      const designTask = allSubTasks.find(t => t.type === 'design');
      if (designTask) dependencies.push(designTask.id);
    }

    if (subTask.type === 'testing') {
      const implTask = allSubTasks.find(t => t.type === 'implementation');
      if (implTask) dependencies.push(implTask.id);
    }

    return dependencies;
  }

  private async executeInParallel(
    assignments: Map<string, Assignment>,
    swarm: SwarmInstance
  ): Promise<Map<string, any>> {
    const results = new Map<string, any>();
    const executionPromises: Promise<void>[] = [];

    for (const [subTaskId, assignment] of assignments.entries()) {
      const promise = this.executeAssignment(assignment, swarm)
        .then(result => {
          results.set(subTaskId, result);
          this.emit('subtask-completed', {
            subTaskId,
            result,
            swarm: swarm.id,
          });
        })
        .catch(error => {
          results.set(subTaskId, { success: false, error });
          this.emit('subtask-failed', { subTaskId, error, swarm: swarm.id });
        });

      executionPromises.push(promise);
    }

    await Promise.allSettled(executionPromises);
    return results;
  }

  private async executeAssignment(
    assignment: Assignment,
    _swarm: SwarmInstance
  ): Promise<any> {
    // Simulate task execution with swarm coordination
    const { subTask, agent, tools, estimatedTime } = assignment;

    // Update agent status
    agent.status = 'busy';

    try {
      // Simulate execution delay
      await new Promise(resolve => setTimeout(resolve, estimatedTime * 0.1)); // Scaled down for demo

      // Execute with tools
      const toolResults = await Promise.all(
        tools.map(tool => this.simulateToolExecution(tool, subTask))
      );

      // Simulate successful execution
      const result = {
        subTaskId: subTask.id,
        agentId: agent.id,
        success: Math.random() > 0.1, // 90% success rate
        executionTime: estimatedTime,
        toolResults: toolResults,
        output: this.generateSubTaskOutput(subTask),
        timestamp: new Date(),
      };

      // Update agent metrics
      if (result.success) {
        agent.metrics.tasksCompleted++;
        agent.metrics.successRate = agent.metrics.successRate * 0.9 + 1 * 0.1;
      } else {
        agent.metrics.successRate = agent.metrics.successRate * 0.9 + 0 * 0.1;
      }

      agent.status = 'idle';
      return result;
    } catch (error) {
      agent.status = 'error';
      throw error;
    }
  }

  private async simulateToolExecution(
    tool: any,
    subTask: SubTask
  ): Promise<any> {
    // Simulate tool execution
    return {
      toolId: tool.id,
      subTaskId: subTask.id,
      result: `Tool ${tool.id} executed successfully for ${subTask.type}`,
      executionTime: Math.floor(Math.random() * 100) + 50,
    };
  }

  private generateSubTaskOutput(subTask: SubTask): string {
    const outputs = {
      analysis: 'Requirements analysis completed with detailed specifications',
      design: 'System architecture designed with optimal patterns',
      implementation: 'Code implementation completed with best practices',
      testing: 'Comprehensive test suite created and executed',
      review: 'Code review completed with quality improvements',
    };

    return (
      outputs[subTask.type] || `${subTask.description} completed successfully`
    );
  }

  private async aggregateResults(
    consensusResult: any,
    swarm: SwarmInstance
  ): Promise<any> {
    // Aggregate sub-task results into final result
    const aggregatedResult = {
      swarmId: swarm.id,
      taskId: swarm.task.id,
      topology: swarm.topology.type,
      agentCount: swarm.agents.size,
      executionTime: Date.now() - swarm.performance.startTime.getTime(),
      consensus: consensusResult,
      subResults: consensusResult.results,
      qualityScore: this.calculateQualityScore(consensusResult),
      insights: this.generateInsights(swarm, consensusResult),
    };

    return aggregatedResult;
  }

  private calculateQualityScore(consensusResult: any): number {
    const results = consensusResult.results || [];
    const successfulResults = results.filter((r: any) => r.success);

    let score = (successfulResults.length / results.length) * 0.7; // Success rate weight
    score += consensusResult.agreement * 0.2; // Consensus agreement weight
    score += (consensusResult.confidence || 0.5) * 0.1; // Confidence weight

    return Math.round(score * 100) / 100;
  }

  private generateInsights(swarm: SwarmInstance, result: any): string[] {
    const insights: string[] = [];

    if (result.agreement > 0.9) {
      insights.push('High consensus achieved - excellent swarm coordination');
    }

    if (swarm.topology.type === 'adaptive') {
      insights.push('Adaptive topology provided optimal flexibility');
    }

    const avgAgentSuccess =
      Array.from(swarm.agents.values()).reduce(
        (sum, agent) => sum + agent.metrics.successRate,
        0
      ) / swarm.agents.size;

    if (avgAgentSuccess > 0.8) {
      insights.push('Agent performance exceeded expectations');
    }

    return insights;
  }

  private async processCollectiveLearning(
    swarm: SwarmInstance,
    task: Task,
    result: any
  ): Promise<void> {
    // Store successful patterns
    if (result.success && result.data?.qualityScore > 0.8) {
      const pattern = {
        topology: swarm.topology.type,
        agentTypes: Array.from(swarm.agents.values()).map(a => a.type),
        taskType: task.type,
        qualityScore: result.data.qualityScore,
        executionTime: result.data.executionTime,
        timestamp: new Date(),
      };

      const successfulPatterns = this.collectiveMemory.get(
        'successful-patterns'
      );
      successfulPatterns.set(`${task.type}-${swarm.topology.type}`, pattern);
    }

    // Update performance metrics
    const performanceMetrics = this.collectiveMemory.get('performance-metrics');
    performanceMetrics.set(swarm.id, {
      task: task.type,
      topology: swarm.topology.type,
      performance: result.data,
    });

    this.emit('collective-learning-updated', {
      swarmId: swarm.id,
      pattern: result.success ? 'success' : 'failure',
      insights: result.data?.insights || [],
    });
  }

  /**
   * Update patterns based on new intelligence
   */
  async updatePatterns(pattern: any): Promise<void> {
    const patternType = this.classifyPattern(pattern);

    let patterns = this.collectiveMemory.get(`${patternType}-patterns`);
    if (!patterns) {
      patterns = new Map();
      this.collectiveMemory.set(`${patternType}-patterns`, patterns);
    }

    const patternKey = this.generatePatternKey(pattern);
    patterns.set(patternKey, {
      ...pattern,
      updatedAt: new Date(),
      confidence: this.calculatePatternConfidence(pattern),
    });

    this.emit('pattern-updated', { type: patternType, pattern });
  }

  private classifyPattern(pattern: any): string {
    if (pattern.type) return pattern.type;
    if (pattern.success === true) return 'successful';
    if (pattern.success === false) return 'failure';
    if (pattern.performance) return 'performance';
    return 'general';
  }

  private generatePatternKey(pattern: any): string {
    const components = [
      pattern.topology || 'unknown',
      pattern.taskType || 'general',
      pattern.agentTypes?.join('-') || 'mixed',
    ];

    return components.join('_');
  }

  private calculatePatternConfidence(pattern: any): number {
    let confidence = 0.5; // Base confidence

    if (pattern.qualityScore > 0.8) confidence += 0.3;
    if (pattern.executionTime < 5000) confidence += 0.1;
    if (pattern.consensus?.agreement > 0.9) confidence += 0.1;

    return Math.min(confidence, 1.0);
  }

  /**
   * Optimize topology based on bottleneck analysis
   */
  async optimizeTopology(bottleneck: Bottleneck): Promise<void> {
    const optimizationHistory = this.collectiveMemory.get(
      'optimization-history'
    );

    const optimization = {
      bottleneck,
      timestamp: new Date(),
      actions: this.generateOptimizationActions(bottleneck),
      impact: 'pending',
    };

    optimizationHistory.push(optimization);

    // Apply optimizations
    await this.applyOptimizations(optimization.actions);

    this.emit('topology-optimized', optimization);
  }

  private generateOptimizationActions(bottleneck: Bottleneck): string[] {
    const actions: string[] = [];

    switch (bottleneck.type) {
      case 'memory':
        actions.push('Enable memory compression');
        actions.push('Implement memory cleanup cycles');
        break;

      case 'cpu':
        actions.push('Distribute computation load');
        actions.push('Implement agent load balancing');
        break;

      case 'network':
        actions.push('Optimize communication patterns');
        actions.push('Enable message batching');
        break;

      case 'agent':
        actions.push('Scale agent resources');
        actions.push('Implement agent failover');
        break;

      case 'task-queue':
        actions.push('Increase task processing parallelism');
        actions.push('Implement priority-based scheduling');
        break;
    }

    return actions;
  }

  private async applyOptimizations(actions: string[]): Promise<void> {
    // Apply optimization actions to improve performance
    for (const action of actions) {
      try {
        await this.executeOptimizationAction(action);
      } catch (error) {
        console.warn(`Failed to apply optimization: ${action}`, error);
      }
    }
  }

  private async executeOptimizationAction(action: string): Promise<void> {
    // Simulate optimization action execution
    console.info(`Applying optimization: ${action}`);
    await new Promise(resolve => setTimeout(resolve, 100));
  }

  private generateSwarmId(): string {
    return `swarm-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
  }

  private async cleanupSwarm(swarmId: string): Promise<void> {
    const swarm = this.activeSwarms.get(swarmId);
    if (swarm) {
      // Cleanup communication matrix
      await swarm.communication.cleanup();

      // Reset agent statuses
      for (const agent of swarm.agents.values()) {
        if (agent.status === 'busy') {
          agent.status = 'idle';
        }
      }

      this.activeSwarms.delete(swarmId);
      this.emit('swarm-cleanup-completed', { swarmId });
    }
  }

  async getMetrics(): Promise<any> {
    return {
      activeSwarms: this.activeSwarms.size,
      availableTopologies: this.topologyTemplates.size,
      collectiveMemorySize: this.collectiveMemory.size,
      consensusEngine: await this.consensusEngine.getMetrics(),
      adaptiveManager: await this.adaptiveManager.getMetrics(),
      patterns: {
        successful: this.collectiveMemory.get('successful-patterns')?.size || 0,
        failure: this.collectiveMemory.get('failure-patterns')?.size || 0,
        performance:
          this.collectiveMemory.get('performance-metrics')?.size || 0,
      },
    };
  }

  async shutdown(): Promise<OperationResult> {
    try {
      // Cleanup all active swarms
      for (const swarmId of this.activeSwarms.keys()) {
        await this.cleanupSwarm(swarmId);
      }

      // Shutdown engines
      await this.consensusEngine.shutdown();
      await this.adaptiveManager.shutdown();

      this.collectiveMemory.clear();

      return {
        success: true,
        message: 'Swarm Intelligence system shutdown completed',
      };
    } catch (error) {
      return {
        success: false,
        message: `Shutdown failed: ${error.message}`,
        error: error,
      };
    }
  }
}

// Supporting Classes

interface SwarmInstance {
  id: string;
  agents: Map<string, Agent>;
  topology: SwarmTopology;
  task: Task;
  status: 'initializing' | 'ready' | 'executing' | 'completed' | 'failed';
  createdAt: Date;
  communication: CommunicationMatrix;
  consensus: { decisions: any[]; currentDecision: any };
  performance: { startTime: Date; metrics: any };
  collectiveKnowledge?: any;
}

interface SubTask {
  id: string;
  type: string;
  description: string;
  priority: 'low' | 'medium' | 'high' | 'critical';
}

interface Assignment {
  subTask: SubTask;
  agent: Agent;
  tools: any[];
  estimatedTime: number;
  dependencies: string[];
}

class CommunicationMatrix {
  private agents: Agent[];
  private topology: SwarmTopology;
  private connections: Map<string, string[]> = new Map();

  constructor(agents: Agent[], topology: SwarmTopology) {
    this.agents = agents;
    this.topology = topology;
  }

  async initialize(): Promise<void> {
    // Setup communication matrix based on topology
    this.buildConnectionMatrix();
  }

  private buildConnectionMatrix(): void {
    switch (this.topology.connectionPattern) {
      case 'full-mesh':
        this.buildFullMeshConnections();
        break;
      case 'tree':
        this.buildTreeConnections();
        break;
      case 'circular':
        this.buildRingConnections();
        break;
      case 'hub-spoke':
        this.buildStarConnections();
        break;
      default:
        this.buildDynamicConnections();
    }
  }

  private buildFullMeshConnections(): void {
    for (const agent of this.agents) {
      const connections = this.agents
        .filter(a => a.id !== agent.id)
        .map(a => a.id);
      this.connections.set(agent.id, connections);
    }
  }

  private buildTreeConnections(): void {
    if (this.agents.length === 0) return;

    // Simple tree structure - first agent is root
    const root = this.agents[0];
    this.connections.set(root.id, []);

    for (let i = 1; i < this.agents.length; i++) {
      const agent = this.agents[i];
      const parentIndex = Math.floor((i - 1) / 2);
      const parent = this.agents[parentIndex];

      // Connect to parent
      if (!this.connections.has(agent.id)) {
        this.connections.set(agent.id, []);
      }
      this.connections.get(agent.id)!.push(parent.id);

      // Parent connects to child
      if (!this.connections.has(parent.id)) {
        this.connections.set(parent.id, []);
      }
      this.connections.get(parent.id)!.push(agent.id);
    }
  }

  private buildRingConnections(): void {
    for (let i = 0; i < this.agents.length; i++) {
      const current = this.agents[i];
      const next = this.agents[(i + 1) % this.agents.length];
      const prev =
        this.agents[(i - 1 + this.agents.length) % this.agents.length];

      this.connections.set(current.id, [next.id, prev.id]);
    }
  }

  private buildStarConnections(): void {
    if (this.agents.length === 0) return;

    const hub = this.agents[0]; // First agent is hub
    const spokes = this.agents.slice(1);

    // Hub connects to all spokes
    this.connections.set(
      hub.id,
      spokes.map(s => s.id)
    );

    // Spokes connect only to hub
    for (const spoke of spokes) {
      this.connections.set(spoke.id, [hub.id]);
    }
  }

  private buildDynamicConnections(): void {
    // Dynamic connections based on agent capabilities and task requirements
    for (const agent of this.agents) {
      const connections = this.findOptimalConnections(agent);
      this.connections.set(agent.id, connections);
    }
  }

  private findOptimalConnections(agent: Agent): string[] {
    return this.agents
      .filter(a => a.id !== agent.id)
      .sort(
        (a, b) =>
          this.calculateConnectionScore(agent, b) -
          this.calculateConnectionScore(agent, a)
      )
      .slice(0, Math.min(3, this.agents.length - 1)) // Connect to top 3 compatible agents
      .map(a => a.id);
  }

  private calculateConnectionScore(agent1: Agent, agent2: Agent): number {
    // Score based on capability complementarity
    const commonCaps = agent1.capabilities.filter(cap =>
      agent2.capabilities.includes(cap)
    );
    const uniqueCaps = [
      ...new Set([...agent1.capabilities, ...agent2.capabilities]),
    ];

    return uniqueCaps.length - commonCaps.length; // Prefer diverse capabilities
  }

  async cleanup(): Promise<void> {
    this.connections.clear();
  }
}

class ConsensusEngine {
  private config: SwarmConfig;

  constructor(config: SwarmConfig) {
    this.config = config;
  }

  async initialize(): Promise<void> {
    // Initialize consensus mechanisms
  }

  async setupSwarmConsensus(swarm: SwarmInstance): Promise<void> {
    // Setup consensus for specific swarm
    swarm.consensus = {
      decisions: [],
      currentDecision: null,
    };
  }

  async reachConsensus(
    swarm: SwarmInstance,
    results: Map<string, any>
  ): Promise<any> {
    const resultsArray = Array.from(results.values());
    const successfulResults = resultsArray.filter(r => r.success);

    const consensus = {
      results: resultsArray,
      agreement: successfulResults.length / resultsArray.length,
      confidence: this.calculateConsensusConfidence(resultsArray),
      decision:
        successfulResults.length > resultsArray.length / 2
          ? 'accept'
          : 'reject',
      participatingAgents: swarm.agents.size,
      timestamp: new Date(),
    };

    swarm.consensus.decisions.push(consensus);
    return consensus;
  }

  private calculateConsensusConfidence(results: any[]): number {
    if (results.length === 0) return 0;

    const avgQuality =
      results
        .filter(r => r.success && r.qualityScore !== undefined)
        .reduce((sum, r) => sum + (r.qualityScore || 0), 0) / results.length;

    return Math.round(avgQuality * 100) / 100;
  }

  async getMetrics(): Promise<any> {
    return {
      threshold: this.config.consensusThreshold,
      algorithmsSupported: ['majority', 'weighted', 'byzantine-fault-tolerant'],
    };
  }

  async shutdown(): Promise<void> {
    // Cleanup consensus resources
  }
}

class AdaptiveTopologyManager {
  private config: SwarmConfig;
  private optimizationHistory: any[] = [];

  constructor(config: SwarmConfig) {
    this.config = config;
  }

  async initialize(): Promise<void> {
    // Initialize adaptive management
  }

  async getMetrics(): Promise<any> {
    return {
      adaptiveScaling: this.config.adaptiveScaling,
      optimizations: this.optimizationHistory.length,
    };
  }

  async shutdown(): Promise<void> {
    this.optimizationHistory = [];
  }
}