// agents/base/metrics.ts
import { register, Counter, Histogram, Gauge } from 'prom-client';

export class AgentMetrics {
  // Task metrics
  private tasksReceived = new Counter({
    name: 'agent_tasks_received_total',
    help: 'Total number of tasks received',
    labelNames: ['agent_type', 'task_type']
  });
  
  private tasksCompleted = new Counter({
    name: 'agent_tasks_completed_total',
    help: 'Total number of tasks completed',
    labelNames: ['agent_type', 'task_type', 'status']
  });
  
  private taskDuration = new Histogram({
    name: 'agent_task_duration_seconds',
    help: 'Task execution duration in seconds',
    labelNames: ['agent_type', 'task_type'],
    buckets: [0.1, 0.5, 1, 5, 10, 30, 60, 300, 600]
  });
  
  // TDD metrics
  private testsRun = new Counter({
    name: 'agent_tests_run_total',
    help: 'Total number of test runs',
    labelNames: ['agent_type', 'phase']
  });
  
  private testResults = new Gauge({
    name: 'agent_test_results',
    help: 'Test results (passing/total)',
    labelNames: ['agent_type', 'result_type']
  });
  
  private tddPhase = new Gauge({
    name: 'agent_tdd_phase',
    help: 'Current TDD phase (1=red, 2=green, 3=refactor)',
    labelNames: ['agent_type']
  });
  
  // Resource metrics
  private cpuUsage = new Gauge({
    name: 'agent_cpu_usage_percent',
    help: 'CPU usage percentage',
    labelNames: ['agent_type', 'agent_id']
  });
  
  private memoryUsage = new Gauge({
    name: 'agent_memory_usage_bytes',
    help: 'Memory usage in bytes',
    labelNames: ['agent_type', 'agent_id']
  });
  
  // Communication metrics
  private messagessSent = new Counter({
    name: 'agent_messages_sent_total',
    help: 'Total messages sent',
    labelNames: ['agent_type', 'target_agent', 'message_type']
  });
  
  private messagesReceived = new Counter({
    name: 'agent_messages_received_total',
    help: 'Total messages received',
    labelNames: ['agent_type', 'source_agent', 'message_type']
  });
  
  private messageLatency = new Histogram({
    name: 'agent_message_latency_seconds',
    help: 'Message handling latency',
    labelNames: ['agent_type', 'message_type'],
    buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1]
  });
  
  // Status update metrics
  private statusUpdates = new Counter({
    name: 'agent_status_updates_total',
    help: 'Total status updates written to Agent_Output.md',
    labelNames: ['agent_type']
  });
  
  private lastStatusUpdate = new Gauge({
    name: 'agent_last_status_update_timestamp',
    help: 'Timestamp of last status update',
    labelNames: ['agent_type', 'agent_id']
  });
  
  recordTaskReceived(agentType: string, taskType: string): void {
    this.tasksReceived.inc({ agent_type: agentType, task_type: taskType });
  }
  
  recordTaskCompleted(
    agentType: string,
    taskType: string,
    status: 'success' | 'failure',
    duration: number
  ): void {
    this.tasksCompleted.inc({ 
      agent_type: agentType, 
      task_type: taskType, 
      status 
    });
    
    this.taskDuration.observe(
      { agent_type: agentType, task_type: taskType },
      duration
    );
  }
  
  recordTDDPhase(agentType: string, phase: 'red' | 'green' | 'refactor'): void {
    const phaseMap = { red: 1, green: 2, refactor: 3 };
    this.tddPhase.set({ agent_type: agentType }, phaseMap[phase]);
  }
  
  recordTestResults(
    agentType: string,
    passing: number,
    total: number
  ): void {
    this.testResults.set({ agent_type: agentType, result_type: 'passing' }, passing);
    this.testResults.set({ agent_type: agentType, result_type: 'total' }, total);
  }
}

// services/MetricsCollector.ts
export class MetricsCollector {
  private customMetrics = new Map<string, any>();
  
  // TDD Compliance Metrics
  registerTDDMetrics(): void {
    this.customMetrics.set('tdd_compliance_rate', new Gauge({
      name: 'autosdlc_tdd_compliance_rate',
      help: 'Percentage of implementations following TDD',
      labelNames: ['project', 'sprint']
    }));
    
    this.customMetrics.set('tests_written_first', new Counter({
      name: 'autosdlc_tests_written_first_total',
      help: 'Number of features with tests written first',
      labelNames: ['agent', 'feature_type']
    }));
    
    this.customMetrics.set('red_phase_violations', new Counter({
      name: 'autosdlc_red_phase_violations_total',
      help: 'Number of times implementation started without all tests red',
      labelNames: ['agent', 'reason']
    }));
  }
  
  // Agent Collaboration Metrics
  registerCollaborationMetrics(): void {
    this.customMetrics.set('agent_handoffs', new Counter({
      name: 'autosdlc_agent_handoffs_total',
      help: 'Number of task handoffs between agents',
      labelNames: ['from_agent', 'to_agent', 'task_type']
    }));
    
    this.customMetrics.set('agent_wait_time', new Histogram({
      name: 'autosdlc_agent_wait_time_seconds',
      help: 'Time agents spend waiting for other agents',
      labelNames: ['waiting_agent', 'blocking_agent'],
      buckets: [1, 5, 10, 30, 60, 300, 600, 1800, 3600]
    }));
  }
  
