/**
 * Analyst Agent - Specialized in data analysis and performance optimization
 */

import { BaseAgent } from './base-agent.js';
import type { AgentCapabilities, AgentConfig, AgentEnvironment, TaskDefinition } from '../../swarm/types.js';
import type { ILogger } from '../../core/logger.js';
import type { IEventBus } from '../../core/event-bus.js';
import type { DistributedMemorySystem } from '../../memory/distributed-memory.js';

// Type definitions for analysis
interface AnalysisVisualization {
  type: string;
  title: string;
  description: string;
  dataPoints: number;
  interactive: boolean;
}

interface AnalysisBottleneck {
  component: string;
  impact: string;
  description: string;
  recommendation: string;
}

interface AnalysisAnomaly {
  id: string;
  timestamp: Date;
  severity: string;
  score: number;
  description: string;
  features: string[];
}

interface AnalysisTrend {
  metric: string;
  direction: string;
  slope: number;
  significance: number;
  period: string;
}

interface QualityIssue {
  category: string;
  severity: string;
  description: string;
  impact: string;
}

interface DataAnalysis {
  dataset: {
    name: string;
    size: number;
    columns: string[];
    types: Record<string, string>;
  };
  analysisType: string;
  summary: {
    rowCount: number;
    columnCount: number;
    missingValues: number;
    duplicateRows: number;
    outliers: number;
  };
  descriptiveStats: Record<string, any>;
  correlations: Record<string, any>;
  distributions: Record<string, any>;
  insights: string[];
  recommendations: string[];
  visualizations: AnalysisVisualization[];
  confidence: number;
  methodology: string;
  timestamp: Date;
}

interface PerformanceAnalysis {
  system?: string;
  timeframe?: string;
  metrics: Record<string, any>;
  benchmarks?: Record<string, any>;
  bottlenecks: AnalysisBottleneck[];
  anomalies: AnalysisAnomaly[];
  trends: AnalysisTrend[];
  insights: string[];
  recommendations: string[];
  visualizations: AnalysisVisualization[];
  optimizationPotential: number;
  projectedImprovement: number;
  confidence: number;
  timestamp: Date;
  alertsTriggered?: any[];
  slaCompliance?: {
    availability: number;
    responseTime: number;
    throughput: number;
  };
  comparison?: {
    baseline: string;
    improvements: string[];
    regressions: string[];
  };
}

interface QualityAnalysis {
  codeQuality: {
    complexity: number;
    maintainability: number;
    testCoverage: number;
    technicalDebt: number;
  };
  issues: QualityIssue[];
  patterns: string[];
  recommendations: string[];
  visualizations: AnalysisVisualization[];
  overallScore: number;
  confidence: number;
  timestamp: Date;
}

interface StatisticalAnalysis {
  tests: Record<string, any>;
  hypothesis: string;
  alpha: number;
  results: Record<string, any>;
  interpretation: Record<string, any>;
  assumptions: {
    normality: boolean;
    independence: boolean;
    homogeneity: boolean;
  };
  powerAnalysis: {
    power: number;
    sampleSize: number;
    effectSize: number;
  };
  conclusions: string[];
  limitations: string[];
  timestamp: Date;
}

interface VisualizationResult {
  chartType: string;
  style: string;
  interactive: boolean;
  charts: any[];
  dashboard: any;
  insights: string[];
  recommendations: string[];
  exportFormats: string[];
  accessibility: {
    colorBlind: boolean;
    screenReader: boolean;
    highContrast: boolean;
  };
  timestamp: Date;
}

interface AnomalyDetectionResult {
  method: string;
  sensitivity: number;
  threshold: string | number;
  detected: AnalysisAnomaly[];
  summary: {
    total: number;
    severity: {
      low: number;
      medium: number;
      high: number;
      critical: number;
    };
  };
  patterns: string[];
  recommendations: string[];
  falsePositiveRate: number;
  confidence: number;
  timestamp: Date;
}

interface TrendAnalysisResult {
  timeframe: string;
  metrics: string[];
  trends: AnalysisTrend[];
  correlations: Record<string, number>;
  patterns: {
    seasonal: boolean;
    cyclical: boolean;
    trending: boolean;
  };
  forecasts: any[];
  insights: string[];
  recommendations: string[];
  confidence: number;
  timestamp: Date;
}

