// Consistency Levels in Practice

class ConsistentDatabase {
  async read(key, consistency = 'eventual') {
    switch (consistency) {
      case 'linearizable':
        // Wait for quorum, ensure latest write
        return await this.readFromQuorum(key);
      case 'causal':
        // Ensure causally related ops are seen in order
        return await this.readWithCausalTracking(key);
      case 'read_your_writes':
        // Route to same replica user wrote to
        const replica = this.getUserReplica(key);
        return await replica.read(key);
      case 'monotonic':
        // Never go backwards in time
        return await this.readWithVersionCheck(key);
      case 'eventual':
        // Read from any replica, fastest
        return await this.readFromAnyReplica(key);
    }
  }
}

// CRDT Example: Conflict-free replicated counter
class GCounter {
  constructor() {
    this.counts = new Map(); // node_id -> count
  }

  increment(nodeId) {
    this.counts.set(nodeId, (this.counts.get(nodeId) || 0) + 1);
  }

  merge(otherCounter) {
    for (const [nodeId, count] of otherCounter.counts) {
      this.counts.set(nodeId, Math.max(this.counts.get(nodeId) || 0, count));
    }
  }

  value() {
    return Array.from(this.counts.values()).reduce((a, b) => a + b, 0);
  }
}