class WebSocketScalingArchitecture:
    def __init__(self):
        self.max_connections_per_server = 50000
        self.target_cpu_utilization = 70
        self.memory_per_connection = 8  # KB
        
    def calculate_server_requirements(self, peak_concurrent_users):
        """
        Calculate server requirements for WebSocket connections
        """
        # Account for connection overhead and safety margin
        effective_connections_per_server = int(
            self.max_connections_per_server * 0.8  # 80% utilization
        )
        
        required_servers = math.ceil(
            peak_concurrent_users / effective_connections_per_server
        )
        
        # Memory requirements
        memory_per_server_gb = (
            self.max_connections_per_server * 
            self.memory_per_connection / (1024 * 1024)
        )
        
        return {
            'required_servers': required_servers,
            'connections_per_server': effective_connections_per_server,
            'memory_per_server_gb': memory_per_server_gb,
            'total_memory_gb': memory_per_server_gb * required_servers,
            'safety_margin_servers': int(required_servers * 0.2)
        }
    
    def implement_connection_load_balancing(self):
        """
        Load balancing strategy for WebSocket connections
        """
        load_balancing_config = {
            'algorithm': 'consistent_hashing',
            'hash_key': 'event_id',  # Event-based affinity
            'health_check': {
                'interval_seconds': 10,
                'timeout_seconds': 5,
                'failure_threshold': 3
            },
            'sticky_sessions': {
                'enabled': True,
                'session_key': 'user_id',
                'fallback_strategy': 'least_connections'
            },
            'auto_scaling': {
                'scale_up_threshold': 80,  # CPU percentage
                'scale_down_threshold': 30,
                'cooldown_period_minutes': 5
            }
        }
        return load_balancing_config

# Connection manager implementation
class DistributedConnectionManager:
    def __init__(self, redis_client, consul_client):
        self.redis = redis_client
        self.consul = consul_client
        self.server_id = self._generate_server_id()
        
    def register_server(self):
        """
        Register WebSocket server in service discovery
        """
        server_info = {
            'server_id': self.server_id,
            'host': self._get_server_host(),
            'port': self._get_server_port(),
            'max_connections': 50000,
            'current_connections': 0,
            'cpu_usage': 0,
            'memory_usage': 0,
            'status': 'healthy',
            'last_heartbeat': time.time()
        }
        
        # Register in Consul
        self.consul.agent.service.register(
            name='websocket-server',
            service_id=self.server_id,
            address=server_info['host'],
            port=server_info['port'],
            tags=['websocket', 'live-comments'],
            check=consul.Check.http(
                f"http://{server_info['host']}:{server_info['port']}/health",
                interval="10s"
            )
        )
        
        # Store detailed info in Redis
        self.redis.hset(
            f"server:{self.server_id}",
            mapping=server_info
        )
        self.redis.expire(f"server:{self.server_id}", 60)
        
    def distribute_connection(self, user_id, event_id):
        """
        Distribute new connection to optimal server
        """
        # Get available servers
        servers = self._get_healthy_servers()
        
        # Use consistent hashing for event affinity
        event_hash = hashlib.md5(event_id.encode()).hexdigest()
        server_index = int(event_hash, 16) % len(servers)
        
        primary_server = servers[server_index]
        
        # Check server capacity
        if self._is_server_overloaded(primary_server):
            # Find least loaded server
            primary_server = min(servers, key=lambda s: s['current_connections'])
        
        return primary_server
    
    def handle_server_failure(self, failed_server_id):
        """
        Handle WebSocket server failure and connection redistribution
        """
        # Get connections from failed server
        failed_connections = self.redis.smembers(
            f"server:{failed_server_id}:connections"
        )
        
        # Redistribute connections
        healthy_servers = self._get_healthy_servers()
        
        redistribution_tasks = []
        for connection_id in failed_connections:
            # Get connection details
            connection_info = self.redis.hgetall(f"connection:{connection_id}")
            
            # Find new server
            new_server = self.distribute_connection(
                connection_info['user_id'],
                connection_info['event_id']
            )
            
            # Create reconnection task
            task = self._create_reconnection_task(connection_info, new_server)
            redistribution_tasks.append(task)
        
        # Execute redistribution
        return asyncio.gather(*redistribution_tasks)

# WebSocket server deployment with HPA
apiVersion: apps/v1
kind: Deployment
metadata:
  name: websocket-servers
