class PerformanceMonitor {
  private metrics = {
    messageCount: 0,
    totalBytes: 0,
    latencies: [] as number[],
    throughput: [] as number[],
    errors: 0
  };
  
  private performanceObserver = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      if (entry.entryType === "measure" && entry.name.startsWith("mcp.")) {
        this.recordLatency(entry.duration);
      }
    }
  });
  
  recordMessage(message: MCPMessage, direction: "in" | "out"): void {
    const size = JSON.stringify(message).length;
    
    this.metrics.messageCount++;
    this.metrics.totalBytes += size;
    
    // Mark for performance measurement
    performance.mark(`mcp.${direction}.${message.id}`);
    
    // Calculate throughput
    const now = Date.now();
    const throughput = this.calculateThroughput();
    this.metrics.throughput.push(throughput);
    
    // Emit metrics event
    this.emit("metrics", {
      instant: {
        messagesPerSecond: this.getMessagesPerSecond(),
        bytesPerSecond: this.getBytesPerSecond(),
        averageLatency: this.getAverageLatency(),
        p99Latency: this.getP99Latency()
      }
    });
  }
  
  private calculateThroughput(): number {
    const window = 1000; // 1 second window
    const now = Date.now();
    const cutoff = now - window;
    
    // Count messages in window
    const recentMessages = this.metrics.throughput.filter(t => t > cutoff).length;
    return recentMessages;
  }
}

// Real production optimization
class OptimizedMCPClient {
  private messagePool = new ObjectPool<MCPMessage>(() => ({ jsonrpc: "2.0" }));
  private compressionThreshold = 1024; // Compress messages over 1KB
  
  async send(method: string, params: any): Promise<any> {
    const message = this.messagePool.acquire();
    
    try {
      message.method = method;
      message.params = params;
      message.id = this.generateId();
      
      // Optimize payload
      const optimized = this.optimize(message);
      
      // Send with timing
      const start = performance.now();
      const response = await this.transport.send(optimized);
      const duration = performance.now() - start;
      
      // Record metrics
      this.metrics.record({
        method,
        duration,
        payloadSize: JSON.stringify(optimized).length,
        compressed: optimized !== message
      });
      
      return response;
    } finally {
      this.messagePool.release(message);
    }
  }
  
  private optimize(message: MCPMessage): MCPMessage | CompressedMessage {
    const json = JSON.stringify(message);
    
    if (json.length > this.compressionThreshold) {
      return {
        jsonrpc: "2.0",
        compressed: true,
        data: gzip(json),
        id: message.id
      };
    }
    
    return message;
  }
}