// Client-side short polling
class ShortPoller {
  private intervalId: ReturnType<typeof setInterval> | null = null;
 
  start(url: string, intervalMs: number, onData: (data: any) => void) {
    this.intervalId = setInterval(async () => {
      try {
        const response = await fetch(url);
        const data = await response.json();
        onData(data);
      } catch (error) {
        console.error('Polling error:', error);
      }
    }, intervalMs);
  }
 
  stop() {
    if (this.intervalId) {
      clearInterval(this.intervalId);
      this.intervalId = null;
    }
  }
}
 
// Usage
const poller = new ShortPoller();
poller.start('/api/notifications', 5000, (data) => {
  updateNotificationBadge(data.unreadCount);
});

// Server-side endpoint for polling
// Next.js API route
export async function GET(request: Request) {
  const userId = await getUserId(request);
  const notifications = await db
    .select()
    .from(notificationsTable)
    .where(eq(notificationsTable.userId, userId))
    .orderBy(desc(notificationsTable.createdAt))
    .limit(20);
 
  return Response.json({
    notifications,
    unreadCount: notifications.filter(n => !n.read).length,
  });
}

// Server-side long polling
export async function GET(request: Request) {
  const userId = await getUserId(request);
  const lastEventId = request.headers.get('Last-Event-ID') || '0';
  const timeoutMs = 30000;
 
  // Wait for new data or timeout
  const data = await waitForNewEvents(userId, lastEventId, timeoutMs);
 
  if (data) {
    return Response.json({ events: data, hasMore: false });
  }
 
  // Timeout - return empty response, client will reconnect
  return Response.json({ events: [], hasMore: false });
}
 
async function waitForNewEvents(
  userId: string,
  afterId: string,
  timeoutMs: number
): Promise<Event[] | null> {
  return new Promise((resolve) => {
    const timeout = setTimeout(() => resolve(null), timeoutMs);
 
    const unsubscribe = eventEmitter.on(`user:${userId}`, (events) => {
      clearTimeout(timeout);
      unsubscribe();
      resolve(events);
    });
  });
}

// Server-side SSE with Next.js Route Handler
export async function GET(request: Request) {
  const userId = await getUserId(request);
 
  const stream = new ReadableStream({
    start(controller) {
      const encoder = new TextEncoder();
 
      // Send initial connection event
      controller.enqueue(
        encoder.encode(`event: connected\ndata: {"status":"ok"}\n\n`)
      );
 
      // Set up event listener for this user
      const handler = (event: AppEvent) => {
        const data = JSON.stringify(event);
        controller.enqueue(
          encoder.encode(`id: ${event.id}\nevent: ${event.type}\ndata: ${data}\n\n`)
        );
      };
 
      eventEmitter.on(`user:${userId}`, handler);
 
      // Send periodic keepalive comments
      const keepalive = setInterval(() => {
        controller.enqueue(encoder.encode(': keepalive\n\n'));
      }, 15000);
 
      // Cleanup on disconnect
      request.signal.addEventListener('abort', () => {
        eventEmitter.off(`user:${userId}`, handler);
        clearInterval(keepalive);
        controller.close();
      });
    },
  });
 
  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    },
  });
}

// Client-side SSE
class NotificationStream {
  private eventSource: EventSource | null = null;
 
  connect(onNotification: (event: AppEvent) => void) {
    this.eventSource = new EventSource('/api/notifications/stream');
 
    this.eventSource.addEventListener('notification', (e) => {
      const data = JSON.parse(e.data);
      onNotification(data);
    });
 
    this.eventSource.addEventListener('connected', () => {
      console.log('SSE connection established');
    });
 
    this.eventSource.onerror = (error) => {
      console.error('SSE error:', error);
      // EventSource automatically reconnects with Last-Event-ID header
    };
  }
 
  disconnect() {
    this.eventSource?.close();
    this.eventSource = null;
  }
}
 
// Usage in React
function useNotifications() {
  const [notifications, setNotifications] = useState<AppEvent[]>([]);
 
  useEffect(() => {
    const stream = new NotificationStream();
    stream.connect((event) => {
      setNotifications(prev => [event, ...prev]);
    });
    return () => stream.disconnect();
  }, []);
 
  return notifications;
}

// Server-side WebSocket with ws library
import { WebSocketServer, WebSocket } from 'ws';
 
const wss = new WebSocketServer({ port: 8080 });
 