spec:
  replicas: 10
  selector:
    matchLabels:
      app: websocket-server
  template:
    metadata:
      labels:
        app: websocket-server
    spec:
      containers:
      - name: websocket-server
        image: live-comments/websocket-server:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            memory: "8Gi"
            cpu: "4"
        env:
        - name: MAX_CONNECTIONS
          value: "50000"
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-credentials
              key: url
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: websocket-server-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: websocket-servers
  minReplicas: 10
  maxReplicas: 1000
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  - type: Pods
    pods:
      metric:
        name: websocket_connections_per_pod
      target:
        type: AverageValue
        averageValue: "40000"
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 100
        periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

class KafkaScalingConfiguration:
    def __init__(self):
        self.target_throughput = 1_000_000  # messages per second
        self.message_size_avg = 500  # bytes
        
    def calculate_kafka_cluster_size(self):
        """
        Calculate Kafka cluster requirements
        """
        # Throughput calculations
        target_bandwidth_mbps = (
            self.target_throughput * 
            self.message_size_avg * 8 / (1024 * 1024)
        )
        
        # Kafka broker capacity (conservative estimate)
        broker_throughput_mbps = 100  # MB/s per broker
        broker_message_capacity = 200_000  # messages/s per broker
        
        required_brokers_bandwidth = math.ceil(
            target_bandwidth_mbps / broker_throughput_mbps
        )
        required_brokers_messages = math.ceil(
            self.target_throughput / broker_message_capacity
        )
        
        required_brokers = max(required_brokers_bandwidth, required_brokers_messages)
        
        return {
            'required_brokers': required_brokers,
            'target_bandwidth_mbps': target_bandwidth_mbps,
            'broker_throughput_mbps': broker_throughput_mbps,
            'replication_factor': 3,
            'total_brokers_with_replication': required_brokers * 3
        }
    
    def configure_kafka_topics(self):
        """
        Kafka topic configuration for optimal performance
        """
        topic_configs = {
            'comment_events': {
                'partitions': 100,
                'replication_factor': 3,
                'min_in_sync_replicas': 2,
                'retention_ms': 86400000,  # 24 hours
                'segment_ms': 3600000,     # 1 hour segments
                'compression_type': 'snappy',
                'batch_size': 65536,       # 64KB batches
                'linger_ms': 5,            # 5ms batching delay
                'acks': 1                  # Leader acknowledgment only
            },
            'moderation_events': {
                'partitions': 20,
                'replication_factor': 3,
                'min_in_sync_replicas': 2,
                'retention_ms': 604800000,  # 7 days
                'compression_type': 'gzip',
                'acks': 'all'              # Full acknowledgment for reliability
            },
            'analytics_events': {
                'partitions': 50,
                'replication_factor': 2,
                'min_in_sync_replicas': 1,
                'retention_ms': 2592000000,  # 30 days
                'compression_type': 'lz4',
                'acks': 0                   # No acknowledgment for speed
            }
        }
        return topic_configs
    
    def implement_producer_optimization(self):
        """
        Kafka producer optimization for high throughput
        """
        producer_config = {
            'bootstrap_servers': ['kafka1:9092', 'kafka2:9092', 'kafka3:9092'],
            'acks': 1,
            'retries': 3,
            'batch_size': 65536,        # 64KB
            'linger_ms': 5,             # 5ms batching
            'buffer_memory': 67108864,  # 64MB
            'compression_type': 'snappy',
            'max_in_flight_requests_per_connection': 5,
            'enable_idempotence': True,
            'request_timeout_ms': 30000,
            'delivery_timeout_ms': 120000
        }
        return producer_config

# Kafka consumer scaling
class KafkaConsumerScaling:
    def __init__(self, topic_name, consumer_group):
        self.topic_name = topic_name
        self.consumer_group = consumer_group
        
    def implement_parallel_processing(self):
        """
        Implement parallel consumer processing
        """
        consumer_config = {
            'bootstrap_servers': ['kafka1:9092', 'kafka2:9092', 'kafka3:9092'],
            'group_id': self.consumer_group,
            'auto_offset_reset': 'latest',
            'enable_auto_commit': False,
            'max_poll_records': 1000,
            'fetch_min_bytes': 50000,      # 50KB minimum fetch
            'fetch_max_wait_ms': 500,      # 500ms max wait
            'session_timeout_ms': 30000,
            'heartbeat_interval_ms': 3000,
            'max_poll_interval_ms': 300000  # 5 minutes
        }
        
        # Processing pipeline
        processing_pipeline = {
            'consumer_threads': 16,         # Parallel consumers
            'processing_threads': 32,       # Processing workers
            'batch_processing': True,
            'batch_size': 100,
            'processing_timeout': 30,       # seconds
            'error_handling': 'dead_letter_queue',
            'retry_policy': {
                'max_retries': 3,
                'backoff_multiplier': 2,
                'initial_delay_ms': 1000
            }
        }
        
        return consumer_config, processing_pipeline

