/**
 * Neural Pattern Recognition Engine with TensorFlow.js
 * True machine learning for pattern detection, learning, and optimization
 */

import * as tf from '@tensorflow/tfjs-node';
import { EventEmitter } from 'node:events';
import { ILogger } from '../core/logger.ts';
import { IEventBus } from '../core/event-bus.ts';
import { TaskDefinition, AgentState, TaskResult } from '../swarm/types.ts';
import { generateId } from '../utils/helpers.ts';

export interface NeuralPattern {
  id: string;
  name: string;
  type: 'coordination' | 'task_prediction' | 'behavior_analysis' | 'optimization';
  description: string;
  confidence: number;
  accuracy: number;
  trainingData: number;
  features: string[];
  model: tf.LayersModel;
  createdAt: Date;
  lastTrained: Date;
  usageCount: number;
  successRate: number;
  metadata: Record<string, any>;
}

export interface PatternPrediction {
  patternId: string;
  prediction: number[];
  confidence: number;
  features: Record<string, number>;
  reasoning: string;
  timestamp: Date;
}

export interface LearningContext {
  taskType: string;
  agentCapabilities: string[];
  environment: Record<string, any>;
  historicalPerformance: number[];
  resourceUsage: Record<string, number>;
  communicationPatterns: any[];
  outcomes: string[];
}

export interface NeuralConfig {
  modelUpdateInterval: number;
  confidenceThreshold: number;
  trainingBatchSize: number;
  maxTrainingEpochs: number;
  learningRate: number;
  enableWasmAcceleration: boolean;
  patternCacheSize: number;
  autoRetraining: boolean;
  qualityThreshold: number;
}

/**
 * Neural Pattern Recognition Engine using TensorFlow.js
 * Provides true machine learning capabilities for pattern detection and optimization
 */
export class NeuralPatternEngine extends EventEmitter {
  private logger: ILogger;
  private eventBus: IEventBus;
  private config: NeuralConfig;
  
  // Neural models for different pattern types
  private patterns = new Map<string, NeuralPattern>();
  private modelCache = new Map<string, tf.LayersModel>();
  private trainingQueues = new Map<string, any[]>();
  private predictionCache = new Map<string, PatternPrediction>();
  
  // Learning data collection
  private trainingData = new Map<string, any[]>();
  private featureExtractors = new Map<string, (data: any) => number[]>();
  private labelEncoders = new Map<string, Map<string, number>>();
  
  // Performance tracking
  private patternMetrics = new Map<string, {
    predictions: number;
    accuracy: number;
    avgConfidence: number;
    lastUpdate: Date;
  }>();
  
  // Advanced learning capabilities
  private transferLearning = new Map<string, tf.LayersModel>();
  private ensembleModels = new Map<string, tf.LayersModel[]>();
  private reinforcementLearning = new Map<string, any>();
  private emergentPatterns = new Map<string, any[]>();
  
  // Cross-session persistence
  private persistenceManager?: any;
  private sessionId: string;
  private isLoaded = false;
  
  constructor(config: Partial<NeuralConfig>, logger: ILogger, eventBus: IEventBus) {
    super();
    this.logger = logger;
    this.eventBus = eventBus;
    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    
    this.config = {
      modelUpdateInterval: 300000, // 5 minutes
      confidenceThreshold: 0.7,
      trainingBatchSize: 32,
      maxTrainingEpochs: 100,
      learningRate: 0.001,
      enableWasmAcceleration: true,
      patternCacheSize: 1000,
      autoRetraining: true,
      qualityThreshold: 0.8,
      ...config
    };
    
    this.initializeNeuralEngine();
  }

  /**
   * Initialize the neural engine with cross-session learning
   */
  private async initializeNeuralEngine(): Promise<void> {
    try {
      this.logger.info('Initializing Neural Pattern Engine with cross-session learning');
      
      // Set up TensorFlow.js backend with proper WASM initialization
      if (this.config.enableWasmAcceleration) {
        try {
          // Import and register WASM backend
          const wasmBackend = await import('@tensorflow/tfjs-backend-wasm');
          
          // Set the WASM path if the function is available
          const wasmPath = process.env.TFJS_WASM_PATH || 'node_modules/@tensorflow/tfjs-backend-wasm/dist/';
          if (wasmBackend && typeof wasmBackend.setWasmPaths === 'function') {
            wasmBackend.setWasmPaths(wasmPath);
          }
          
          await tf.setBackend('wasm');
          await tf.ready(); // Ensure backend is ready
          
          this.logger.info('WASM backend initialized for TensorFlow.js', { 
            backend: tf.getBackend(),
            wasmPath: wasmPath
          });
        } catch (error) {
          this.logger.warn('WASM backend not available, falling back to CPU', { error });
          await tf.setBackend('cpu');
          await tf.ready();
        }
      } else {
        await tf.setBackend('cpu');
        await tf.ready();
      }
      
      // Initialize persistence manager
      await this.initializePersistenceManager();
      
      // Load existing patterns from previous sessions
      await this.loadPersistedPatterns();
      
      // Create default patterns if none exist
      if (this.patterns.size === 0) {
        await this.initializeCorePatterns();
      }
      
      // Set up feature extractors
      this.setupFeatureExtractors();
      
      // Set up automatic pattern saving
      this.setupPatternPersistence();
      
      // Set up model retraining timer
      if (this.config.autoRetraining) {
        this.startTrainingLoops();
      }
      
      this.logger.info('Neural Pattern Engine initialization complete', {
        patternsLoaded: this.patterns.size,
        sessionId: this.sessionId
      });
      
      this.emit('engine:initialized', {
        patternsCount: this.patterns.size,
        sessionId: this.sessionId
      });
      
    } catch (error) {
      this.logger.error('Failed to initialize Neural Pattern Engine', { error });
      throw error;
    }
  }