  // Code Quality Metrics
  registerQualityMetrics(): void {
    this.customMetrics.set('code_complexity', new Gauge({
      name: 'autosdlc_code_complexity',
      help: 'Cyclomatic complexity of generated code',
      labelNames: ['agent', 'module']
    }));
    
    this.customMetrics.set('test_coverage', new Gauge({
      name: 'autosdlc_test_coverage_percent',
      help: 'Test coverage percentage',
      labelNames: ['project', 'module']
    }));
    
    this.customMetrics.set('review_iterations', new Histogram({
      name: 'autosdlc_review_iterations',
      help: 'Number of review iterations before approval',
      labelNames: ['reviewer_agent', 'coder_agent'],
      buckets: [1, 2, 3, 4, 5, 10]
    }));
  }
}

// utils/Logger.ts
import winston from 'winston';
import { LogstashTransport } from 'winston-logstash-transport';

export class StructuredLogger {
  private logger: winston.Logger;
  
  constructor(component: string, agentType?: string) {
    this.logger = winston.createLogger({
      level: process.env.LOG_LEVEL || 'info',
      format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.errors({ stack: true }),
        winston.format.json()
      ),
      defaultMeta: {
        component,
        agentType,
        environment: process.env.NODE_ENV,
        version: process.env.APP_VERSION
      },
      transports: [
        // Console transport for development
        new winston.transports.Console({
          format: winston.format.combine(
            winston.format.colorize(),
            winston.format.simple()
          )
        }),
        
        // Loki transport for production
        new LogstashTransport({
          host: process.env.LOKI_HOST || 'loki',
          port: parseInt(process.env.LOKI_PORT || '5000'),
          ssl_enable: true,
          max_connect_retries: -1,
          timeout_connect_retries: 60000
        })
      ]
    });
  }
  
  // Structured log methods
  logTaskReceived(task: Task, context: LogContext): void {
    this.logger.info('Task received', {
      event: 'task_received',
      taskId: task.id,
      taskType: task.type,
      priority: task.priority,
      ...context
    });
  }
  
  logTDDPhaseChange(phase: string, details: TDDDetails): void {
    this.logger.info('TDD phase change', {
      event: 'tdd_phase_change',
      phase,
      testsTotal: details.testsTotal,
      testsPassing: details.testsPassing,
      testsFailing: details.testsFailing,
      coverage: details.coverage,
      timestamp: new Date().toISOString()
    });
  }
  
  logAgentCommunication(comm: AgentCommunication): void {
    this.logger.info('Agent communication', {
      event: 'agent_communication',
      from: comm.from,
      to: comm.to,
      messageType: comm.messageType,
      correlationId: comm.correlationId,
      duration: comm.duration
    });
  }
  
  logError(error: Error, context: ErrorContext): void {
    this.logger.error('Error occurred', {
      event: 'error',
      errorType: error.name,
      errorMessage: error.message,
      errorStack: error.stack,
      ...context,
      timestamp: new Date().toISOString()
    });
  }
}

// agents/base/LogPatterns.ts
export const AgentLogPatterns = {
  // Task lifecycle
  TASK_START: {
    pattern: /Task started: (\w+) \(ID: ([\w-]+)\)/,
    fields: ['taskType', 'taskId']
  },
  
  TASK_COMPLETE: {
    pattern: /Task completed: (\w+) \(ID: ([\w-]+)\) - Duration: (\d+)ms/,
    fields: ['taskType', 'taskId', 'duration']
  },
  
  // TDD patterns
  TDD_RED_VERIFIED: {
    pattern: /TDD Red phase verified: (\d+)\/(\d+) tests failing/,
    fields: ['failingTests', 'totalTests']
  },
  
  TDD_GREEN_ACHIEVED: {
    pattern: /TDD Green phase achieved: All (\d+) tests passing/,
    fields: ['totalTests']
  },
  
  TDD_REFACTOR_COMPLETE: {
    pattern: /TDD Refactor complete: (\d+) improvements made/,
    fields: ['improvements']
  },
  
  // Agent status
  STATUS_UPDATE: {
    pattern: /Agent status updated: (\w+) - File: Agent_Output\.md/,
    fields: ['status']
  },
  
  // Communication
  MESSAGE_SENT: {
    pattern: /Message sent to (\w+): Type=(\w+), ID=([\w-]+)/,
    fields: ['targetAgent', 'messageType', 'messageId']
  },
  
  MESSAGE_RECEIVED: {
    pattern: /Message received from (\w+): Type=(\w+), ID=([\w-]+)/,
    fields: ['sourceAgent', 'messageType', 'messageId']
  }
};

