// WebSocket - Full duplex, lowest latency
class WebSocketImplementation {
    constructor(eventId, authToken) {
        this.eventId = eventId;
        this.authToken = authToken;
        this.reconnectDelay = 1000;
        this.maxReconnectDelay = 30000;
    }
    
    connect() {
        this.ws = new WebSocket(`wss://api.example.com/ws/${this.eventId}`);
        
        this.ws.onopen = () => {
            console.log('WebSocket connected');
            this.reconnectDelay = 1000; // Reset delay on successful connection
        };
        
        this.ws.onmessage = (event) => {
            const message = JSON.parse(event.data);
            this.handleMessage(message);
        };
        
        this.ws.onclose = () => {
            console.log('WebSocket disconnected, attempting reconnect...');
            this.scheduleReconnect();
        };
    }
    
    sendComment(content) {
        if (this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(JSON.stringify({
                type: 'comment',
                content: content,
                timestamp: Date.now()
            }));
        }
    }
}

// Pros and Cons Analysis
const webSocketTradeoffs = {
    pros: [
        'Lowest latency (sub-100ms)',
        'Full duplex communication',
        'Efficient for high-frequency updates',
        'Native browser support',
        'Persistent connection reduces overhead'
    ],
    cons: [
        'Complex connection management',
        'Proxy/firewall compatibility issues',
        'Higher server resource usage',
        'Connection state management complexity',
        'Scaling challenges with sticky sessions'
    ],
    bestFor: [
        'High-frequency real-time updates',
        'Bidirectional communication',
        'Gaming or collaborative applications',
        'Live sports commentary'
    ]
};

// Server-Sent Events - Simpler, unidirectional
class ServerSentEventsImplementation {
    constructor(eventId, authToken) {
        this.eventId = eventId;
        this.authToken = authToken;
    }
    
    connect() {
        const url = `https://api.example.com/events/${this.eventId}/stream`;
        
        this.eventSource = new EventSource(url, {
            headers: {
                'Authorization': `Bearer ${this.authToken}`
            }
        });
        
        this.eventSource.onmessage = (event) => {
            const comment = JSON.parse(event.data);
            this.displayComment(comment);
        };
        
        this.eventSource.onerror = () => {
            console.log('SSE connection error, will auto-reconnect');
        };
    }
    
    // Comments sent via separate HTTP POST
    async sendComment(content) {
        const response = await fetch(`/api/events/${this.eventId}/comments`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.authToken}`
            },
            body: JSON.stringify({ content })
        });
        return response.json();
    }
}

const sseTradeoffs = {
    pros: [
        'Simpler implementation',
        'Automatic reconnection',
        'Better proxy/firewall compatibility',
        'HTTP/2 multiplexing support',
        'Built-in error handling'
    ],
    cons: [
        'Unidirectional only (server to client)',
        'Limited browser connection pool',
        'No binary data support',
        'Less efficient than WebSocket for high frequency'
    ],
    bestFor: [
        'Read-heavy applications',
        'News feeds or notifications',
        'Simple real-time updates',
        'Corporate environments with strict firewalls'
    ]
};

// Long Polling - Most compatible, highest latency
class LongPollingImplementation {
    constructor(eventId, authToken) {
        this.eventId = eventId;
        this.authToken = authToken;
        this.isPolling = false;
        this.lastMessageId = null;
    }
    
    async startPolling() {
        this.isPolling = true;
        
        while (this.isPolling) {
            try {
                const response = await fetch(
                    `/api/events/${this.eventId}/comments/poll?since=${this.lastMessageId}`,
                    {
                        method: 'GET',
                        headers: {
                            'Authorization': `Bearer ${this.authToken}`
                        },
                        timeout: 30000 // 30 second timeout
                    }
                );
                
                if (response.ok) {
                    const data = await response.json();
                    if (data.comments.length > 0) {
                        data.comments.forEach(comment => this.displayComment(comment));
                        this.lastMessageId = data.comments[data.comments.length - 1].id;
                    }
                }
            } catch (error) {
                console.log('Polling error:', error);
                await this.sleep(5000); // Wait 5 seconds before retry
            }
        }
    }
    
    async sendComment(content) {
        const response = await fetch(`/api/events/${this.eventId}/comments`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.authToken}`
            },
            body: JSON.stringify({ content })
        });
        return response.json();
    }
}