  /**
   * Initialize persistence manager for cross-session learning
   */
  private async initializePersistenceManager(): Promise<void> {
    try {
      // Try to import and initialize the persistence manager
      const { getPersistenceManager } = await import('../cli/core/global-initialization.ts');
      this.persistenceManager = await getPersistenceManager();
      
      this.logger.debug('Persistence manager initialized for neural patterns');
    } catch (error) {
      this.logger.warn('Persistence manager not available, patterns will not persist across sessions', { error });
    }
  }

  /**
   * Load neural patterns from previous sessions
   */
  private async loadPersistedPatterns(): Promise<void> {
    if (!this.persistenceManager) {
      this.logger.warn('No persistence manager available, starting with empty patterns');
      return;
    }

    try {
      this.logger.info('Loading persisted neural patterns from previous sessions');
      
      // Load patterns from database
      const savedPatterns = await this.persistenceManager.query(`
        SELECT * FROM neural_patterns 
        WHERE created_at > datetime('now', '-30 days')
        ORDER BY success_rate DESC, confidence DESC
        LIMIT 100
      `);

      let loadedCount = 0;
      
      for (const patternData of savedPatterns) {
        try {
          // Deserialize pattern data
          const pattern = await this.deserializePattern(patternData);
          if (pattern) {
            this.patterns.set(pattern.id, pattern);
            
            // Initialize pattern metrics
            this.patternMetrics.set(pattern.id, {
              predictions: patternData.usage_count || 0,
              accuracy: patternData.success_rate || 0.5,
              avgConfidence: patternData.confidence || 0.5,
              lastUpdate: new Date(patternData.last_used_at || patternData.created_at)
            });
            
            loadedCount++;
          }
                 } catch (error) {
           this.logger.warn('Failed to load pattern', { 
             patternId: patternData.id, 
             error: error instanceof Error ? error.message : String(error)
           });
         }
      }

      // Load training data from previous sessions
      await this.loadPersistedTrainingData();

      this.isLoaded = true;
      this.logger.info('Cross-session pattern loading complete', { 
        patternsLoaded: loadedCount,
        totalPatterns: this.patterns.size
      });

      this.emit('patterns:loaded', {
        loadedCount,
        totalPatterns: this.patterns.size
      });

    } catch (error) {
      this.logger.error('Failed to load persisted patterns', { error });
      this.isLoaded = true; // Continue without persisted data
    }
  }

  /**
   * Load training data from previous sessions
   */
  private async loadPersistedTrainingData(): Promise<void> {
    if (!this.persistenceManager) return;

    try {
      const trainingRecords = await this.persistenceManager.query(`
        SELECT pattern_type, input_context, action_taken, outcome, success_score, timestamp
        FROM training_data 
        WHERE timestamp > datetime('now', '-7 days')
        ORDER BY timestamp DESC
        LIMIT 1000
      `);

      for (const record of trainingRecords) {
        const patternType = record.pattern_type;
        if (!this.trainingData.has(patternType)) {
          this.trainingData.set(patternType, []);
        }

        this.trainingData.get(patternType)!.push({
          context: JSON.parse(record.input_context || '{}'),
          action: record.action_taken,
          outcome: record.outcome,
          success: record.success_score > 0.7,
          timestamp: new Date(record.timestamp)
        });
      }

      this.logger.info('Loaded training data from previous sessions', {
        records: trainingRecords.length,
        patternTypes: this.trainingData.size
      });

    } catch (error) {
      this.logger.warn('Failed to load persisted training data', { error });
    }
  }

  /**
   * Deserialize a pattern from database format
   */
  private async deserializePattern(patternData: any): Promise<NeuralPattern | null> {
    try {
      const metadata = JSON.parse(patternData.metadata || '{}');
      const trainingData = JSON.parse(patternData.training_data || '{}');

      // Recreate the TensorFlow model
      const model = await this.recreateModel(metadata.architecture, patternData.pattern_type);
      
      const pattern: NeuralPattern = {
        id: patternData.id,
        name: patternData.pattern_type,
        type: patternData.pattern_type as NeuralPattern['type'],
        description: metadata.description || `${patternData.pattern_type} pattern`,
        confidence: patternData.confidence,
        accuracy: patternData.success_rate,
        trainingData: patternData.usage_count,
        features: metadata.features || [],
        model,
        createdAt: new Date(patternData.created_at),
        lastTrained: new Date(patternData.last_used_at || patternData.created_at),
        usageCount: patternData.usage_count,
        successRate: patternData.success_rate,
        metadata: metadata
      };

      // Cache the model
      this.modelCache.set(pattern.id, model);

      return pattern;
         } catch (error) {
       this.logger.error('Failed to deserialize pattern', { 
         patternId: patternData.id, 
         error: error instanceof Error ? error.message : String(error)
       });
       return null;
     }
  }

  /**
   * Recreate a TensorFlow model from saved architecture
   */
  private async recreateModel(architecture: any, patternType: string): Promise<tf.LayersModel> {
    if (!architecture) {
      // Create default architecture based on pattern type
      architecture = this.getDefaultArchitecture(patternType);
    }

    const model = tf.sequential();
    
    // Add layers based on saved architecture
    for (let i = 0; i < architecture.layers.length; i++) {
      const layer = architecture.layers[i];
      
      if (i === 0) {
        // Input layer
        model.add(tf.layers.dense({
          inputShape: [layer.inputSize || 10],
          units: layer.units,
          activation: layer.activation || 'relu'
        }));
      } else {
        switch (layer.type) {
          case 'dense':
            model.add(tf.layers.dense({
              units: layer.units,
              activation: layer.activation || 'relu'
            }));
            break;
          case 'dropout':
            model.add(tf.layers.dropout({ rate: layer.rate || 0.2 }));
            break;
          case 'batchNormalization':
            model.add(tf.layers.batchNormalization());
            break;
        }
      }
    }

    // Compile model
    model.compile({
      optimizer: tf.train.adam(this.config.learningRate),
      loss: patternType === 'behavior_analysis' ? 'binaryCrossentropy' : 'meanSquaredError',
      metrics: ['accuracy']
    });

    return model;
  }