class CassandraScalingStrategy:
    def __init__(self):
        self.target_write_throughput = 500_000  # writes per second
        self.target_read_throughput = 5_000_000  # reads per second
        
    def calculate_cluster_requirements(self):
        """
        Calculate Cassandra cluster size requirements
        """
        # Conservative estimates for Cassandra performance
        writes_per_node = 10_000   # writes/second per node
        reads_per_node = 50_000    # reads/second per node
        
        # Calculate required nodes
        write_nodes_required = math.ceil(
            self.target_write_throughput / writes_per_node
        )
        read_nodes_required = math.ceil(
            self.target_read_throughput / reads_per_node
        )
        
        base_nodes_required = max(write_nodes_required, read_nodes_required)
        
        # Multi-datacenter distribution
        datacenters = {
            'us-east': {
                'nodes': base_nodes_required,
                'replication_factor': 3
            },
            'us-west': {
                'nodes': base_nodes_required,
                'replication_factor': 3
            },
            'eu-west': {
                'nodes': int(base_nodes_required * 0.5),
                'replication_factor': 2
            }
        }
        
        total_nodes = sum(dc['nodes'] for dc in datacenters.values())
        
        return {
            'base_nodes_per_dc': base_nodes_required,
            'datacenters': datacenters,
            'total_nodes': total_nodes,
            'storage_per_node_tb': 2,  # 2TB per node
            'memory_per_node_gb': 64   # 64GB RAM per node
        }
    
    def implement_data_partitioning(self):
        """
        Implement optimal data partitioning strategy
        """
        partitioning_strategy = {
            'partition_key': 'event_id',
            'clustering_keys': ['comment_time', 'comment_id'],
            'partition_size_target': 100_000_000,  # 100MB per partition
            'time_window_hours': 1,
            'compaction_strategy': {
                'class': 'TimeWindowCompactionStrategy',
                'compaction_window_unit': 'HOURS',
                'compaction_window_size': 1,
                'max_threshold': 32,
                'min_threshold': 4
            },
            'compression': {
                'chunk_length_in_kb': 64,
                'compression_algorithm': 'LZ4Compressor'
            }
        }
        return partitioning_strategy

# Cassandra connection pooling
class CassandraConnectionPool:
    def __init__(self):
        self.cluster_config = self._configure_cluster()
        
    def _configure_cluster(self):
        """
        Configure Cassandra cluster connection
        """
        from cassandra.cluster import Cluster
        from cassandra.policies import DCAwareRoundRobinPolicy, TokenAwarePolicy
        from cassandra.pool import HostDistance
        
        # Load balancing policy
        load_balancing_policy = TokenAwarePolicy(
            DCAwareRoundRobinPolicy(local_dc='us-east')
        )
        
        cluster = Cluster(
            contact_points=['cassandra1', 'cassandra2', 'cassandra3'],
            load_balancing_policy=load_balancing_policy,
            default_retry_policy=RetryPolicy(),
            compression=True,
            protocol_version=4,
            port=9042
        )
        
        # Connection pool settings
        cluster.set_core_connections_per_host(HostDistance.LOCAL, 4)
        cluster.set_max_connections_per_host(HostDistance.LOCAL, 8)
        cluster.set_core_connections_per_host(HostDistance.REMOTE, 2)
        cluster.set_max_connections_per_host(HostDistance.REMOTE, 4)
        
        return cluster