const longPollingTradeoffs = {
    pros: [
        'Universal compatibility',
        'Simple to implement',
        'Works with all proxies/firewalls',
        'No persistent connection management',
        'Easy to debug and monitor'
    ],
    cons: [
        'Higher latency (1-5 seconds)',
        'More server resources per user',
        'Inefficient for high-frequency updates',
        'Battery drain on mobile devices'
    ],
    bestFor: [
        'Fallback mechanism',
        'Low-frequency updates',
        'Maximum compatibility requirements',
        'Simple notification systems'
    ]
};

class EventualConsistencyCommentSystem:
    def __init__(self, cassandra_session):
        self.session = cassandra_session
        
    async def submit_comment(self, comment_data):
        """
        Submit comment with eventual consistency
        """
        # Write with LOCAL_QUORUM for fast writes
        insert_statement = self.session.prepare("""
            INSERT INTO comments (event_id, comment_time, comment_id, user_id, content)
            VALUES (?, ?, ?, ?, ?)
        """)
        
        await self.session.execute_async(
            insert_statement,
            [
                comment_data['event_id'],
                comment_data['timestamp'],
                comment_data['comment_id'],
                comment_data['user_id'],
                comment_data['content']
            ],
            consistency_level=ConsistencyLevel.LOCAL_QUORUM
        )
        
        # Immediate broadcast to connected users (may show before persistence)
        await self.broadcast_comment_immediately(comment_data)
        
        return {
            'comment_id': comment_data['comment_id'],
            'status': 'submitted',
            'consistency': 'eventual'
        }
    
    async def get_comments(self, event_id, limit=50):
        """
        Read comments with eventual consistency
        """
        select_statement = self.session.prepare("""
            SELECT * FROM comments 
            WHERE event_id = ? 
            ORDER BY comment_time DESC 
            LIMIT ?
        """)
        
        # Read with LOCAL_ONE for fastest reads
        result = await self.session.execute_async(
            select_statement,
            [event_id, limit],
            consistency_level=ConsistencyLevel.LOCAL_ONE
        )
        
        return result.all()

# Tradeoffs analysis
eventual_consistency_tradeoffs = {
    'advantages': {
        'performance': 'Sub-50ms write latency',
        'availability': '99.99% uptime even during node failures',
        'scalability': 'Linear scaling with node additions',
        'partition_tolerance': 'Continues operating during network splits'
    },
    'disadvantages': {
        'consistency_lag': '100ms-1s delay for global consistency',
        'duplicate_detection': 'May show same comment multiple times temporarily',
        'ordering_issues': 'Comments may appear out of order briefly',
        'conflict_resolution': 'Complex conflict resolution logic needed'
    },
    'mitigation_strategies': {
        'client_side_deduplication': 'Track comment IDs on client',
        'optimistic_ui': 'Show comment immediately, handle conflicts later',
        'vector_clocks': 'Use vector clocks for causal ordering',
        'read_repair': 'Implement read repair for consistency'
    }
}

class StrongConsistencyCommentSystem:
    def __init__(self, postgres_pool):
        self.pool = postgres_pool
        
    async def submit_comment(self, comment_data):
        """
        Submit comment with strong consistency
        """
        async with self.pool.acquire() as conn:
            async with conn.transaction():
                # Insert comment with ACID guarantees
                comment_id = await conn.fetchval("""
                    INSERT INTO comments (event_id, user_id, content, parent_id, created_at)
                    VALUES ($1, $2, $3, $4, NOW())
                    RETURNING comment_id
                """, 
                comment_data['event_id'],
                comment_data['user_id'],
                comment_data['content'],
                comment_data.get('parent_id')
                )
                
                # Update event statistics atomically
                await conn.execute("""
                    UPDATE events 
                    SET comment_count = comment_count + 1,
                        last_comment_at = NOW()
                    WHERE event_id = $1
                """, comment_data['event_id'])
                
                # Get complete comment data for broadcast
                comment = await conn.fetchrow("""
                    SELECT c.*, u.username, u.display_name, u.avatar_url
                    FROM comments c
                    JOIN users u ON c.user_id = u.user_id
                    WHERE c.comment_id = $1
                """, comment_id)
                
        # Broadcast after successful commit
        await self.broadcast_comment_after_commit(dict(comment))
        
        return {
            'comment_id': comment_id,
            'status': 'committed',
            'consistency': 'strong'
        }

