┌─────────────────────────────────────────────────────────────┐
│                WebSocket Load Balancer                     │
│  • Sticky Sessions (User Affinity)                         │
│  • Health Checks & Failover                                │
│  • Geographic Routing                                      │
└─────────────────────┬───────────────────────────────────────┘
                      │
        ┌─────────────┼─────────────┐
        │             │             │
        ▼             ▼             ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ WebSocket   │ │ WebSocket   │ │ WebSocket   │
│ Server 1    │ │ Server 2    │ │ Server 3    │
│ (50K conn)  │ │ (50K conn)  │ │ (50K conn)  │
└─────────────┘ └─────────────┘ └─────────────┘

class WebSocketScaler {
    constructor() {
        this.maxConnectionsPerServer = 50000;
        this.servers = new Map();
        this.connectionDistributor = new ConnectionDistributor();
    }
    
    async scaleConnections() {
        const totalConnections = this.getTotalConnections();
        const requiredServers = Math.ceil(totalConnections / this.maxConnectionsPerServer);
        const currentServers = this.servers.size;
        
        if (requiredServers > currentServers) {
            // Scale up
            for (let i = 0; i < requiredServers - currentServers; i++) {
                await this.addWebSocketServer();
            }
        } else if (requiredServers < currentServers * 0.7) {
            // Scale down (with 30% buffer)
            const serversToRemove = currentServers - requiredServers;
            await this.removeWebSocketServers(serversToRemove);
        }
    }
    
    async routeConnection(userId, workspaceId) {
        // Use consistent hashing for user affinity
        const serverKey = this.hashUser(userId, workspaceId);
        let server = this.servers.get(serverKey);
        
        if (!server || server.connections >= this.maxConnectionsPerServer) {
            server = this.findLeastLoadedServer();
        }
        
        return server;
    }
}

┌─────────────┐    Publish    ┌─────────────┐    Subscribe   ┌─────────────┐
│   Message   │──────────────►│    Redis    │──────────────►│ WebSocket   │
│   Service   │               │   Pub/Sub   │               │  Servers    │
└─────────────┘               └─────────────┘               └─────────────┘
                                     │
                              ┌─────────────┐
                              │   Kafka     │
                              │ (Persistent)│
                              └─────────────┘

class MessageBroadcaster {
    constructor() {
        this.redisPublisher = new RedisPublisher();
        this.kafkaProducer = new KafkaProducer();
        this.channelSubscriptions = new Map();
    }
    
    async broadcastMessage(message, channelId, workspaceId) {
        // Get channel members efficiently
        const members = await this.getChannelMembers(channelId);
        
        // Batch members by server for efficient broadcasting
        const serverBatches = this.groupMembersByServer(members);
        
        // Publish to Redis for real-time delivery
        await this.redisPublisher.publish(`channel:${channelId}`, {
            type: 'message',
            data: message,
            members: members
        });
        
        // Publish to Kafka for persistence and offline users
        await this.kafkaProducer.send({
            topic: `workspace-${workspaceId}`,
            key: channelId,
            value: JSON.stringify({
                type: 'message',
                message: message,
                timestamp: Date.now()
            })
        });
        
        // Send push notifications to offline users
        const offlineUsers = await this.getOfflineUsers(members);
        await this.sendPushNotifications(offlineUsers, message);
    }
    
    groupMembersByServer(members) {
        const batches = new Map();
        
        members.forEach(memberId => {
            const serverId = this.getUserServer(memberId);
            if (!batches.has(serverId)) {
                batches.set(serverId, []);
            }
            batches.get(serverId).push(memberId);
        });
        
        return batches;
    }
}

# PostgreSQL Read Replicas
Master (Write):
  - All INSERT, UPDATE, DELETE operations
  - Message creation, user updates
  - Channel management, file uploads

Read Replicas (5x):
  - Message history queries
  - User profile lookups
  - Channel member lists
  - Search queries
  - Analytics queries

# Connection Routing
Write Operations: → Master
Read Operations: → Read Replicas (Round Robin)

class DatabaseSharding {
    constructor() {
        this.shards = {
            'shard_0': { workspaces: [], connection: 'db-shard-0' },
            'shard_1': { workspaces: [], connection: 'db-shard-1' },
            'shard_2': { workspaces: [], connection: 'db-shard-2' },
            'shard_3': { workspaces: [], connection: 'db-shard-3' }
        };
    }
    
    getShardForWorkspace(workspaceId) {
        // Consistent hashing based on workspace ID
        const hash = this.hashWorkspace(workspaceId);
        const shardIndex = hash % Object.keys(this.shards).length;
        return `shard_${shardIndex}`;
    }
    