  /**
   * Get default architecture for a pattern type
   */
  private getDefaultArchitecture(patternType: string): any {
    const baseArchitecture = {
      layers: [
        { inputSize: 10, units: 32, activation: 'relu' },
        { type: 'dropout', rate: 0.2 },
        { type: 'dense', units: 16, activation: 'relu' },
        { type: 'dense', units: 1, activation: 'sigmoid' }
      ]
    };

    switch (patternType) {
      case 'coordination':
        return {
          layers: [
            { inputSize: 15, units: 64, activation: 'relu' },
            { type: 'dropout', rate: 0.3 },
            { type: 'dense', units: 32, activation: 'relu' },
            { type: 'dense', units: 8, activation: 'softmax' } // Multiple coordination modes
          ]
        };
      case 'task_prediction':
        return {
          layers: [
            { inputSize: 12, units: 48, activation: 'relu' },
            { type: 'dropout', rate: 0.2 },
            { type: 'dense', units: 24, activation: 'relu' },
            { type: 'dense', units: 3, activation: 'softmax' } // Success, partial, failure
          ]
        };
      case 'behavior_analysis':
        return baseArchitecture;
      default:
        return baseArchitecture;
    }
  }

  /**
   * Set up automatic pattern persistence
   */
  private setupPatternPersistence(): void {
    // Save patterns every 10 minutes
    setInterval(async () => {
      await this.saveAllPatterns();
    }, 10 * 60 * 1000);

    // Save on process exit
    process.on('beforeExit', async () => {
      await this.saveAllPatterns();
    });

    process.on('SIGINT', async () => {
      await this.saveAllPatterns();
      process.exit(0);
    });

    process.on('SIGTERM', async () => {
      await this.saveAllPatterns();
      process.exit(0);
    });
  }

  /**
   * Save all patterns to persistent storage
   */
  private async saveAllPatterns(): Promise<void> {
    if (!this.persistenceManager || this.patterns.size === 0) return;

    try {
      this.logger.info('Saving neural patterns for cross-session persistence');
      
      let savedCount = 0;
      
      for (const [patternId, pattern] of this.patterns) {
        try {
          await this.savePattern(pattern);
          savedCount++;
                 } catch (error) {
           this.logger.warn('Failed to save pattern', { patternId, error: error instanceof Error ? error.message : String(error) });
         }
      }

      // Save training data
      await this.saveTrainingData();

      // Save session summary
      await this.saveSessionSummary();

      this.logger.info('Pattern saving complete', { 
        savedCount, 
        totalPatterns: this.patterns.size,
        sessionId: this.sessionId
      });

      this.emit('patterns:saved', {
        savedCount,
        totalPatterns: this.patterns.size
      });

    } catch (error) {
      this.logger.error('Failed to save patterns', { error });
    }
  }

  /**
   * Save a single pattern to persistent storage
   */
  private async savePattern(pattern: NeuralPattern): Promise<void> {
    if (!this.persistenceManager) return;

    const metrics = this.patternMetrics.get(pattern.id);
    
    const patternData = {
      id: pattern.id,
      pattern_type: pattern.type,
      pattern_data: JSON.stringify({
        architecture: pattern.metadata.architecture,
        features: pattern.features,
        description: pattern.description
      }),
      confidence: pattern.confidence,
      usage_count: pattern.usageCount,
      success_rate: pattern.successRate,
      created_at: pattern.createdAt.toISOString(),
      last_used_at: pattern.lastTrained.toISOString(),
      metadata: JSON.stringify({
        ...pattern.metadata,
        lastSession: this.sessionId,
        modelVersion: pattern.metadata.modelVersion || '1.0'
      }),
      training_data: JSON.stringify({
        sampleCount: pattern.trainingData,
        lastTraining: pattern.lastTrained.toISOString(),
        accuracy: metrics?.accuracy || pattern.accuracy
      }),
      model_version: pattern.metadata.modelVersion || '1.0',
      validation_score: metrics?.accuracy || pattern.accuracy
    };

    await this.persistenceManager.store('neural_patterns', pattern.id, patternData);
  }

  /**
   * Save training data for cross-session learning
   */
  private async saveTrainingData(): Promise<void> {
    if (!this.persistenceManager) return;

    try {
      for (const [patternType, data] of this.trainingData) {
        // Save recent training data (last 100 entries)
        const recentData = data.slice(-100);
        
        for (const entry of recentData) {
          await this.persistenceManager.store('training_data', `${patternType}_${Date.now()}`, {
            pattern_type: patternType,
            input_context: JSON.stringify(entry.context),
            action_taken: entry.action,
            outcome: entry.outcome,
            success_score: entry.success ? 1.0 : 0.0,
            timestamp: entry.timestamp.toISOString(),
            model_version: '1.0',
            feedback: '',
            session_id: this.sessionId
          });
        }
      }

      this.logger.debug('Training data saved for cross-session learning');
    } catch (error) {
      this.logger.warn('Failed to save training data', { error });
    }
  }