interface PredictiveModelResult {
  algorithm: string;
  features: string[];
  target: string;
  performance: {
    accuracy: number;
    precision: number;
    recall: number;
    f1Score: number;
    rmse?: number;
    mse?: number;
    auc?: number;
  };
  validation: {
    method: string;
    splits: number;
    crossValidation: any;
  };
  predictions: any[];
  featureImportance: Record<string, number>;
  insights: string[];
  recommendations: string[];
  modelMetadata: {
    parameters: Record<string, any>;
    training: {
      epochs: number;
      convergence: boolean;
      finalLoss: number;
    };
  };
  confidence: number;
  timestamp: Date;
}

interface BusinessIntelligenceResult {
  scope: string;
  timeframe: string;
  kpis: Record<string, any>;
  trends: AnalysisTrend[];
  insights: string[];
  recommendations: string[];
  actionItems: string[];
  riskFactors: string[];
  opportunities: string[];
  marketAnalysis: {
    competitors: any[];
    positioning: string;
    threats: string[];
    opportunities: string[];
  };
  financialProjections: {
    revenue: any[];
    costs: any[];
    profitability: any[];
  };
  confidence: number;
  timestamp: Date;
}

export class AnalystAgent extends BaseAgent {
  constructor(
    id: string,
    config: AgentConfig,
    environment: AgentEnvironment,
    logger: ILogger,
    eventBus: IEventBus,
    memory: DistributedMemorySystem
  ) {
    super(id, 'analyst', config, environment, logger, eventBus, memory);
  }

  protected getDefaultCapabilities(): AgentCapabilities {
    return {
      codeGeneration: false,
      codeReview: true,
      testing: false,
      documentation: true,
      research: false,
      analysis: true,
      webSearch: false,
      apiIntegration: true,
      fileSystem: true,
      terminalAccess: false,
      languages: [
        'python',
        'r',
        'sql',
        'typescript',
        'javascript',
        'julia',
        'scala',
        'matlab'
      ],
      frameworks: [
        'pandas',
        'numpy',
        'matplotlib',
        'seaborn',
        'plotly',
        'dask',
        'spark',
        'tensorflow',
        'pytorch',
        'scikit-learn',
        'jupyter',
        'tableau'
      ],
      domains: [
        'data-analysis',
        'statistical-analysis',
        'performance-analysis',
        'business-intelligence',
        'data-visualization',
        'predictive-modeling',
        'machine-learning',
        'data-mining',
        'financial-analysis',
        'market-research',
        'operations-research',
        'quality-assurance'
      ],
      tools: [
        'data-processor',
        'statistical-analyzer',
        'chart-generator',
        'report-builder',
        'dashboard-creator',
        'ml-pipeline',
        'data-validator',
        'performance-profiler',
        'anomaly-detector',
        'trend-analyzer'
      ],
      maxConcurrentTasks: 4,
      maxMemoryUsage: 2048 * 1024 * 1024, // 2GB
      maxExecutionTime: 1200000, // 20 minutes
      reliability: 0.90,
      speed: 0.80,
      quality: 0.95
    };
  }

  protected getDefaultConfig(): Partial<AgentConfig> {
    return {
      autonomyLevel: 0.75,
      learningEnabled: true,
      adaptationEnabled: true,
      maxTasksPerHour: 15,
      maxConcurrentTasks: 4,
      timeoutThreshold: 1200000,
      reportingInterval: 45000,
      heartbeatInterval: 12000,
      permissions: [
        'file-read',
        'file-write',
        'data-access',
        'database-read',
        'api-access'
      ],
      trustedAgents: [],
      expertise: {
        'data-analysis': 0.95,
        'statistical-analysis': 0.92,
        'visualization': 0.88,
        'performance-analysis': 0.90,
        'predictive-modeling': 0.85,
        'business-intelligence': 0.83
      },
      preferences: {
        outputFormat: 'detailed',
        includeCharts: true,
        statisticalTests: 'comprehensive',
        confidenceLevel: 0.95,
        visualStyle: 'professional'
      }
    };
  }

  override async executeTask(task: TaskDefinition): Promise<any> {
    this.logger.info('Analyst executing task', {
      agentId: this.id,
      taskType: task.type,
      taskId: task.id
    });

    try {
      switch (task.type) {
        case 'data-analysis':
          return await this.analyzeData(task);
        case 'performance-analysis':
          return await this.analyzePerformance(task);
        case 'statistical-analysis':
          return await this.performStatisticalAnalysis(task);
        case 'visualization':
          return await this.createVisualization(task);
        case 'predictive-modeling':
          return await this.buildPredictiveModel(task);
        case 'anomaly-detection':
          return await this.detectAnomalies(task);
        case 'trend-analysis':
          return await this.analyzeTrends(task);
        case 'business-intelligence':
          return await this.generateBusinessIntelligence(task);
        case 'quality-analysis':
          return await this.analyzeQuality(task);
        default:
          return await this.performGeneralAnalysis(task);
      }
    } catch (error) {
      this.logger.error('Analysis task failed', {
        agentId: this.id,
        taskId: task.id,
        error: error instanceof Error ? error.message : String(error)
      });
      throw error;
    }
  }