    async rebalanceShards() {
        // Monitor shard sizes and rebalance when needed
        const shardSizes = await this.getShardSizes();
        const avgSize = shardSizes.reduce((a, b) => a + b, 0) / shardSizes.length;
        
        for (const [shardId, size] of Object.entries(shardSizes)) {
            if (size > avgSize * 1.5) {
                await this.rebalanceShard(shardId);
            }
        }
    }
}

class SearchIndexManager {
    constructor() {
        this.elasticsearch = new ElasticsearchClient();
        this.indexStrategy = 'workspace-based'; // or 'time-based'
    }
    
    async createWorkspaceIndex(workspaceId) {
        const indexName = `messages_workspace_${workspaceId}`;
        
        // Large workspaces get dedicated indices
        if (await this.isLargeWorkspace(workspaceId)) {
            await this.elasticsearch.indices.create({
                index: indexName,
                body: {
                    settings: {
                        number_of_shards: 5,
                        number_of_replicas: 1,
                        refresh_interval: '5s'
                    },
                    mappings: this.getMessageMappings()
                }
            });
        } else {
            // Small workspaces share indices
            const sharedIndex = this.getSharedIndex(workspaceId);
            return sharedIndex;
        }
        
        return indexName;
    }
    
    async optimizeIndices() {
        // Merge segments for better search performance
        const indices = await this.elasticsearch.cat.indices({ format: 'json' });
        
        for (const index of indices) {
            if (index['docs.count'] > 1000000) {
                await this.elasticsearch.indices.forcemerge({
                    index: index.index,
                    max_num_segments: 1
                });
            }
        }
    }
}

class FileStorageManager {
    constructor() {
        this.providers = {
            primary: new S3StorageProvider('us-east-1'),
            secondary: new GCSStorageProvider('us-central1'),
            cdn: new CloudFrontProvider()
        };
        this.replicationStrategy = 'cross-cloud';
    }
    
    async uploadFile(file, workspaceId) {
        const fileId = this.generateFileId();
        const storagePath = this.generatePath(workspaceId, fileId);
        
        // Upload to primary storage
        const primaryUpload = this.providers.primary.upload(storagePath, file);
        
        // Async replication to secondary storage
        const secondaryUpload = this.providers.secondary.upload(storagePath, file);
        
        // Wait for primary, continue with secondary in background
        await primaryUpload;
        secondaryUpload.catch(err => this.handleReplicationError(err));
        
        // Generate CDN URLs for global distribution
        const cdnUrl = await this.providers.cdn.generateUrl(storagePath);
        
        return {
            fileId: fileId,
            primaryUrl: primaryUpload.url,
            cdnUrl: cdnUrl,
            storagePath: storagePath
        };
    }
    
    async optimizeStorageCosts() {
        // Move old files to cheaper storage tiers
        const oldFiles = await this.getFilesOlderThan(90); // 90 days
        
        for (const file of oldFiles) {
            if (file.accessCount < 5) {
                // Move to cold storage
                await this.moveToTier(file, 'GLACIER');
            } else if (file.accessCount < 20) {
                // Move to warm storage
                await this.moveToTier(file, 'STANDARD_IA');
            }
        }
    }
}

# Message Service Auto-scaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: message-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: message-service
  minReplicas: 10
  maxReplicas: 100
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Pods
    pods:
      metric:
        name: messages_per_second
      target:
        type: AverageValue
        averageValue: "1000"

---
# WebSocket Service Auto-scaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: websocket-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: websocket-service
  minReplicas: 5
  maxReplicas: 50
  metrics:
  - type: Pods
    pods:
      metric:
        name: websocket_connections
      target:
        type: AverageValue
        averageValue: "40000"  # Scale when >40K connections per pod

class PredictiveScaler {
    constructor() {
        this.historicalData = new HistoricalDataService();
        this.mlModel = new ScalingPredictionModel();
    }
    
    async predictAndScale() {
        // Get historical usage patterns
        const patterns = await this.historicalData.getUsagePatterns(30); // 30 days
        
        // Predict next hour's load
        const prediction = await this.mlModel.predict({
            hour: new Date().getHours(),
            dayOfWeek: new Date().getDay(),
            historicalAverage: patterns.averageLoad,
            trend: patterns.trend
        });
        
        // Pre-scale infrastructure 15 minutes before predicted peak
        if (prediction.confidence > 0.8) {
            await this.scheduleScaling(prediction.expectedLoad, 15); // 15 min ahead
        }
    }
    