  /**
   * Save session summary for analysis
   */
  private async saveSessionSummary(): Promise<void> {
    if (!this.persistenceManager) return;

    try {
      const summary = {
        session_id: this.sessionId,
        started_at: new Date().toISOString(),
        patterns_used: this.patterns.size,
        predictions_made: Array.from(this.patternMetrics.values())
          .reduce((sum, metrics) => sum + metrics.predictions, 0),
        avg_confidence: Array.from(this.patternMetrics.values())
          .reduce((sum, metrics) => sum + metrics.avgConfidence, 0) / this.patternMetrics.size || 0,
        patterns_created: Array.from(this.patterns.values())
          .filter(p => p.createdAt.getTime() > Date.now() - 24 * 60 * 60 * 1000).length,
        session_type: 'neural_learning',
        outcome: 'completed'
      };

      await this.persistenceManager.store('session_history', this.sessionId, summary);
      
      this.logger.debug('Session summary saved', { sessionId: this.sessionId });
    } catch (error) {
      this.logger.warn('Failed to save session summary', { error });
    }
  }

  /**
   * Learn from cross-session patterns
   */
  public async adaptFromPreviousSessions(): Promise<void> {
    if (!this.persistenceManager || !this.isLoaded) return;

    try {
      this.logger.info('Adapting from previous session patterns');

      // Analyze session history for learning trends
      const recentSessions = await this.persistenceManager.query(`
        SELECT * FROM session_history 
        WHERE started_at > datetime('now', '-7 days')
        AND outcome = 'completed'
        ORDER BY started_at DESC
        LIMIT 50
      `);

      // Identify successful patterns
      const successfulPatterns = await this.persistenceManager.query(`
        SELECT * FROM neural_patterns 
        WHERE success_rate > 0.7 
        AND usage_count > 5
        ORDER BY success_rate DESC, confidence DESC
        LIMIT 20
      `);

      // Adapt thresholds based on historical performance
      if (successfulPatterns.length > 0) {
        const avgSuccessRate = successfulPatterns.reduce((sum: number, p: any) => 
          sum + p.success_rate, 0) / successfulPatterns.length;
        
        if (avgSuccessRate > this.config.confidenceThreshold) {
          this.config.confidenceThreshold = Math.min(0.9, avgSuccessRate * 0.9);
          this.logger.info('Adapted confidence threshold based on historical performance', {
            newThreshold: this.config.confidenceThreshold,
            basedOnPatterns: successfulPatterns.length
          });
        }
      }

      // Re-prioritize patterns based on success rates
      this.prioritizePatternsByHistoricalSuccess();

      this.emit('cross_session:adapted', {
        sessionsAnalyzed: recentSessions.length,
        successfulPatterns: successfulPatterns.length,
        newThreshold: this.config.confidenceThreshold
      });

    } catch (error) {
      this.logger.error('Failed to adapt from previous sessions', { error });
    }
  }

  /**
   * Prioritize patterns based on historical success
   */
  private prioritizePatternsByHistoricalSuccess(): void {
    const patterns = Array.from(this.patterns.values());
    
    // Sort by success rate and confidence
    patterns.sort((a, b) => {
      const aScore = (a.successRate * 0.7) + (a.confidence * 0.3);
      const bScore = (b.successRate * 0.7) + (b.confidence * 0.3);
      return bScore - aScore;
    });

    // Update pattern priorities
    patterns.forEach((pattern, index) => {
      pattern.metadata.priority = patterns.length - index;
    });

    this.logger.debug('Patterns reprioritized based on historical success');
  }

  /**
   * Get patterns learned from previous sessions
   */
  public async getCrossSessionInsights(): Promise<{
    totalSessions: number;
    averageSessionDuration: number;
    mostSuccessfulPatterns: string[];
    improvementAreas: string[];
    confidenceEvolution: number[];
  }> {
    if (!this.persistenceManager) {
      return {
        totalSessions: 0,
        averageSessionDuration: 0,
        mostSuccessfulPatterns: [],
        improvementAreas: [],
        confidenceEvolution: []
      };
    }

    try {
      const sessions = await this.persistenceManager.query(`
        SELECT * FROM session_history 
        WHERE started_at > datetime('now', '-30 days')
        ORDER BY started_at ASC
      `);

      const patterns = await this.persistenceManager.query(`
        SELECT pattern_type, AVG(success_rate) as avg_success, COUNT(*) as usage
        FROM neural_patterns 
        WHERE created_at > datetime('now', '-30 days')
        GROUP BY pattern_type
        ORDER BY avg_success DESC
      `);

      const mostSuccessful = patterns
        .filter((p: any) => p.avg_success > 0.8)
        .map((p: any) => p.pattern_type);

      const needsImprovement = patterns
        .filter((p: any) => p.avg_success < 0.6)
        .map((p: any) => p.pattern_type);

      return {
        totalSessions: sessions.length,
        averageSessionDuration: sessions.length > 0 ? 
          sessions.reduce((sum: number, s: any) => sum + (s.patterns_used || 0), 0) / sessions.length : 0,
        mostSuccessfulPatterns: mostSuccessful,
        improvementAreas: needsImprovement,
        confidenceEvolution: sessions.map((s: any) => s.avg_confidence || 0.5)
      };

    } catch (error) {
      this.logger.error('Failed to get cross-session insights', { error });
      return {
        totalSessions: 0,
        averageSessionDuration: 0,
        mostSuccessfulPatterns: [],
        improvementAreas: [],
        confidenceEvolution: []
      };
    }
  }
  