class RedisClusterScaling:
    def __init__(self):
        self.target_operations_per_second = 10_000_000
        self.memory_per_node_gb = 32
        
    def calculate_redis_cluster_size(self):
        """
        Calculate Redis cluster requirements
        """
        # Redis performance estimates
        operations_per_node = 100_000  # ops/second per node
        
        required_nodes = math.ceil(
            self.target_operations_per_second / operations_per_node
        )
        
        # Redis cluster requires minimum 6 nodes (3 masters + 3 replicas)
        min_nodes = 6
        cluster_nodes = max(required_nodes, min_nodes)
        
        # Ensure even number for master-replica pairs
        if cluster_nodes % 2 != 0:
            cluster_nodes += 1
            
        master_nodes = cluster_nodes // 2
        replica_nodes = cluster_nodes // 2
        
        return {
            'total_nodes': cluster_nodes,
            'master_nodes': master_nodes,
            'replica_nodes': replica_nodes,
            'memory_per_node_gb': self.memory_per_node_gb,
            'total_memory_gb': cluster_nodes * self.memory_per_node_gb,
            'hash_slots': 16384  # Redis cluster hash slots
        }
    
    def configure_redis_cluster(self):
        """
        Redis cluster configuration
        """
        cluster_config = {
            'cluster_enabled': True,
            'cluster_config_file': 'nodes.conf',
            'cluster_node_timeout': 15000,
            'cluster_announce_ip': '${REDIS_ANNOUNCE_IP}',
            'cluster_announce_port': 6379,
            'cluster_announce_bus_port': 16379,
            
            # Memory optimization
            'maxmemory_policy': 'allkeys-lru',
            'maxmemory': '30gb',
            'save': '',  # Disable RDB snapshots for performance
            
            # Network optimization
            'tcp_keepalive': 300,
            'timeout': 0,
            'tcp_backlog': 511,
            
            # Performance tuning
            'hash_max_ziplist_entries': 512,
            'hash_max_ziplist_value': 64,
            'list_max_ziplist_size': -2,
            'set_max_intset_entries': 512,
            'zset_max_ziplist_entries': 128,
            'zset_max_ziplist_value': 64
        }
        return cluster_config

# Redis connection management
class RedisConnectionManager:
    def __init__(self):
        self.cluster_nodes = [
            {'host': 'redis1', 'port': 6379},
            {'host': 'redis2', 'port': 6379},
            {'host': 'redis3', 'port': 6379},
            {'host': 'redis4', 'port': 6379},
            {'host': 'redis5', 'port': 6379},
            {'host': 'redis6', 'port': 6379}
        ]
        
    def create_connection_pool(self):
        """
        Create Redis cluster connection pool
        """
        from rediscluster import RedisCluster
        
        cluster = RedisCluster(
            startup_nodes=self.cluster_nodes,
            decode_responses=True,
            skip_full_coverage_check=True,
            health_check_interval=30,
            socket_keepalive=True,
            socket_keepalive_options={
                'TCP_KEEPIDLE': 1,
                'TCP_KEEPINTVL': 3,
                'TCP_KEEPCNT': 5
            },
            retry_on_timeout=True,
            max_connections=100,
            max_connections_per_node=20
        )
        
        return cluster

class CDNScalingStrategy:
    def __init__(self):
        self.global_regions = [
            'us-east', 'us-west', 'eu-west', 'eu-central',
            'ap-southeast', 'ap-northeast', 'sa-east'
        ]
        
    def configure_cdn_distribution(self):
        """
        Configure CDN for global comment delivery
        """
        cdn_config = {
            'edge_locations': {
                'tier_1_cities': 50,    # Major metropolitan areas
                'tier_2_cities': 100,   # Secondary cities
                'tier_3_cities': 200    # Smaller cities
            },
            'caching_strategy': {
                'static_assets': {
                    'ttl': 86400,       # 24 hours
                    'cache_control': 'public, max-age=86400'
                },
                'api_responses': {
                    'ttl': 300,         # 5 minutes
                    'cache_control': 'public, max-age=300'
                },
                'user_content': {
                    'ttl': 60,          # 1 minute
                    'cache_control': 'public, max-age=60'
                }
            },
            'compression': {
                'gzip_enabled': True,
                'brotli_enabled': True,
                'compression_level': 6
            },
            'http2_enabled': True,
            'websocket_support': True
        }
        return cdn_config
    
    def implement_edge_computing(self):
        """
        Implement edge computing for comment processing
        """
        edge_functions = {
            'comment_validation': {
                'runtime': 'javascript',
                'memory_mb': 128,
                'timeout_ms': 5000,
                'purpose': 'Basic comment validation at edge'
            },
            'rate_limiting': {
                'runtime': 'javascript', 
                'memory_mb': 64,
                'timeout_ms': 1000,
                'purpose': 'User rate limiting at edge'
            },
            'geo_routing': {
                'runtime': 'javascript',
                'memory_mb': 32,
                'timeout_ms': 500,
                'purpose': 'Route to nearest data center'
            }
        }
        return edge_functions