  private async analyzeData(task: TaskDefinition): Promise<any> {
    const dataset = task.context?.dataset;
    const analysisType = task.context?.type || 'exploratory';
    const metrics = task.context?.metrics || ['central_tendency', 'distribution', 'correlation'];
    const outputFormat = task.context?.format || 'report';

    this.logger.info('Analyzing data', {
      analysisType,
      metrics,
      outputFormat
    });

    const analysis: DataAnalysis = {
      dataset: {
        name: dataset?.name || 'Unknown',
        size: dataset?.size || 0,
        columns: dataset?.columns || [],
        types: dataset?.types || {}
      },
      analysisType,
      summary: {
        rowCount: 0,
        columnCount: 0,
        missingValues: 0,
        duplicateRows: 0,
        outliers: 0
      },
      descriptiveStats: {},
      correlations: {},
      distributions: {},
      insights: [] as string[],
      recommendations: [] as string[],
      visualizations: [] as AnalysisVisualization[],
      confidence: 0,
      methodology: 'statistical-analysis',
      timestamp: new Date()
    };

    // Store analysis progress
    await this.memory.store(`analysis:${task.id}:progress`, {
      status: 'analyzing',
      startTime: new Date(),
      analysisType
    }, {
      type: 'analysis-progress',
      tags: ['analysis', this.id, analysisType],
      partition: 'tasks'
    });

    // Simulate data analysis
    await this.delay(3000);
    
    analysis.summary = {
      rowCount: 10000,
      columnCount: 15,
      missingValues: 125,
      duplicateRows: 23,
      outliers: 47
    };
    
    analysis.insights = [
      'Strong positive correlation between variables A and B (r=0.85)',
      'Variable C shows seasonal patterns with 3-month cycles',
      'Data quality is high with only 1.25% missing values',
      'Outliers concentrated in Q4 periods, likely due to seasonal effects'
    ];
    
    analysis.recommendations = [
      'Consider log transformation for skewed variables',
      'Implement imputation strategy for missing values',
      'Investigate Q4 outliers for business context',
      'Add more recent data to improve model accuracy'
    ];
    
    analysis.confidence = 0.88;

    // Store final results
    await this.memory.store(`analysis:${task.id}:results`, analysis, {
      type: 'analysis-results',
      tags: ['analysis', 'completed', this.id, analysisType],
      partition: 'tasks'
    });

    return analysis;
  }

  private async analyzePerformance(task: TaskDefinition): Promise<any> {
    const system = task.context?.system;
    const metrics = task.context?.metrics || ['response_time', 'throughput', 'error_rate'];
    const timeframe = task.context?.timeframe || '24h';
    const baseline = task.context?.baseline;

    this.logger.info('Analyzing performance', {
      system,
      metrics,
      timeframe
    });

    const performance: PerformanceAnalysis = {
      system,
      timeframe,
      metrics: {},
      benchmarks: {},
      bottlenecks: [] as AnalysisBottleneck[],
      trends: [] as AnalysisTrend[],
      recommendations: [] as string[],
      alertsTriggered: [] as any[],
      slaCompliance: {
        availability: 0,
        responseTime: 0,
        throughput: 0
      },
      comparison: {
        baseline: baseline || 'previous_week',
        improvements: [] as string[],
        regressions: [] as string[]
      },
      timestamp: new Date(),
      anomalies: [] as AnalysisAnomaly[],
      insights: [] as string[],
      visualizations: [] as AnalysisVisualization[],
      optimizationPotential: 0,
      projectedImprovement: 0,
      confidence: 0
    };

    // Simulate performance analysis
    await this.delay(2500);

    performance.metrics = {
      averageResponseTime: 245, // ms
      p95ResponseTime: 520,
      p99ResponseTime: 1200,
      throughput: 1250, // requests/min
      errorRate: 0.03, // 3%
      availability: 99.85 // %
    };
    
    performance.bottlenecks = [
      {
        component: 'Database queries',
        impact: 'high',
        description: 'N+1 query pattern causing 40% performance degradation',
        recommendation: 'Implement query optimization and caching'
      },
      {
        component: 'Memory allocation',
        impact: 'medium',
        description: 'Large object creation in hot path',
        recommendation: 'Use object pooling or lazy initialization'
      }
    ];
    
    performance.slaCompliance = {
      availability: 99.85,
      responseTime: 92.3,
      throughput: 103.5
    };

    return performance;
  }