  private async initializeCorePatterns(): Promise<void> {
    // Coordination Optimizer Pattern
    await this.createPattern({
      name: 'coordination_optimizer',
      type: 'coordination',
      description: 'Optimizes agent coordination patterns based on task complexity and team dynamics',
      features: ['task_complexity', 'agent_count', 'communication_overhead', 'success_rate'],
      modelArchitecture: {
        layers: [
          { type: 'dense', units: 64, activation: 'relu' },
          { type: 'dropout', rate: 0.2 },
          { type: 'dense', units: 32, activation: 'relu' },
          { type: 'dropout', rate: 0.1 },
          { type: 'dense', units: 16, activation: 'relu' },
          { type: 'dense', units: 5, activation: 'softmax' } // 5 coordination modes
        ]
      }
    });
    
    // Task Predictor Pattern
    await this.createPattern({
      name: 'task_predictor',
      type: 'task_prediction',
      description: 'Predicts task completion time, resource requirements, and success probability',
      features: ['task_type', 'agent_capabilities', 'historical_performance', 'resource_availability'],
      modelArchitecture: {
        layers: [
          { type: 'dense', units: 128, activation: 'relu' },
          { type: 'batchNormalization' },
          { type: 'dropout', rate: 0.3 },
          { type: 'dense', units: 64, activation: 'relu' },
          { type: 'dropout', rate: 0.2 },
          { type: 'dense', units: 32, activation: 'relu' },
          { type: 'dense', units: 3, activation: 'linear' } // time, resources, success_prob
        ]
      }
    });
    
    // Behavior Analyzer Pattern
    await this.createPattern({
      name: 'behavior_analyzer',
      type: 'behavior_analysis',
      description: 'Analyzes agent behavior patterns for optimization and anomaly detection',
      features: ['response_time', 'error_rate', 'communication_frequency', 'task_quality'],
      modelArchitecture: {
        layers: [
          { type: 'dense', units: 96, activation: 'relu' },
          { type: 'dropout', rate: 0.25 },
          { type: 'dense', units: 48, activation: 'relu' },
          { type: 'dropout', rate: 0.15 },
          { type: 'dense', units: 24, activation: 'relu' },
          { type: 'dense', units: 1, activation: 'sigmoid' } // anomaly score
        ]
      }
    });
    
    // Optimization Engine Pattern
    await this.createPattern({
      name: 'optimization_engine',
      type: 'optimization',
      description: 'Optimizes system parameters for maximum performance and efficiency',
      features: ['throughput', 'latency', 'resource_usage', 'error_rate', 'user_satisfaction'],
      modelArchitecture: {
        layers: [
          { type: 'dense', units: 256, activation: 'relu' },
          { type: 'batchNormalization' },
          { type: 'dropout', rate: 0.4 },
          { type: 'dense', units: 128, activation: 'relu' },
          { type: 'dropout', rate: 0.3 },
          { type: 'dense', units: 64, activation: 'relu' },
          { type: 'dropout', rate: 0.2 },
          { type: 'dense', units: 32, activation: 'relu' },
          { type: 'dense', units: 10, activation: 'tanh' } // optimization parameters
        ]
      }
    });
  }
  
  private async createPattern(config: {
    name: string;
    type: NeuralPattern['type'];
    description: string;
    features: string[];
    modelArchitecture: any;
  }): Promise<string> {
    const patternId = generateId('pattern');
    
    // Build TensorFlow model
    const model = tf.sequential();
    
    // Add input layer
    model.add(tf.layers.dense({
      inputShape: [config.features.length],
      units: config.modelArchitecture.layers[0].units,
      activation: config.modelArchitecture.layers[0].activation
    }));
    
    // Add hidden layers
    for (let i = 1; i < config.modelArchitecture.layers.length; i++) {
      const layer = config.modelArchitecture.layers[i];
      
      switch (layer.type) {
        case 'dense':
          model.add(tf.layers.dense({
            units: layer.units,
            activation: layer.activation
          }));
          break;
        case 'dropout':
          model.add(tf.layers.dropout({ rate: layer.rate }));
          break;
        case 'batchNormalization':
          model.add(tf.layers.batchNormalization());
          break;
      }
    }
    
    // Compile model
    model.compile({
      optimizer: tf.train.adam(this.config.learningRate),
      loss: config.type === 'behavior_analysis' ? 'binaryCrossentropy' : 'meanSquaredError',
      metrics: ['accuracy']
    });
    
    const pattern: NeuralPattern = {
      id: patternId,
      name: config.name,
      type: config.type,
      description: config.description,
      confidence: 0.5,
      accuracy: 0.0,
      trainingData: 0,
      features: config.features,
      model,
      createdAt: new Date(),
      lastTrained: new Date(),
      usageCount: 0,
      successRate: 0.0,
      metadata: { architecture: config.modelArchitecture }
    };
    
    this.patterns.set(patternId, pattern);
    this.modelCache.set(patternId, model);
    this.trainingQueues.set(patternId, []);
    
    this.logger.info('Neural pattern created', {
      patternId,
      name: config.name,
      type: config.type,
      features: config.features.length
    });
    
    return patternId;
  }
  
