Use Case                    | WebSocket | SSE    | Long Polling
---------------------------|-----------|--------|-------------
Real-time Chat            | ✅ Best   | ❌ No  | ⚠️ Fallback
Live Updates/Notifications | ✅ Good   | ✅ Best| ⚠️ Fallback
File Transfer             | ✅ Best   | ❌ No  | ❌ No
Gaming/Interactive        | ✅ Best   | ❌ No  | ❌ No
Simple Notifications      | ⚠️ Overkill| ✅ Best| ✅ Good
Corporate Environment     | ⚠️ Blocked | ✅ Works| ✅ Works

// Long polling client implementation
class LongPollingClient {
  constructor(endpoint) {
    this.endpoint = endpoint;
    this.isPolling = false;
    this.backoffDelay = 1000;
    this.maxBackoffDelay = 30000;
  }
  
  async startPolling() {
    this.isPolling = true;
    
    while (this.isPolling) {
      try {
        const response = await fetch(this.endpoint, {
          method: 'GET',
          headers: {
            'Authorization': `Bearer ${this.token}`,
            'Cache-Control': 'no-cache'
          },
          timeout: 30000 // 30 second timeout
        });
        
        if (response.ok) {
          const data = await response.json();
          this.handleMessages(data.messages);
          this.backoffDelay = 1000; // Reset backoff on success
        } else {
          throw new Error(`HTTP ${response.status}`);
        }
      } catch (error) {
        console.error('Long polling error:', error);
        await this.sleep(this.backoffDelay);
        this.backoffDelay = Math.min(this.backoffDelay * 2, this.maxBackoffDelay);
      }
    }
  }
  