  private async performStatisticalAnalysis(task: TaskDefinition): Promise<StatisticalAnalysis> {
    const data = task.context?.data;
    const tests = task.context?.tests || ['normality', 'correlation', 'significance'];
    const alpha = task.context?.alpha || 0.05;
    const hypothesis = task.context?.hypothesis;

    this.logger.info('Performing statistical analysis', {
      tests,
      alpha,
      hypothesis
    });

    const statistics: StatisticalAnalysis = {
      tests: {},
      hypothesis: hypothesis || 'no_hypothesis',
      alpha,
      results: {},
      interpretation: {},
      assumptions: {
        normality: false,
        independence: false,
        homogeneity: false
      },
      powerAnalysis: {
        power: 0,
        sampleSize: 0,
        effectSize: 0
      },
      conclusions: [] as string[],
      limitations: [] as string[],
      timestamp: new Date()
    };

    // Simulate statistical analysis
    await this.delay(2000);

    statistics.results = {
      normalityTest: {
        statistic: 0.923,
        pValue: 0.041,
        significant: true,
        interpretation: 'Data deviates significantly from normal distribution'
      },
      correlationTest: {
        coefficient: 0.756,
        pValue: 0.002,
        significant: true,
        interpretation: 'Strong positive correlation detected'
      }
    };
    
    statistics.conclusions.push(
      'Null hypothesis rejected at α = 0.05 level',
      'Effect size is large (Cohen\'s d = 0.8)',
      'Results are statistically and practically significant'
    );

    return statistics;
  }

  private async createVisualization(task: TaskDefinition): Promise<VisualizationResult> {
    const data = task.context?.data;
    const chartType = task.context?.type || 'auto';
    const style = task.context?.style || 'professional';
    const interactive = task.context?.interactive || false;

    this.logger.info('Creating visualization', {
      chartType,
      style,
      interactive
    });

    const visualization: VisualizationResult = {
      chartType,
      style,
      interactive,
      charts: [] as any[],
      dashboard: null,
      insights: [] as string[],
      recommendations: [] as string[],
      exportFormats: ['png', 'svg', 'pdf', 'html'],
      accessibility: {
        colorBlind: true,
        screenReader: true,
        highContrast: false
      },
      timestamp: new Date()
    };

    // Simulate visualization creation
    await this.delay(1500);

    visualization.charts.push(
      {
        type: 'line',
        title: 'Trend Analysis Over Time',
        description: 'Shows temporal patterns in the data',
        dataPoints: 100,
        interactive: true
      },
      {
        type: 'scatter',
        title: 'Correlation Matrix',
        description: 'Displays relationships between variables',
        dataPoints: 500,
        interactive: false
      }
    );
    
    visualization.insights.push(
      'Clear upward trend visible in Q3-Q4',
      'Seasonal patterns repeat every 3 months',
      'Strong correlation between variables X and Y'
    );

    return visualization;
  }

  private async buildPredictiveModel(task: TaskDefinition): Promise<PredictiveModelResult> {
    const data = task.context?.data;
    const target = task.context?.target;
    const algorithm = task.context?.algorithm || 'auto';
    const validation = task.context?.validation || 'k-fold';

    this.logger.info('Building predictive model', {
      target,
      algorithm,
      validation
    });

    const model: PredictiveModelResult = {
      algorithm: algorithm === 'auto' ? 'random_forest' : algorithm,
      features: [],
      target: target || 'default_target',
      performance: {
        accuracy: 0,
        precision: 0,
        recall: 0,
        f1Score: 0,
        rmse: 0,
        mse: 0
      },
      validation: {
        method: validation,
        splits: 5,
        crossValidation: {
          folds: 5,
          avgScore: 0,
          stdDev: 0
        }
      },
      predictions: [],
      featureImportance: {},
      insights: [],
      recommendations: [],
      modelMetadata: {
        parameters: {},
        training: {
          epochs: 100,
          convergence: true,
          finalLoss: 0.15
        }
      },
      confidence: 0,
      timestamp: new Date()
    };

    // Simulate model building
    await this.delay(4000);

    model.performance = {
      accuracy: 0.87,
      precision: 0.85,
      recall: 0.89,
      f1Score: 0.87,
      auc: 0.92,
      rmse: 2.34
    };
    
    model.featureImportance = {
      'feature_1': 0.35,
      'feature_2': 0.28,
      'feature_3': 0.22,
      'feature_4': 0.15
    };

    return model;
  }