  private setupFeatureExtractors(): void {
    // Coordination feature extractor
    this.featureExtractors.set('coordination_optimizer', (data: LearningContext) => {
      return [
        this.normalizeTaskComplexity(data.taskType),
        data.agentCapabilities.length / 20, // normalized agent count
        data.communicationPatterns.length / 100, // normalized communication overhead
        data.historicalPerformance.reduce((a, b) => a + b, 0) / data.historicalPerformance.length || 0
      ];
    });
    
    // Task prediction feature extractor
    this.featureExtractors.set('task_predictor', (data: LearningContext) => {
      return [
        this.encodeTaskType(data.taskType),
        data.agentCapabilities.length / 10,
        data.historicalPerformance.reduce((a, b) => a + b, 0) / data.historicalPerformance.length || 0,
        Object.values(data.resourceUsage).reduce((a, b) => a + b, 0) / 100
      ];
    });
    
    // Behavior analysis feature extractor
    this.featureExtractors.set('behavior_analyzer', (data: LearningContext) => {
      return [
        data.resourceUsage.responseTime || 0,
        data.resourceUsage.errorRate || 0,
        data.communicationPatterns.length / 50,
        data.historicalPerformance.reduce((a, b) => a + b, 0) / data.historicalPerformance.length || 0
      ];
    });
    
    // Optimization feature extractor
    this.featureExtractors.set('optimization_engine', (data: LearningContext) => {
      return [
        data.resourceUsage.throughput || 0,
        data.resourceUsage.latency || 0,
        data.resourceUsage.cpu || 0,
        data.resourceUsage.memory || 0,
        data.resourceUsage.errorRate || 0
      ];
    });
  }
  
  private startTrainingLoops(): void {
    // Skip intervals in test environment to prevent hanging
    if (process.env.NODE_ENV === 'test') {
      this.logger.debug('Skipping training loops in test environment');
      return;
    }
    
    // Auto-retraining loop
    if (this.config.autoRetraining) {
      setInterval(() => {
        this.performAutoRetraining();
      }, this.config.modelUpdateInterval);
    }
    
    // Pattern optimization loop
    setInterval(() => {
      this.optimizePatterns();
    }, this.config.modelUpdateInterval * 2);
  }
  
  private setupEventHandlers(): void {
    // Listen for task completions to collect training data
    this.eventBus.on('task:completed', (data: { task: TaskDefinition; result: TaskResult; agent: AgentState }) => {
      this.collectTrainingData(data.task, data.result, data.agent);
    });
    
    // Listen for agent behavior changes
    this.eventBus.on('agent:behavior_change', (data: { agent: AgentState; metrics: any }) => {
      this.analyzeAgentBehavior(data.agent, data.metrics);
    });
    
    // Listen for coordination events
    this.eventBus.on('coordination:pattern_detected', (data: { pattern: string; context: any }) => {
      this.learnCoordinationPattern(data.pattern, data.context);
    });
  }
  
  /**
   * Predict optimal coordination mode for given context
   */
  async predictCoordinationMode(context: LearningContext): Promise<PatternPrediction> {
    // Find coordination pattern by type instead of hardcoded name
    const pattern = Array.from(this.patterns.values()).find(p => p.type === 'coordination');
    if (!pattern) {
      throw new Error('Coordination pattern not found');
    }
    
    const features = this.featureExtractors.get('coordination_optimizer')!(context);
    const input = tf.tensor2d([features]);
    
    const prediction = pattern.model.predict(input) as tf.Tensor;
    const result = await prediction.data();
    
    // Clean up tensors
    input.dispose();
    prediction.dispose();
    
    const coordinationModes = ['centralized', 'distributed', 'hierarchical', 'mesh', 'hybrid'];
    const maxIndex = result.indexOf(Math.max(...Array.from(result)));
    const confidence = result[maxIndex];
    
    const patternPrediction: PatternPrediction = {
      patternId: pattern.id,
      prediction: Array.from(result),
      confidence,
      features: Object.fromEntries(pattern.features.map((f, i) => [f, features[i]])),
      reasoning: `Predicted ${coordinationModes[maxIndex]} mode with ${(confidence * 100).toFixed(1)}% confidence`,
      timestamp: new Date()
    };
    
    // Update pattern usage
    pattern.usageCount++;
    this.updatePatternMetrics(pattern.id, confidence);
    
    this.emit('pattern:prediction', patternPrediction);
    
    return patternPrediction;
  }
  
  /**
   * Predict task completion metrics
   */
  async predictTaskMetrics(context: LearningContext): Promise<PatternPrediction> {
    // Find task prediction pattern by type instead of hardcoded name
    const pattern = Array.from(this.patterns.values()).find(p => p.type === 'task_prediction');
    if (!pattern) {
      throw new Error('Task prediction pattern not found');
    }
    
    const features = this.featureExtractors.get('task_predictor')!(context);
    const input = tf.tensor2d([features]);
    
    const prediction = pattern.model.predict(input) as tf.Tensor;
    const result = await prediction.data();
    
    input.dispose();
    prediction.dispose();
    
    const patternPrediction: PatternPrediction = {
      patternId: pattern.id,
      prediction: Array.from(result),
      confidence: Math.min(...Array.from(result).map(v => Math.abs(v))), // Confidence based on prediction certainty
      features: Object.fromEntries(pattern.features.map((f, i) => [f, features[i]])),
      reasoning: `Predicted completion time: ${result[0].toFixed(2)}s, resources: ${result[1].toFixed(2)}, success: ${(result[2] * 100).toFixed(1)}%`,
      timestamp: new Date()
    };
    
    pattern.usageCount++;
    this.updatePatternMetrics(pattern.id, patternPrediction.confidence);
    
    return patternPrediction;
  }
  