    async scheduleScaling(expectedLoad, minutesAhead) {
        const requiredInstances = Math.ceil(expectedLoad / this.instanceCapacity);
        const currentInstances = await this.getCurrentInstanceCount();
        
        if (requiredInstances > currentInstances) {
            setTimeout(async () => {
                await this.scaleUp(requiredInstances - currentInstances);
            }, minutesAhead * 60 * 1000);
        }
    }
}

class CacheOptimizer {
    constructor() {
        this.l1Cache = new LRUCache({ max: 10000, ttl: 300000 }); // 5 min
        this.l2Cache = new RedisCluster();
        this.l3Cache = new CDNCache();
        
        this.cacheStrategies = {
            'user_profile': { ttl: 3600, levels: ['l1', 'l2'] },
            'channel_members': { ttl: 1800, levels: ['l1', 'l2'] },
            'recent_messages': { ttl: 300, levels: ['l1', 'l2'] },
            'file_metadata': { ttl: 7200, levels: ['l1', 'l2', 'l3'] }
        };
    }
    
    async get(key, type = 'default') {
        const strategy = this.cacheStrategies[type] || { levels: ['l1', 'l2'] };
        
        // Try each cache level in order
        for (const level of strategy.levels) {
            const cache = this[level + 'Cache'];
            const value = await cache.get(key);
            
            if (value) {
                // Populate higher-level caches
                await this.populateHigherLevels(key, value, level, strategy.levels);
                return value;
            }
        }
        
        return null;
    }
    
    async optimizeCacheUsage() {
        // Analyze cache hit rates and adjust strategies
        const stats = await this.getCacheStats();
        
        for (const [type, strategy] of Object.entries(this.cacheStrategies)) {
            const hitRate = stats[type]?.hitRate || 0;
            
            if (hitRate < 0.7) {
                // Increase TTL for low hit rate items
                strategy.ttl *= 1.5;
            } else if (hitRate > 0.95) {
                // Decrease TTL for very high hit rate items (save memory)
                strategy.ttl *= 0.8;
            }
        }
    }
}

class PerformanceMonitor {
    constructor() {
        this.metricsCollector = new PrometheusMetrics();
        this.alertManager = new AlertManager();
    }
    
    collectMetrics() {
        // WebSocket metrics
        this.metricsCollector.gauge('websocket_connections_active')
            .set(this.getActiveConnections());
        
        // Message throughput
        this.metricsCollector.counter('messages_sent_total')
            .inc();
        
        // Database performance
        this.metricsCollector.histogram('database_query_duration_seconds')
            .observe(queryDuration);
        
        // Cache performance
        this.metricsCollector.gauge('cache_hit_rate')
            .set(this.getCacheHitRate());
        
        // File upload metrics
        this.metricsCollector.histogram('file_upload_duration_seconds')
            .observe(uploadDuration);
    }
    
    async checkPerformanceThresholds() {
        const metrics = await this.getCurrentMetrics();
        
        // Alert on high latency
        if (metrics.messageLatencyP95 > 500) {
            await this.alertManager.sendAlert({
                severity: 'warning',
                message: 'High message latency detected',
                value: metrics.messageLatencyP95
            });
        }
        
        // Alert on low cache hit rate
        if (metrics.cacheHitRate < 0.8) {
            await this.alertManager.sendAlert({
                severity: 'info',
                message: 'Low cache hit rate',
                value: metrics.cacheHitRate
            });
        }
    }
}

class CostOptimizer {
    constructor() {
        this.usageAnalyzer = new UsageAnalyzer();
        this.costCalculator = new CostCalculator();
    }
    
    async optimizeInfrastructureCosts() {
        const usage = await this.usageAnalyzer.getUsagePatterns(30); // 30 days
        const recommendations = [];
        
        // Analyze compute resources
        for (const service of usage.services) {
            if (service.avgCpuUtilization < 30) {
                recommendations.push({
                    type: 'downsize',
                    service: service.name,
                    currentSize: service.instanceType,
                    recommendedSize: this.getSmallerInstance(service.instanceType),
                    monthlySavings: service.monthlyCost * 0.4
                });
            }
        }
        
        // Analyze storage costs
        const storageUsage = await this.analyzeStorageUsage();
        for (const bucket of storageUsage.buckets) {
            if (bucket.coldAccessPercentage > 80) {
                recommendations.push({
                    type: 'storage_tier',
                    bucket: bucket.name,
                    currentTier: 'STANDARD',
                    recommendedTier: 'GLACIER',
                    monthlySavings: bucket.monthlyCost * 0.7
                });
            }
        }
        
        return recommendations;
    }
}