const clients = new Map<string, Set<WebSocket>>();
 
wss.on('connection', (ws, request) => {
  const userId = authenticateFromRequest(request);
  if (!userId) {
    ws.close(4001, 'Unauthorized');
    return;
  }
 
  // Track connected clients
  if (!clients.has(userId)) {
    clients.set(userId, new Set());
  }
  clients.get(userId)!.add(ws);
 
  // Handle incoming messages from client
  ws.on('message', async (raw) => {
    try {
      const message = JSON.parse(raw.toString());
 
      switch (message.type) {
        case 'chat:send':
          await handleChatMessage(userId, message.payload);
          break;
        case 'typing:start':
          broadcastToRoom(message.payload.roomId, {
            type: 'typing:indicator',
            userId,
            isTyping: true,
          });
          break;
        case 'presence:ping':
          updatePresence(userId);
          break;
      }
    } catch (error) {
      ws.send(JSON.stringify({ type: 'error', message: 'Invalid message' }));
    }
  });
 
  ws.on('close', () => {
    clients.get(userId)?.delete(ws);
    if (clients.get(userId)?.size === 0) {
      clients.delete(userId);
    }
  });
 
  // Send queued messages
  sendQueuedMessages(userId, ws);
});
 
function broadcastToRoom(roomId: string, message: object) {
  const roomMembers = getRoomMembers(roomId);
  const payload = JSON.stringify(message);
 
  for (const memberId of roomMembers) {
    const memberSockets = clients.get(memberId);
    memberSockets?.forEach(ws => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(payload);
      }
    });
  }
}

// Client-side WebSocket with reconnection
class ChatConnection {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 5;
  private handlers = new Map<string, Function[]>();
 
  connect(token: string) {
    this.ws = new WebSocket(`wss://api.example.com/ws?token=${token}`);
 
    this.ws.onopen = () => {
      this.reconnectAttempts = 0;
      this.emit('connected', {});
    };
 
    this.ws.onmessage = (event) => {
      const message = JSON.parse(event.data);
      this.emit(message.type, message);
    };
 
    this.ws.onclose = (event) => {
      if (event.code !== 1000 && this.reconnectAttempts < this.maxReconnectAttempts) {
        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
        this.reconnectAttempts++;
        setTimeout(() => this.connect(token), delay);
      }
    };
  }
 
  send(type: string, payload: object) {
    if (this.ws?.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify({ type, payload }));
    }
  }
 
  on(event: string, handler: Function) {
    if (!this.handlers.has(event)) this.handlers.set(event, []);
    this.handlers.get(event)!.push(handler);
  }
 
  private emit(event: string, data: any) {
    this.handlers.get(event)?.forEach(h => h(data));
  }
}

// Scaling WebSockets with Redis pub/sub
import Redis from 'ioredis';
 
const publisher = new Redis(process.env.REDIS_URL);
const subscriber = new Redis(process.env.REDIS_URL);
 
// When a message needs to reach users on other server instances
async function publishMessage(channel: string, message: object) {
  await publisher.publish(channel, JSON.stringify(message));
}
 
// Each server instance subscribes to relevant channels
subscriber.subscribe('chat:*', 'notifications:*');
subscriber.on('message', (channel, data) => {
  const message = JSON.parse(data);
  // Deliver to locally connected clients
  const localClients = getLocalClientsForChannel(channel);
  localClients.forEach(ws => ws.send(data));
});

// Decision helper - not actual code, but a useful mental model
function chooseRealTimeTransport(requirements: Requirements): Transport {
  // Does the client need to send real-time data to the server?
  if (requirements.bidirectional) {
    // Is it high-frequency like gaming or collaborative editing?
    if (requirements.lowLatency && requirements.highFrequency) {
      return 'WebSocket';
    }
    // Can client-to-server use regular HTTP POST?
    if (requirements.clientToServerIsInfrequent) {
      return 'SSE + HTTP POST'; // Best of both worlds
    }
    return 'WebSocket';
  }
 
  // Server-to-client only
  if (requirements.updateFrequency === 'continuous') {
    return 'SSE'; // Live feeds, dashboards, logs
  }
 
  if (requirements.updateFrequency === 'periodic') {
    if (requirements.intervalSeconds > 30) {
      return 'Short Polling'; // Simple and effective
    }
    return 'SSE'; // More efficient than rapid polling
  }
 
  return 'Short Polling'; // Simplest option for rare updates
}