  private async detectAnomalies(task: TaskDefinition): Promise<AnomalyDetectionResult> {
    const data = task.context?.data;
    const method = task.context?.method || 'isolation_forest';
    const sensitivity = task.context?.sensitivity || 0.1;
    const threshold = task.context?.threshold;

    this.logger.info('Detecting anomalies', {
      method,
      sensitivity
    });

    const anomalies: AnomalyDetectionResult = {
      method,
      sensitivity,
      threshold: threshold || 'auto',
      detected: ([] as any) as any[],
      summary: {
        total: 0,
        severity: {
          low: 0,
          medium: 0,
          high: 0,
          critical: 0
        }
      },
      patterns: ([] as any) as string[],
      recommendations: ([] as any) as string[],
      falsePositiveRate: 0,
      confidence: 0,
      timestamp: new Date()
    };

    // Simulate anomaly detection
    await this.delay(2000);

    (anomalies.detected as any).push(
      {
        id: 'anom_001',
        timestamp: new Date('2024-01-15'),
        severity: 'high',
        score: 0.95,
        description: 'Unusual spike in traffic during off-peak hours',
        features: ['traffic_volume', 'time_of_day']
      },
      {
        id: 'anom_002',
        timestamp: new Date('2024-01-16'),
        severity: 'medium',
        score: 0.72,
        description: 'Abnormal response time pattern',
        features: ['response_time', 'request_size']
      }
    );
    
    anomalies.summary = {
      total: 15,
      severity: {
        low: 8,
        medium: 4,
        high: 2,
        critical: 1
      }
    };
    
    anomalies.confidence = 0.83;

    return anomalies;
  }

  private async analyzeTrends(task: TaskDefinition): Promise<TrendAnalysisResult> {
    const data = task.context?.data;
    const timeframe = task.context?.timeframe || '3-months';
    const granularity = task.context?.granularity || 'daily';
    const forecast = task.context?.forecast || false;

    this.logger.info('Analyzing trends', {
      timeframe,
      granularity,
      forecast
    });

    const trends: TrendAnalysisResult = {
      timeframe,
      metrics: ([] as any) as string[],
      trends: ([] as any) as any[],
      correlations: {},
      patterns: {
        seasonal: false,
        cyclical: false,
        trending: false
      },
      forecasts: forecast ? ([] as any) : [],
      insights: ([] as any) as string[],
      recommendations: ([] as any) as string[],
      confidence: 0,
      timestamp: new Date()
    };

    // Simulate trend analysis
    await this.delay(2500);

    (trends.trends as any).push(
      {
        metric: 'user_engagement',
        direction: 'increasing',
        slope: 0.15,
        significance: 0.92,
        period: 'Q4-2023'
      },
      {
        metric: 'conversion_rate',
        direction: 'stable',
        slope: 0.02,
        significance: 0.23,
        period: 'Q4-2023'
      }
    );
    
    trends.patterns = {
      seasonal: true,
      cyclical: false,
      trending: true
    };
    
    trends.confidence = 0.89;

    return trends;
  }

  private async generateBusinessIntelligence(task: TaskDefinition): Promise<BusinessIntelligenceResult> {
    const domain = task.context?.domain || 'general';
    const metrics = task.context?.metrics || ['revenue', 'growth', 'efficiency'];
    const timeframe = task.context?.timeframe || 'quarterly';
    const audience = task.context?.audience || 'executive';

    this.logger.info('Generating business intelligence', {
      domain,
      metrics,
      timeframe,
      audience
    });

    const intelligence: BusinessIntelligenceResult = {
      scope: domain,
      timeframe,
      kpis: {},
      trends: [],
      insights: [],
      recommendations: [],
      actionItems: [],
      riskFactors: [],
      opportunities: [],
      marketAnalysis: {
        competitors: [],
        positioning: '',
        threats: [],
        opportunities: []
      },
      financialProjections: {
        revenue: [],
        costs: [],
        profitability: []
      },
      confidence: 0,
      timestamp: new Date()
    };

    // Simulate business intelligence generation
    await this.delay(3500);

    intelligence.kpis = {
      revenue_growth: 12.5,
      customer_acquisition_cost: 45.30,
      lifetime_value: 1250.00,
      churn_rate: 5.2,
      market_share: 15.7
    };
    
    intelligence.insights = [
      'Customer acquisition costs decreased by 18% due to improved targeting',
      'Premium tier adoption increased 35% following feature updates',
      'Seasonal patterns show consistent Q4 revenue spikes'
    ];
    
    intelligence.recommendations = [
      'Increase marketing budget allocation to high-performing channels',
      'Develop retention strategies for at-risk customer segments',
      'Accelerate premium feature development to capture market demand'
    ];
    
    intelligence.confidence = 0.91;

    return intelligence;
  }