strong_consistency_tradeoffs = {
    'advantages': {
        'data_integrity': 'ACID guarantees prevent data corruption',
        'immediate_consistency': 'All reads see latest committed data',
        'simple_reasoning': 'Easier to reason about application logic',
        'no_conflicts': 'No need for conflict resolution'
    },
    'disadvantages': {
        'higher_latency': '100-500ms write latency',
        'lower_availability': 'System unavailable during database failures',
        'scaling_limits': 'Vertical scaling limitations',
        'blocking_operations': 'Long transactions can block other operations'
    },
    'use_cases': {
        'financial_data': 'Payment processing, billing',
        'user_accounts': 'Authentication, profile updates',
        'moderation_actions': 'Comment approval/rejection',
        'audit_logs': 'Compliance and security logging'
    }
}

class AtMostOnceDelivery:
    def __init__(self, kafka_producer):
        self.producer = kafka_producer
        
    async def send_comment(self, comment_data):
        """
        Send comment with at-most-once semantics
        """
        try:
            # Fire and forget - no acknowledgment waited
            await self.producer.send(
                'comment_events',
                value=comment_data,
                acks=0  # No acknowledgment required
            )
            return {'status': 'sent', 'guarantee': 'at_most_once'}
        except Exception as e:
            # If send fails, message is lost
            return {'status': 'failed', 'error': str(e)}

at_most_once_tradeoffs = {
    'characteristics': {
        'latency': 'Lowest possible (1-5ms)',
        'throughput': 'Highest possible',
        'reliability': 'Messages may be lost',
        'duplicates': 'No duplicates possible'
    },
    'use_cases': [
        'Live sports scores (latest value matters most)',
        'Real-time analytics (some data loss acceptable)',
        'Presence updates (current state matters)',
        'Metrics collection (sampling acceptable)'
    ]
}

class AtLeastOnceDelivery:
    def __init__(self, kafka_producer):
        self.producer = kafka_producer
        
    async def send_comment(self, comment_data):
        """
        Send comment with at-least-once semantics
        """
        max_retries = 3
        retry_count = 0
        
        while retry_count < max_retries:
            try:
                # Wait for leader acknowledgment
                record_metadata = await self.producer.send(
                    'comment_events',
                    value=comment_data,
                    acks=1  # Leader acknowledgment required
                )
                
                return {
                    'status': 'delivered',
                    'guarantee': 'at_least_once',
                    'partition': record_metadata.partition,
                    'offset': record_metadata.offset
                }
                
            except Exception as e:
                retry_count += 1
                if retry_count >= max_retries:
                    # Store in dead letter queue for manual processing
                    await self.store_in_dlq(comment_data, str(e))
                    return {'status': 'failed_after_retries', 'error': str(e)}
                
                # Exponential backoff
                await asyncio.sleep(2 ** retry_count)

at_least_once_tradeoffs = {
    'characteristics': {
        'latency': 'Medium (10-50ms)',
        'throughput': 'High',
        'reliability': 'No message loss',
        'duplicates': 'Possible during retries'
    },
    'use_cases': [
        'Comment notifications (must be delivered)',
        'User actions (likes, replies)',
        'Moderation events (critical for safety)',
        'Billing events (financial accuracy)'
    ],
    'duplicate_handling': [
        'Idempotent processing',
        'Deduplication keys',
        'Client-side tracking',
        'Database constraints'
    ]
}

class ExactlyOnceDelivery:
    def __init__(self, kafka_producer):
        self.producer = kafka_producer
        # Enable idempotent producer
        self.producer.config.update({
            'enable_idempotence': True,
            'acks': 'all',
            'retries': 2147483647,  # Max retries
            'max_in_flight_requests_per_connection': 5
        })
        
    async def send_comment_transactional(self, comment_data, database_operation):
        """
        Send comment with exactly-once semantics using transactions
        """
        transaction_id = f"comment_tx_{uuid.uuid4()}"
        
        try:
            # Begin Kafka transaction
            await self.producer.begin_transaction()
            
            # Send message to Kafka
            await self.producer.send(
                'comment_events',
                value=comment_data
            )
            
            # Perform database operation
            await database_operation(comment_data)
            
            # Commit transaction (atomic)
            await self.producer.commit_transaction()
            
            return {
                'status': 'committed',
                'guarantee': 'exactly_once',
                'transaction_id': transaction_id
            }
            
        except Exception as e:
            # Abort transaction on any failure
            await self.producer.abort_transaction()
            return {
                'status': 'aborted',
                'error': str(e),
                'transaction_id': transaction_id
            }

