CAP Theorem

const gun = Gun(); // No peers - fully local

// Works offline
gun.get('todo').put({
  title: 'Buy milk',
  done: false
});

// When back online, changes sync automatically
gun.opt({peers: ['https://relay.example.com/gun']});

// Peer A (offline)
gunA.get('doc').put({title: 'Hello'});

// Peer B (offline)
gunB.get('doc').put({subtitle: 'World'});

// When peers reconnect:
// Both converge to: {title: 'Hello', subtitle: 'World'}

Time →

Peer A: [write v1] ─────────→ [read v1] ───→ [read v2]
                                              
Peer B: ──────────→ [write v2] ───→ [sync] ─→ [read v2]
                                      ↑
Peer C: ───────────────────→ [read v1] [sync] [read v2]

Eventually all peers converge to v2

// Network splits into two groups

// Group A (Peers 1, 2, 3)
gun.get('counter').put(10);

// Group B (Peers 4, 5, 6)
gun.get('counter').put(20);

// When network heals: conflict resolution kicks in
// Result: 10 or 20 (last-write-wins based on state timestamp)

// Peers track connection state
gun.on('hi', peer => {
  console.log('Connected to peer:', peer.id);
});

gun.on('bye', peer => {
  console.log('Disconnected from peer:', peer.id);
});

// Automatic resync when connection restored
// 1. Peers exchange subscription info
// 2. Missing data is requested
// 3. Conflicts are resolved using state timestamps
// 4. All peers converge

gun.get('data').put({value: 42});

gun.get('data').once(data => {
  console.log(data.value); // 42 - immediate local read
});

// Peer A writes
gunA.get('data').put({value: 42});

// Peer B reads (over network)
gunB.get('data').on(data => {
  // Receives update after network propagation
  console.log(data.value); // 42 (eventually)
});

// Traditional database (e.g., PostgreSQL)
// Requires distributed consensus (Paxos, Raft)
// Blocks during network partitions

db.beginTransaction();
  db.write({value: 42});  // Blocks until all replicas confirm
  db.commit();             // Blocks until consensus reached
// Either succeeds everywhere or fails everywhere

// GUN - always available
gun.get('data').put({value: 42}); // Never blocks

// Conflict resolution is automatic and deterministic
gun.get('data').on(data => {
  // May see different values during partition
  // Eventually converges to consistent state
});

function updateUI(newValue){
  // Update UI immediately (optimistic)
  displayValue(newValue);
  
  // Persist to GUN
  gun.get('data').put(newValue);
  
  // Handle conflicts
  gun.get('data').on(actualValue => {
    if(actualValue !== newValue){
      // Conflict occurred - update UI with winning value
      displayValue(actualValue);
      notifyUser('Your change was overwritten');
    }
  });
}

// ❌ BAD: Non-idempotent
gun.get('counter').once(val => {
  gun.get('counter').put(val + 1); // Race condition!
});

// ✅ GOOD: Idempotent (using sets)
const id = Gun.text.random();
gun.get('counters').get(id).put(1);

// Count by summing the set
let total = 0;
gun.get('counters').map().once(val => {
  total += val;
});

// Leader election using timestamps
function electLeader(){
  const candidateId = gun.user().is.pub;
  const timestamp = Gun.state();
  
  gun.get('leader-election').get(timestamp).put({
    candidate: candidateId,
    timestamp: timestamp
  });
  
  // Wait for stabilization
  setTimeout(() => {
    gun.get('leader-election').once(elections => {
      const sorted = Object.values(elections)
        .sort((a, b) => b.timestamp - a.timestamp);
      
      const leader = sorted[0].candidate;
      console.log('Leader elected:', leader);
    });
  }, 5000);
}

// Grow-only counter (G-Counter)
function increment(amount = 1){
  const peerId = gun.user().is.pub;
  gun.get('counter').get(peerId).put({
    count: Gun.state(),
    amount: amount
  });
}

function getTotal(callback){
  let total = 0;
  gun.get('counter').map().once(entry => {
    total += entry.amount;
    callback(total);
  });
}

// Works even without network
const gun = Gun();
gun.get('data').put({value: 42}); // Always succeeds locally

// Returns local data immediately
gun.get('data').once(data => {
  console.log(data); // Latest local state
});

// Subscribe for updates
gun.get('data').on(data => {
  console.log(data); // Updates as network syncs
});

gun.on('hi', peer => {
  // Connected to peer - full functionality
  showOnlineIndicator();
});

gun.on('bye', peer => {
  // Peer disconnected - still functional
  showOfflineIndicator();
});

// Application continues working regardless

Peer A ←→ Peer B
  ↕         ↕
Peer C ←→ Peer D

// If A-B connection breaks:
A → C → D → B (alternative path)

// Browser peers connect through relay
const gun = Gun({
  peers: [
    'https://relay1.example.com/gun',
    'https://relay2.example.com/gun', // Redundancy
    'https://relay3.example.com/gun'
  ]
});

const gun = Gun({
  axe: true // Enabled by default
});

const writes = new Map();

gun.get('data').on(data => {
  const writeTime = writes.get(data.id);
  if(writeTime){
    const convergenceTime = Date.now() - writeTime;
    console.log('Converged in:', convergenceTime, 'ms');
  }
});

function write(value){
  const id = Gun.text.random();
  writes.set(id, Date.now());
  gun.get('data').put({id, value});
}

let lastState = {};

gun.get('data').on(data => {
  const currentState = data._['>'];
  
  Object.keys(currentState).forEach(key => {
    if(lastState[key] && currentState[key] > lastState[key]){
      const timeDiff = currentState[key] - lastState[key];
      console.log(`Property '${key}' updated after ${timeDiff}ms`);
    }
  });
  
  lastState = {...currentState};
});

gun.on('in', function(msg){
  if(msg.DBG && msg.DBG.out){
    const lag = Date.now() - msg.DBG.out;
    console.log('Peer lag:', lag, 'ms');
  }
  this.to.next(msg);
});