  /**
   * Analyze agent behavior for anomalies
   */
  async analyzeAgentBehavior(agent: AgentState, metrics: any): Promise<PatternPrediction> {
    // Find behavior analysis pattern by type instead of hardcoded name
    const pattern = Array.from(this.patterns.values()).find(p => p.type === 'behavior_analysis');
    if (!pattern) {
      throw new Error('Behavior analysis pattern not found');
    }
    
    const context: LearningContext = {
      taskType: agent.type,
      agentCapabilities: Object.keys(agent.capabilities),
      environment: agent.environment,
      historicalPerformance: [agent.metrics.successRate],
      resourceUsage: {
        responseTime: agent.metrics.responseTime,
        errorRate: agent.metrics.tasksFailed / (agent.metrics.tasksCompleted + agent.metrics.tasksFailed) || 0,
        cpu: agent.metrics.cpuUsage,
        memory: agent.metrics.memoryUsage
      },
      communicationPatterns: [],
      outcomes: []
    };
    
    const features = this.featureExtractors.get('behavior_analyzer')!(context);
    const input = tf.tensor2d([features]);
    
    const prediction = pattern.model.predict(input) as tf.Tensor;
    const result = await prediction.data();
    
    input.dispose();
    prediction.dispose();
    
    const anomalyScore = result[0];
    const isAnomaly = anomalyScore > 0.5;
    
    const patternPrediction: PatternPrediction = {
      patternId: pattern.id,
      prediction: Array.from(result),
      confidence: Math.abs(anomalyScore - 0.5) * 2, // Distance from threshold
      features: Object.fromEntries(pattern.features.map((f, i) => [f, features[i]])),
      reasoning: isAnomaly ? 
        `Anomaly detected with score ${(anomalyScore * 100).toFixed(1)}%` :
        `Normal behavior with score ${(anomalyScore * 100).toFixed(1)}%`,
      timestamp: new Date()
    };
    
    if (isAnomaly) {
      this.emit('pattern:anomaly', { agent, prediction: patternPrediction });
    }
    
    return patternPrediction;
  }
  
  /**
   * Train pattern with new data
   */
  async trainPattern(patternId: string, trainingData: any[], labels: any[]): Promise<void> {
    const pattern = this.patterns.get(patternId);
    if (!pattern) {
      throw new Error(`Pattern not found: ${patternId}`);
    }
    
    if (trainingData.length < this.config.trainingBatchSize) {
      // Queue data for batch training
      const queue = this.trainingQueues.get(patternId) || [];
      queue.push(...trainingData.map((data, i) => ({ data, label: labels[i] })));
      this.trainingQueues.set(patternId, queue);
      return;
    }
    
    try {
      // Prepare training tensors
      const xs = tf.tensor2d(trainingData);
      const ys = tf.tensor2d(labels);
      
      // Train the model
      const history = await pattern.model.fit(xs, ys, {
        epochs: Math.min(this.config.maxTrainingEpochs, 20),
        batchSize: this.config.trainingBatchSize,
        validationSplit: 0.2,
        verbose: 0
      });
      
      // Update pattern metrics
      const finalLoss = history.history.loss[history.history.loss.length - 1] as number;
      const finalAccuracy = history.history.accuracy ? history.history.accuracy[history.history.accuracy.length - 1] as number : 0;
      
      pattern.accuracy = finalAccuracy;
      pattern.confidence = Math.max(0.1, 1 - finalLoss);
      pattern.trainingData += trainingData.length;
      pattern.lastTrained = new Date();
      
      // Clean up tensors
      xs.dispose();
      ys.dispose();
      
      this.logger.info('Pattern trained successfully', {
        patternId,
        accuracy: finalAccuracy,
        loss: finalLoss,
        samples: trainingData.length
      });
      
      this.emit('pattern:trained', { patternId, accuracy: finalAccuracy, loss: finalLoss });
      
    } catch (error) {
      this.logger.error('Pattern training failed', { patternId, error });
      throw error;
    }
  }
  
  private async collectTrainingData(task: TaskDefinition, result: TaskResult, agent: AgentState): Promise<void> {
    const context: LearningContext = {
      taskType: task.type,
      agentCapabilities: Object.keys(agent.capabilities),
      environment: agent.environment,
      historicalPerformance: [agent.metrics.successRate],
      resourceUsage: {
        cpu: agent.metrics.cpuUsage,
        memory: agent.metrics.memoryUsage,
        responseTime: agent.metrics.responseTime,
        errorRate: agent.metrics.tasksFailed / (agent.metrics.tasksCompleted + agent.metrics.tasksFailed) || 0
      },
      communicationPatterns: [],
      outcomes: [result.output ? 'success' : 'failure']
    };
    
    // Collect data for different patterns
    for (const [patternId, pattern] of this.patterns) {
      const extractor = this.featureExtractors.get(pattern.name);
      if (extractor) {
        const features = extractor(context);
        const label = this.createLabel(pattern.type, result, context);
        
        // Add to training queue
        const queue = this.trainingQueues.get(patternId) || [];
        queue.push({ data: features, label });
        this.trainingQueues.set(patternId, queue);
        
        // Trigger training if queue is full
        if (queue.length >= this.config.trainingBatchSize) {
          const trainingData = queue.map(item => item.data);
          const labels = queue.map(item => item.label);
          
          await this.trainPattern(patternId, trainingData, labels);
          this.trainingQueues.set(patternId, []);
        }
      }
    }
  }
  
  private createLabel(patternType: string, result: TaskResult, context: LearningContext): number[] {
    switch (patternType) {
      case 'coordination':
        // One-hot encode coordination mode (simplified)
        return [1, 0, 0, 0, 0]; // centralized as default
      case 'task_prediction':
        return [
          result.executionTime || 0,
          result.resourcesUsed?.maxMemory || 0,
          result.accuracy || 0
        ];
      case 'behavior_analysis':
        return [result.accuracy && result.accuracy > 0.8 ? 0 : 1]; // 0 = normal, 1 = anomaly
      case 'optimization':
        return Array(10).fill(0).map(() => Math.random() * 2 - 1); // Random optimization parameters
      default:
        return [0];
    }
  }
  