  stopPolling() {
    this.isPolling = false;
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Long polling server endpoint
app.get('/api/v1/messages/poll', authenticateToken, async (req, res) => {
  const userId = req.user.id;
  const timeout = 30000; // 30 seconds
  const startTime = Date.now();
  
  // Set up timeout
  const timeoutId = setTimeout(() => {
    res.json({ messages: [], timeout: true });
  }, timeout);
  
  // Listen for new messages
  const messageListener = (message) => {
    if (message.recipientId === userId) {
      clearTimeout(timeoutId);
      res.json({ messages: [message] });
      messageEmitter.removeListener('newMessage', messageListener);
    }
  };
  
  messageEmitter.on('newMessage', messageListener);
  
  // Clean up on client disconnect
  req.on('close', () => {
    clearTimeout(timeoutId);
    messageEmitter.removeListener('newMessage', messageListener);
  });
});

// HTTP/2 Server Push implementation
const http2 = require('http2');
const fs = require('fs');

const server = http2.createSecureServer({
  key: fs.readFileSync('private-key.pem'),
  cert: fs.readFileSync('certificate.pem')
});

server.on('stream', (stream, headers) => {
  if (headers[':path'] === '/api/messages/stream') {
    // Authenticate user
    const userId = authenticateFromHeaders(headers);
    
    // Set up message streaming
    const messageHandler = (message) => {
      if (message.recipientId === userId) {
        stream.respond({
          ':status': 200,
          'content-type': 'application/json'
        });
        stream.write(JSON.stringify(message));
      }
    };
    
    messageEmitter.on('newMessage', messageHandler);
    
    stream.on('close', () => {
      messageEmitter.removeListener('newMessage', messageHandler);
    });
  }
});

// Strong ordering with sequence numbers
class StrongOrderingMessageQueue {
  constructor() {
    this.conversationQueues = new Map();
    this.sequenceNumbers = new Map();
  }
  
  async sendMessage(conversationId, message) {
    // Get next sequence number for conversation
    const currentSeq = this.sequenceNumbers.get(conversationId) || 0;
    const nextSeq = currentSeq + 1;
    this.sequenceNumbers.set(conversationId, nextSeq);
    
    // Add sequence number to message
    message.sequenceNumber = nextSeq;
    message.conversationId = conversationId;
    
    // Process messages in order
    const queue = this.getOrCreateQueue(conversationId);
    await queue.add(message);
    
    return message;
  }
  
  getOrCreateQueue(conversationId) {
    if (!this.conversationQueues.has(conversationId)) {
      const queue = new Queue(`conversation-${conversationId}`, {
        redis: redisConnection,
        defaultJobOptions: {
          removeOnComplete: 100,
          removeOnFail: 50
        }
      });
      
      // Process messages sequentially
      queue.process(1, async (job) => {
        await this.processMessage(job.data);
      });
      
      this.conversationQueues.set(conversationId, queue);
    }
    
    return this.conversationQueues.get(conversationId);
  }
}

// Vector clock implementation for causal ordering
class VectorClock {
  constructor(nodeId) {
    this.nodeId = nodeId;
    this.clock = new Map();
    this.clock.set(nodeId, 0);
  }
  
  tick() {
    const current = this.clock.get(this.nodeId) || 0;
    this.clock.set(this.nodeId, current + 1);
    return this.getClock();
  }
  
  update(otherClock) {
    for (const [nodeId, timestamp] of otherClock.entries()) {
      const currentTime = this.clock.get(nodeId) || 0;
      this.clock.set(nodeId, Math.max(currentTime, timestamp));
    }
    
    // Increment own clock
    this.tick();
  }
  
  getClock() {
    return new Map(this.clock);
  }
  
  compare(otherClock) {
    let thisGreater = false;
    let otherGreater = false;
    
    const allNodes = new Set([...this.clock.keys(), ...otherClock.keys()]);
    
    for (const nodeId of allNodes) {
      const thisTime = this.clock.get(nodeId) || 0;
      const otherTime = otherClock.get(nodeId) || 0;
      
      if (thisTime > otherTime) thisGreater = true;
      if (otherTime > thisTime) otherGreater = true;
    }
    
    if (thisGreater && !otherGreater) return 1;  // This is greater
    if (otherGreater && !thisGreater) return -1; // Other is greater
    if (!thisGreater && !otherGreater) return 0; // Equal
    return null; // Concurrent/incomparable
  }
}

// Message with vector clock
class CausalMessage {
  constructor(content, senderId, vectorClock) {
    this.id = generateUUID();
    this.content = content;
    this.senderId = senderId;
    this.vectorClock = vectorClock;
    this.timestamp = Date.now();
  }
}

Consistency Level    | Throughput | Latency | Complexity | Use Case
--------------------|------------|---------|------------|----------
Strong Consistency  | Low        | High    | High       | Financial
Sequential          | Medium     | Medium  | Medium     | Chat
Causal             | High       | Low     | Medium     | Social
Eventual           | Highest    | Lowest  | Low        | Analytics

-- ACID transaction example
BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;

-- Atomicity: All operations succeed or fail together
INSERT INTO conversations (title, created_by) 
VALUES ('New Group', 123456);

INSERT INTO conversation_participants (conversation_id, user_id, role)
VALUES (currval('conversations_conversation_id_seq'), 123456, 'admin'),
       (currval('conversations_conversation_id_seq'), 789012, 'member');

-- Consistency: Database remains in valid state
-- Isolation: Concurrent transactions don't interfere
-- Durability: Changes persist after commit

COMMIT;

-- BASE: Basically Available, Soft state, Eventual consistency
-- Write to multiple replicas with eventual consistency

-- Write message to Cassandra
INSERT INTO messages (conversation_id, message_id, sender_id, content, created_at)
VALUES (1001, now(), 123456, 'Hello world', toTimestamp(now()))
USING TTL 2592000; -- 30 days TTL

-- Read with eventual consistency
SELECT * FROM messages 
WHERE conversation_id = 1001 
ORDER BY message_id DESC 
LIMIT 50;

Partition Tolerance Required (Distributed System)
Choose: Consistency OR Availability

Consistency + Partition Tolerance (CP):
- Strong consistency during network partitions
- May become unavailable during partitions
- Example: Traditional RDBMS with synchronous replication

Availability + Partition Tolerance (AP):
- Always available, even during partitions
- May serve stale data during partitions
- Example: Cassandra, DynamoDB with eventual consistency

// Hybrid consistency model
class HybridConsistencyManager {
  constructor() {
    this.strongConsistencyStore = new PostgreSQLClient();
    this.eventualConsistencyStore = new CassandraClient();
    this.cacheStore = new RedisClient();
  }
  
  async sendMessage(message) {
    try {
      // 1. Write to cache for immediate availability
      await this.cacheStore.lpush(
        `conversation:${message.conversationId}:messages`,
        JSON.stringify(message)
      );
      
      // 2. Write to eventual consistency store (high availability)
      await this.eventualConsistencyStore.insert('messages', message);
      
      // 3. Update conversation metadata with strong consistency
      await this.strongConsistencyStore.query(
        'UPDATE conversations SET last_message_at = $1, message_count = message_count + 1 WHERE conversation_id = $2',
        [message.createdAt, message.conversationId]
      );
      
      return { success: true, messageId: message.id };
    } catch (error) {
      // Rollback cache if database writes fail
      await this.cacheStore.lrem(
        `conversation:${message.conversationId}:messages`,
        1,
        JSON.stringify(message)
      );
      throw error;
    }
  }
}

// Push notification service
class PushNotificationService {
  constructor() {
    this.apnsClient = new apn.Provider(apnsConfig);
    this.fcmClient = new FCM(fcmConfig);
    this.webPushClient = new WebPush(webPushConfig);
  }
  
  async sendNotification(userId, message) {
    const userDevices = await this.getUserDevices(userId);
    const promises = [];
    
    for (const device of userDevices) {
      switch (device.platform) {
        case 'ios':
          promises.push(this.sendAPNS(device, message));
          break;
        case 'android':
          promises.push(this.sendFCM(device, message));
          break;
        case 'web':
          promises.push(this.sendWebPush(device, message));
          break;
      }
    }
    
    const results = await Promise.allSettled(promises);
    return this.processResults(results);
  }
  
  async sendAPNS(device, message) {
    const notification = new apn.Notification({
      alert: {
        title: message.senderName,
        body: message.content
      },
      badge: message.unreadCount,
      sound: 'default',
      payload: {
        conversationId: message.conversationId,
        messageId: message.messageId
      }
    });
    
    return this.apnsClient.send(notification, device.token);
  }
}

// Pull-based notification polling
class PullNotificationService {
  constructor() {
    this.notificationStore = new RedisClient();
    this.pollInterval = 30000; // 30 seconds
  }
  
  async addNotification(userId, notification) {
    const key = `notifications:${userId}`;
    await this.notificationStore.zadd(
      key,
      Date.now(),
      JSON.stringify(notification)
    );
    
    // Keep only last 100 notifications
    await this.notificationStore.zremrangebyrank(key, 0, -101);
  }
  
  async getNotifications(userId, since = 0) {
    const key = `notifications:${userId}`;
    const notifications = await this.notificationStore.zrangebyscore(
      key,
      since,
      '+inf',
      'WITHSCORES'
    );
    
    return notifications.map((item, index) => {
      if (index % 2 === 0) {
        return {
          data: JSON.parse(item),
          timestamp: notifications[index + 1]
        };
      }
    }).filter(Boolean);
  }
  
  // Client polling implementation
  async startPolling(userId, callback) {
    let lastTimestamp = Date.now();
    
    const poll = async () => {
      try {
        const notifications = await this.getNotifications(userId, lastTimestamp);
        
        if (notifications.length > 0) {
          callback(notifications);
          lastTimestamp = Math.max(...notifications.map(n => n.timestamp));
        }
      } catch (error) {
        console.error('Polling error:', error);
      }
      
      setTimeout(poll, this.pollInterval);
    };
    
    poll();
  }
}

// Hybrid notification system
class HybridNotificationService {
  constructor() {
    this.pushService = new PushNotificationService();
    this.pullService = new PullNotificationService();
    this.deliveryTracker = new Map();
  }
  
  async sendNotification(userId, notification) {
    // Always store for pull-based access
    await this.pullService.addNotification(userId, notification);
    
    // Try push notification first
    try {
      const pushResult = await this.pushService.sendNotification(userId, notification);
      
      if (pushResult.success) {
        // Track successful push delivery
        this.deliveryTracker.set(notification.id, {
          method: 'push',
          deliveredAt: Date.now()
        });
        return { method: 'push', success: true };
      }
    } catch (error) {
      console.warn('Push notification failed, falling back to pull:', error);
    }
    
    // Fallback to pull-based notification
    return { method: 'pull', success: true };
  }
  
  async getUndeliveredNotifications(userId) {
    // Get notifications that weren't successfully pushed
    const allNotifications = await this.pullService.getNotifications(userId);
    
    return allNotifications.filter(notification => {
      const delivery = this.deliveryTracker.get(notification.data.id);
      return !delivery || delivery.method !== 'push';
    });
  }
}

Requirement           | PostgreSQL | Cassandra | MongoDB | Redis
---------------------|------------|-----------|---------|-------
ACID Transactions    | ✅ Full    | ❌ No     | ⚠️ Limited| ❌ No
Horizontal Scaling   | ⚠️ Limited | ✅ Excellent| ✅ Good | ✅ Good
Query Flexibility    | ✅ SQL     | ⚠️ Limited | ✅ Rich | ⚠️ Limited
Consistency          | ✅ Strong  | ⚠️ Eventual| ⚠️ Tunable| ✅ Strong
Performance (Reads)  | ✅ Good    | ✅ Excellent| ✅ Good | ✅ Excellent
Performance (Writes) | ⚠️ Good    | ✅ Excellent| ✅ Good | ✅ Excellent
Operational Complexity| ✅ Low    | ⚠️ Medium  | ✅ Low  | ✅ Low

// Multi-database architecture
class MessengerDataLayer {
  constructor() {
    // User data and relationships (ACID required)
    this.userStore = new PostgreSQLClient();
    
    // Message storage (high write volume)
    this.messageStore = new CassandraClient();
    
    // Real-time data and caching
    this.cacheStore = new RedisClient();
    
    // Search and analytics
    this.searchStore = new ElasticsearchClient();
    
    // Media metadata (flexible schema)
    this.mediaStore = new MongoDBClient();
  }
  
  async createUser(userData) {
    // Use PostgreSQL for user data (ACID compliance)
    return this.userStore.insert('users', userData);
  }
  
  async storeMessage(message) {
    // Use Cassandra for high-volume message storage
    return this.messageStore.insert('messages', message);
  }
  
  async cacheRecentMessages(conversationId, messages) {
    // Use Redis for fast access to recent messages
    const key = `conversation:${conversationId}:recent`;
    return this.cacheStore.lpush(key, ...messages.map(JSON.stringify));
  }
  
  async indexMessageForSearch(message) {
    // Use Elasticsearch for full-text search
    return this.searchStore.index('messages', message.id, {
      content: message.content,
      conversationId: message.conversationId,
      senderId: message.senderId,
      timestamp: message.createdAt
    });
  }
  
  async storeMediaMetadata(mediaData) {
    // Use MongoDB for flexible media metadata
    return this.mediaStore.insertOne('media', mediaData);
  }
}

// Modular monolith structure
class MessengerApplication {
  constructor() {
    // Core modules with clear boundaries
    this.userModule = new UserModule();
    this.messageModule = new MessageModule();
    this.notificationModule = new NotificationModule();
    this.presenceModule = new PresenceModule();
    
    // Shared infrastructure
    this.eventBus = new EventBus();
    this.database = new DatabaseConnection();
    this.cache = new CacheConnection();
    
    this.setupEventHandlers();
  }
  
  setupEventHandlers() {
    // Loose coupling through events
    this.eventBus.on('message.sent', (event) => {
      this.notificationModule.handleNewMessage(event);
      this.presenceModule.updateLastActivity(event.senderId);
    });
    
    this.eventBus.on('user.online', (event) => {
      this.notificationModule.deliverPendingNotifications(event.userId);
    });
  }
}

// Module interface
class MessageModule {
  constructor(database, cache, eventBus) {
    this.database = database;
    this.cache = cache;
    this.eventBus = eventBus;
  }
  
  async sendMessage(message) {
    // Business logic
    const savedMessage = await this.database.saveMessage(message);
    await this.cache.cacheMessage(savedMessage);
    
    // Emit event for other modules
    this.eventBus.emit('message.sent', {
      messageId: savedMessage.id,
      senderId: savedMessage.senderId,
      conversationId: savedMessage.conversationId
    });
    
    return savedMessage;
  }
}