Short Polling:
├─ Best case: 0ms (event just before poll)
├─ Average: interval/2 (1500ms for 3s interval)
└─ Worst case: interval (3000ms)

Long Polling:
├─ Best case: 0ms (event while connected)
├─ Average: ~50ms (reconnection time)
└─ Worst case: timeout + reconnect

WebSocket:
├─ Best case: RTT (5-10ms)
├─ Average: RTT (5-10ms)
└─ Worst case: RTT (5-10ms)

// Maximum concurrent connections
const limits = {
  shortPolling: {
    connectionsPerSecond: 1000 / interval,
    totalConnections: clients * (1000 / interval),
    serverLoad: 'High (many short connections)'
  },
  longPolling: {
    connectionsPerSecond: events,
    totalConnections: clients,
    serverLoad: 'Medium (held connections)'
  },
  webSocket: {
    connectionsPerSecond: 0, // After initial connection
    totalConnections: clients,
    serverLoad: 'Low (persistent connections)'
  }
};

// Monthly cost estimation for 1000 concurrent users
const monthlyCosts = {
  shortPolling: {
    requests: 1000 * 28800 * 30, // 864M requests
    dataTransfer: 1000 * 1.3 * 30, // 39 GB
    compute: 'High (CPU for connections)',
    estimatedCost: '$500-1000'
  },
  longPolling: {
    requests: 1000 * 100 * 30, // 3M requests
    dataTransfer: 1000 * 0.2 * 30, // 6 GB
    compute: 'Medium',
    estimatedCost: '$100-300'
  },
  webSocket: {
    requests: 1000, // Initial connections only
    dataTransfer: 1000 * 0.1 * 30, // 3 GB
    compute: 'Low',
    estimatedCost: '$50-150'
  }
};

Is real-time critical (< 100ms)?
├─ No → Is update frequency high (> 1/min)?
│   ├─ No → Use Short Polling
│   └─ Yes → Use Long Polling
└─ Yes → Need bidirectional communication?
    ├─ No → Use Long Polling or SSE
    └─ Yes → Use WebSocket

// Lines of Code (approximate)
const complexity = {
  shortPolling: {
    client: 20,
    server: 10,
    total: 30
  },
  longPolling: {
    client: 50,
    server: 100,
    total: 150
  },
  webSocket: {
    client: 150,
    server: 300,
    infrastructure: 200,
    total: 650
  }
};

// Before (Short Polling)
setInterval(fetchData, 3000);

// After (Long Polling)
async function longPoll() {
  const data = await fetch('/api/long-poll');
  handleData(data);
  longPoll(); // Immediate reconnect
}

// Before (Long Polling)
async function longPoll() {
  const response = await fetch('/api/data');
  handleData(response);
  longPoll();
}

// After (WebSocket)
const ws = new WebSocket('wss://api.example.com');
ws.onmessage = (event) => handleData(event.data);

class AdaptiveClient {
  constructor() {
    this.protocols = ['websocket', 'long-polling', 'short-polling'];
    this.currentProtocol = null;
  }
  
  async connect() {
    for (const protocol of this.protocols) {
      if (await this.tryProtocol(protocol)) {
        this.currentProtocol = protocol;
        break;
      }
    }
  }
  
  async tryProtocol(protocol) {
    switch(protocol) {
      case 'websocket':
        return this.tryWebSocket();
      case 'long-polling':
        return this.tryLongPolling();
      case 'short-polling':
        return true; // Always works
    }
  }
}

class ResilientConnection {
  constructor() {
    this.primary = new WebSocketClient();
    this.fallback = new LongPollingClient();
    this.emergency = new ShortPollingClient();
  }
  
  async connect() {
    try {
      await this.primary.connect();
    } catch (error) {
      console.warn('WebSocket failed, falling back to long polling');
      try {
        await this.fallback.connect();
      } catch (error) {
        console.warn('Long polling failed, using short polling');
        await this.emergency.connect();
      }
    }
  }
}

const loadTestScenarios = {
  shortPolling: {
    users: 1000,
    interval: 3000,
    duration: 3600000, // 1 hour
    expectedRequests: 1200000,
    acceptableErrorRate: '< 1%'
  },
  longPolling: {
    users: 1000,
    avgHoldTime: 30000,
    duration: 3600000,
    expectedConnections: 120000,
    acceptableErrorRate: '< 0.5%'
  },
  webSocket: {
    users: 1000,
    messagesPerSecond: 10,
    duration: 3600000,
    expectedMessages: 36000000,
    acceptableErrorRate: '< 0.1%'
  }
};