// Log parser for analysis
export class AgentLogParser {
  parseLogLine(line: string): ParsedLog | null {
    for (const [eventType, config] of Object.entries(AgentLogPatterns)) {
      const match = line.match(config.pattern);
      if (match) {
        const fields: any = {};
        config.fields.forEach((field, index) => {
          fields[field] = match[index + 1];
        });
        
        return {
          eventType,
          fields,
          timestamp: this.extractTimestamp(line),
          raw: line
        };
      }
    }
    return null;
  }
}

// tracing/setup.ts
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';

export function initializeTracing(serviceName: string, agentType?: string) {
  const traceExporter = new OTLPTraceExporter({
    url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://tempo:4317',
  });

  const sdk = new NodeSDK({
    resource: new Resource({
      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
      [SemanticResourceAttributes.SERVICE_VERSION]: process.env.APP_VERSION || '1.0.0',
      'agent.type': agentType,
      'environment': process.env.NODE_ENV
    }),
    traceExporter,
    instrumentations: [
      getNodeAutoInstrumentations({
        '@opentelemetry/instrumentation-fs': {
          enabled: false, // Disable to reduce noise
        },
      }),
    ],
  });

  sdk.start();
  
  return sdk;
}

// agents/base/Tracing.ts
import { trace, context, SpanStatusCode } from '@opentelemetry/api';

export class AgentTracing {
  private tracer;
  
  constructor(agentType: string) {
    this.tracer = trace.getTracer(`autosdlc-${agentType}-agent`);
  }
  
  async traceTask<T>(
    taskType: string,
    taskId: string,
    fn: () => Promise<T>
  ): Promise<T> {
    const span = this.tracer.startSpan(`agent.task.${taskType}`, {
      attributes: {
        'task.id': taskId,
        'task.type': taskType,
        'agent.type': this.agentType
      }
    });
    
    try {
      const result = await context.with(
        trace.setSpan(context.active(), span),
        fn
      );
      
      span.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (error) {
      span.setStatus({
        code: SpanStatusCode.ERROR,
        message: error.message
      });
      span.recordException(error);
      throw error;
    } finally {
      span.end();
    }
  }
  
  async traceTDDPhase<T>(
    phase: 'red' | 'green' | 'refactor',
    fn: () => Promise<T>
  ): Promise<T> {
    const span = this.tracer.startSpan(`tdd.phase.${phase}`, {
      attributes: {
        'tdd.phase': phase,
        'agent.type': this.agentType
      }
    });
    
    return context.with(
      trace.setSpan(context.active(), span),
      async () => {
        try {
          const result = await fn();
          span.addEvent(`${phase} phase completed`);
          return result;
        } finally {
          span.end();
        }
      }
    );
  }
  
  traceAgentCommunication(
    targetAgent: string,
    messageType: string,
    correlationId: string
  ): Span {
    const span = this.tracer.startSpan('agent.communication', {
      attributes: {
        'communication.target': targetAgent,
        'communication.type': messageType,
        'communication.correlation_id': correlationId,
        'agent.type': this.agentType
      }
    });
    
    return span;
  }
}

// monitoring/PerformanceAnalyzer.ts
export class PerformanceAnalyzer {
  async analyzeAgentPerformance(
    agentType: string,
    timeRange: TimeRange
  ): Promise<PerformanceReport> {
    const metrics = await this.fetchMetrics(agentType, timeRange);
    
    return {
      summary: {
        avgTaskDuration: this.calculateAverage(metrics.taskDurations),
        p95TaskDuration: this.calculatePercentile(metrics.taskDurations, 95),
        successRate: metrics.successCount / metrics.totalCount,
        throughput: metrics.totalCount / timeRange.duration
      },
      
      bottlenecks: this.identifyBottlenecks(metrics),
      
      recommendations: this.generateRecommendations(metrics),
      
      trends: {
        taskDuration: this.analyzeTrend(metrics.taskDurationHistory),
        errorRate: this.analyzeTrend(metrics.errorRateHistory),
        resourceUsage: this.analyzeTrend(metrics.resourceHistory)
      }
    };
  }
  
  private identifyBottlenecks(metrics: AgentMetrics): Bottleneck[] {
    const bottlenecks = [];
    
    // High wait times
    if (metrics.avgWaitTime > 60) {
      bottlenecks.push({
        type: 'agent_waiting',
        severity: 'high',
        description: `Agent spends avg ${metrics.avgWaitTime}s waiting for other agents`,
        recommendation: 'Consider scaling blocking agents'
      });
    }
    
    // Memory pressure
    if (metrics.memoryUsage > 0.8 * metrics.memoryLimit) {
      bottlenecks.push({
        type: 'memory_pressure',
        severity: 'medium',
        description: `Memory usage at ${(metrics.memoryUsage / metrics.memoryLimit * 100).toFixed(1)}% of limit`,
        recommendation: 'Increase memory limit or optimize memory usage'
      });
    }
    
    // Test execution time
    if (metrics.avgTestDuration > 300) {
      bottlenecks.push({
        type: 'slow_tests',
        severity: 'medium',
        description: `Average test duration ${metrics.avgTestDuration}s exceeds threshold`,
        recommendation: 'Optimize test suite or parallelize test execution'
      });
    }
    
    return bottlenecks;
  }
}