  private async analyzeQuality(task: TaskDefinition): Promise<QualityAnalysis> {
    const subject = task.context?.subject;
    const criteria = task.context?.criteria || ['accuracy', 'completeness', 'consistency'];
    const standards = task.context?.standards || 'industry';
    const benchmark = task.context?.benchmark;

    this.logger.info('Analyzing quality', {
      subject,
      criteria,
      standards
    });

    const quality: QualityAnalysis = {
      codeQuality: {
        complexity: 0,
        maintainability: 0,
        testCoverage: 0,
        technicalDebt: 0
      },
      issues: ([] as any) as QualityIssue[],
      patterns: ([] as any) as string[],
      recommendations: ([] as any) as string[],
      visualizations: ([] as any) as AnalysisVisualization[],
      overallScore: 0,
      confidence: 0,
      timestamp: new Date()
    };

    // Simulate quality analysis
    await this.delay(2000);

    quality.codeQuality = {
      complexity: 3.2,
      maintainability: 0.87,
      testCoverage: 0.91,
      technicalDebt: 0.23
    };
    
    quality.overallScore = 0.91;
    
    (quality.issues as any).push({
      category: 'completeness',
      severity: 'medium',
      description: 'Missing values in 13% of records',
      impact: 'Affects downstream analysis accuracy'
    });
    
    (quality.patterns as any).push('High complexity in authentication module');
    (quality.recommendations as any).push('Implement automated testing coverage');
    quality.confidence = 0.89;

    return quality;
  }

  private async performGeneralAnalysis(task: TaskDefinition): Promise<any> {
    this.logger.info('Performing general analysis', {
      description: task.description
    });

    // Default to data analysis
    return await this.analyzeData(task);
  }

  private async delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  override getAgentStatus(): any {
    return {
      ...super.getAgentStatus(),
      specialization: 'Data Analysis & Performance Optimization',
      analyticsCapabilities: [
        'Statistical Analysis',
        'Data Visualization',
        'Performance Analysis',
        'Predictive Modeling',
        'Anomaly Detection',
        'Business Intelligence'
      ],
      supportedFormats: ['CSV', 'JSON', 'Parquet', 'SQL', 'Excel'],
      statisticalMethods: ['Descriptive', 'Inferential', 'Multivariate', 'Time Series'],
      currentAnalyses: this.getCurrentTasks().length,
      averageAnalysisTime: '10-20 minutes',
      lastAnalysisCompleted: this.getLastTaskCompletedTime(),
      preferredTools: ['Python', 'R', 'SQL', 'Jupyter']
    };
  }
}

export const createAnalystAgent = (
  id: string,
  config: Partial<AgentConfig>,
  environment: Partial<AgentEnvironment>,
  logger: ILogger,
  eventBus: IEventBus,
  memory: DistributedMemorySystem
): AnalystAgent => {
  const tempAgent = new AnalystAgent(id, {} as AgentConfig, {} as AgentEnvironment, logger, eventBus, memory);
  const defaultConfig = (tempAgent as any).getDefaultConfig();
  const defaultEnv = {
    runtime: 'deno' as const,
    version: '1.40.0',
    workingDirectory: './agents/analyst',
    tempDirectory: './tmp/analyst',
    logDirectory: './logs/analyst',
    apiEndpoints: {},
    credentials: {},
    availableTools: [
      'data-processor',
      'statistical-analyzer',
      'chart-generator',
      'report-builder'
    ],
    toolConfigs: {
      dataProcessor: { chunkSize: 10000, parallel: true },
      chartGenerator: { style: 'professional', dpi: 300 },
      reportBuilder: { format: 'pdf', includeCharts: true }
    }
  };

  return new AnalystAgent(
    id,
    { ...defaultConfig, ...config } as AgentConfig,
    { ...defaultEnv, ...environment } as AgentEnvironment,
    logger,
    eventBus,
    memory
  );
};