  private async performAutoRetraining(): Promise<void> {
    for (const [patternId, pattern] of this.patterns) {
      const queue = this.trainingQueues.get(patternId) || [];
      
      if (queue.length >= this.config.trainingBatchSize) {
        const trainingData = queue.map(item => item.data);
        const labels = queue.map(item => item.label);
        
        try {
          await this.trainPattern(patternId, trainingData, labels);
          this.trainingQueues.set(patternId, []);
        } catch (error) {
          this.logger.error('Auto-retraining failed', { patternId, error });
        }
      }
    }
  }
  
  private async optimizePatterns(): Promise<void> {
    for (const [patternId, pattern] of this.patterns) {
      const metrics = this.patternMetrics.get(patternId);
      
      if (metrics && metrics.accuracy < this.config.qualityThreshold) {
        // Pattern needs optimization
        await this.optimizePattern(patternId);
      }
    }
  }
  
  private async optimizePattern(patternId: string): Promise<void> {
    const pattern = this.patterns.get(patternId);
    if (!pattern) return;
    
    // Implement pattern optimization techniques
    // This could include hyperparameter tuning, architecture changes, etc.
    this.logger.info('Optimizing pattern', { patternId, currentAccuracy: pattern.accuracy });
    
    // For now, just log the optimization attempt
    this.emit('pattern:optimized', { patternId, previousAccuracy: pattern.accuracy });
  }
  
  private updatePatternMetrics(patternId: string, confidence: number): void {
    const existing = this.patternMetrics.get(patternId) || {
      predictions: 0,
      accuracy: 0,
      avgConfidence: 0,
      lastUpdate: new Date()
    };
    
    existing.predictions++;
    existing.avgConfidence = (existing.avgConfidence * (existing.predictions - 1) + confidence) / existing.predictions;
    existing.lastUpdate = new Date();
    
    this.patternMetrics.set(patternId, existing);
  }
  
  private normalizeTaskComplexity(taskType: string): number {
    const complexityMap: Record<string, number> = {
      'simple': 0.1,
      'medium': 0.5,
      'complex': 0.8,
      'advanced': 1.0
    };
    return complexityMap[taskType] || 0.5;
  }
  
  private encodeTaskType(taskType: string): number {
    const typeMap: Record<string, number> = {
      'coding': 0.1,
      'research': 0.2,
      'analysis': 0.3,
      'documentation': 0.4,
      'testing': 0.5,
      'review': 0.6,
      'optimization': 0.7,
      'deployment': 0.8,
      'monitoring': 0.9,
      'maintenance': 1.0
    };
    return typeMap[taskType] || 0.5;
  }
  
  /**
   * Get pattern by ID
   */
  getPattern(patternId: string): NeuralPattern | undefined {
    return this.patterns.get(patternId);
  }
  
  /**
   * Get all patterns
   */
  getAllPatterns(): NeuralPattern[] {
    return Array.from(this.patterns.values());
  }
  
  /**
   * Get pattern metrics
   */
  getPatternMetrics(patternId: string): any {
    return this.patternMetrics.get(patternId);
  }
  
  private learnCoordinationPattern(pattern: string, context: any): void {
    this.logger.debug('Learning coordination pattern', { pattern, context });
    
    // Store pattern for future learning
    const existingPatterns = this.emergentPatterns.get('coordination') || [];
    existingPatterns.push({ pattern, context, timestamp: new Date() });
    this.emergentPatterns.set('coordination', existingPatterns);
    
    // Emit pattern learned event
    this.emit('pattern:learned', { type: 'coordination', pattern, context });
  }
  
  /**
   * Export pattern model
   */
  async exportPattern(patternId: string): Promise<string> {
    const pattern = this.patterns.get(patternId);
    if (!pattern) {
      throw new Error(`Pattern not found: ${patternId}`);
    }
    
    // For now, return pattern metadata as JSON
    // Full model serialization would require more complex TensorFlow.js setup
    const exportData = {
      id: pattern.id,
      name: pattern.name,
      type: pattern.type,
      description: pattern.description,
      confidence: pattern.confidence,
      accuracy: pattern.accuracy,
      trainingData: pattern.trainingData,
      features: pattern.features,
      createdAt: pattern.createdAt,
      lastTrained: pattern.lastTrained,
      usageCount: pattern.usageCount,
      successRate: pattern.successRate,
      metadata: pattern.metadata
    };
    
    return JSON.stringify(exportData);
  }
  
  /**
   * Import pattern model
   */
  async importPattern(patternId: string, modelData: string): Promise<void> {
    const pattern = this.patterns.get(patternId);
    if (!pattern) {
      throw new Error(`Pattern not found: ${patternId}`);
    }
    
    const parsedData = JSON.parse(modelData);
    
    // Update pattern metadata
    pattern.confidence = parsedData.confidence || pattern.confidence;
    pattern.accuracy = parsedData.accuracy || pattern.accuracy;
    pattern.trainingData = parsedData.trainingData || pattern.trainingData;
    pattern.usageCount = parsedData.usageCount || pattern.usageCount;
    pattern.successRate = parsedData.successRate || pattern.successRate;
    pattern.metadata = { ...pattern.metadata, ...parsedData.metadata };
    
    this.logger.info('Pattern imported successfully', { patternId });
  }
  
  /**
   * Shutdown neural engine
   */
  async shutdown(): Promise<void> {
    // Dispose all models
    for (const model of this.modelCache.values()) {
      model.dispose();
    }
    
    // Clear caches
    this.patterns.clear();
    this.modelCache.clear();
    this.trainingQueues.clear();
    this.predictionCache.clear();
    this.patternMetrics.clear();
    
    this.logger.info('Neural Pattern Engine shutdown complete');
  }
}