exactly_once_tradeoffs = {
    'characteristics': {
        'latency': 'Highest (50-200ms)',
        'throughput': 'Lower due to coordination overhead',
        'reliability': 'No message loss or duplication',
        'complexity': 'High implementation complexity'
    },
    'use_cases': [
        'Financial transactions',
        'Critical system events',
        'Compliance-required operations',
        'State machine updates'
    ],
    'limitations': [
        'Requires transactional infrastructure',
        'Higher resource usage',
        'Potential for deadlocks',
        'Complex error handling'
    ]
}

class WriteThroughCache:
    def __init__(self, redis_client, database):
        self.cache = redis_client
        self.db = database
        
    async def store_comment(self, comment_data):
        """
        Write-through: Write to cache and database simultaneously
        """
        try:
            # Write to both cache and database atomically
            cache_task = self.cache.set(
                f"comment:{comment_data['comment_id']}", 
                json.dumps(comment_data),
                ex=3600  # 1 hour TTL
            )
            
            db_task = self.db.insert_comment(comment_data)
            
            # Wait for both operations to complete
            await asyncio.gather(cache_task, db_task)
            
            return {'status': 'success', 'cached': True, 'persisted': True}
            
        except Exception as e:
            # If either fails, invalidate cache to maintain consistency
            await self.cache.delete(f"comment:{comment_data['comment_id']}")
            raise e

write_through_tradeoffs = {
    'advantages': [
        'Cache always consistent with database',
        'Read performance benefits immediate',
        'Simple consistency model',
        'No data loss on cache failure'
    ],
    'disadvantages': [
        'Higher write latency',
        'Writes limited by slowest storage',
        'Cache pollution with infrequently accessed data',
        'Wasted cache space'
    ],
    'best_for': [
        'Read-heavy workloads',
        'Strong consistency requirements',
        'Critical data that must be cached',
        'Simple cache management'
    ]
}

class WriteBehindCache:
    def __init__(self, redis_client, database):
        self.cache = redis_client
        self.db = database
        self.write_queue = asyncio.Queue()
        self.batch_size = 100
        self.flush_interval = 5  # seconds
        
    async def store_comment(self, comment_data):
        """
        Write-behind: Write to cache immediately, database asynchronously
        """
        # Immediate cache write
        await self.cache.set(
            f"comment:{comment_data['comment_id']}", 
            json.dumps(comment_data),
            ex=3600
        )
        
        # Queue for background database write
        await self.write_queue.put(comment_data)
        
        return {'status': 'cached', 'queued_for_persistence': True}
    
    async def background_writer(self):
        """
        Background process to flush cache to database
        """
        batch = []
        
        while True:
            try:
                # Collect batch of writes
                while len(batch) < self.batch_size:
                    try:
                        comment = await asyncio.wait_for(
                            self.write_queue.get(), 
                            timeout=self.flush_interval
                        )
                        batch.append(comment)
                    except asyncio.TimeoutError:
                        break  # Flush partial batch on timeout
                
                if batch:
                    # Batch write to database
                    await self.db.batch_insert_comments(batch)
                    batch.clear()
                    
            except Exception as e:
                # Handle write failures - could implement retry logic
                logger.error(f"Background write failed: {e}")

write_behind_tradeoffs = {
    'advantages': [
        'Lowest write latency',
        'Batch writes improve database performance',
        'Cache absorbs write spikes',
        'Better write throughput'
    ],
    'disadvantages': [
        'Risk of data loss on cache failure',
        'Complex consistency management',
        'Delayed database updates',
        'Requires background processes'
    ],
    'best_for': [
        'Write-heavy workloads',
        'Temporary data (sessions, counters)',
        'High-performance requirements',
        'Acceptable data loss scenarios'
    ]
}