Offline System Configuration

   Computer Configuration
   └── Windows Settings
       └── Security Settings
           └── Local Policies
               └── Security Options
                   └── Interactive logon: Number of previous logons to cache

   Entra admin centre
   └── Protection
       └── Conditional Access
           └── Policies
               └── [Your policy]
                   └── Session
                       └── Sign-in frequency: 14 days

   Okta admin console
   └── Security
       └── Global Session Policy
           └── Default Rule
               └── Maximum session lifetime: 336 hours (14 days)

   // Run in browser console
   navigator.storage.estimate().then(estimate => {
     console.log(`Quota: ${Math.round(estimate.quota / 1024 / 1024)} MB`);
     console.log(`Usage: ${Math.round(estimate.usage / 1024 / 1024)} MB`);
   });

   // Application should call this on first load
   if (navigator.storage && navigator.storage.persist) {
     navigator.storage.persist().then(granted => {
       console.log(`Persistent storage: ${granted ? 'granted' : 'denied'}`);
     });
   }

   // In main application JavaScript
   if ('serviceWorker' in navigator) {
     navigator.serviceWorker.register('/sw.js')
       .then(registration => {
         console.log('SW registered:', registration.scope);
       })
       .catch(error => {
         console.log('SW registration failed:', error);
       });
   }

   const CACHE_NAME = 'app-cache-v1';
   const OFFLINE_URLS = [
     '/',
     '/index.html',
     '/app.js',
     '/styles.css',
     '/offline.html'
   ];

   self.addEventListener('install', event => {
     event.waitUntil(
       caches.open(CACHE_NAME)
         .then(cache => cache.addAll(OFFLINE_URLS))
     );
   });

   self.addEventListener('fetch', event => {
     event.respondWith(
       caches.match(event.request)
         .then(response => response || fetch(event.request))
         .catch(() => caches.match('/offline.html'))
     );
   });

   ODK Collect
   └── Settings
       └── Form management
           └── Blank form update mode: Manual
           └── Auto-send: Off (prevents failed sends on poor connectivity)
       └── User interface
           └── Navigation: Swipes (works better offline)

   Main menu
   └── Get Blank Form
       └── Select All
           └── Get Selected

   CommCare HQ
   └── Project Settings
       └── Project Settings
           └── Advanced Settings
               └── Days of data to sync: 30

   Outlook
   └── File
       └── Account Settings
           └── Account Settings
               └── [Select account]
                   └── Change
                       └── Use Cached Exchange Mode: Enabled
                       └── Download email for the past: 12 months

   +------------------------------------------------------------------------+
   |                         OFFLINE QUEUE ARCHITECTURE                     |
   +------------------------------------------------------------------------+
   |                                                                        |
   |  +------------------+     +------------------+     +----------------+  |
   |  |   Application    |     |   Queue Store    |     |   Network      |  |
   |  |                  |     |                  |     |   Monitor      |  |
   |  |  User creates    |     |  - Pending ops   |     |                |  |
   |  |  or modifies     +---->|  - Timestamps    +---->|   Detects      |  |
   |  |  record          |     |  - Retry count   |     |   online       |  |
   |  |                  |     |  - Conflict data |     |                |  |
   |  +------------------+     +--------+---------+     +--------+-------+  |
   |                                    |                      |            |
   |                                    v                      v            |
   |                           +--------+---------+     +------+------+     |
   |                           |   Sync Engine    |<----+   Trigger   |     |
   |                           |                  |     |   (online)  |     |
   |                           |  - Batch ops     |     +-------------+     |
   |                           |  - Handle errors |                         |
   |                           |  - Resolve       |                         |
   |                           |    conflicts     |                         |
   |                           +--------+---------+                         |
   |                                   |                                    |
   |                                   v                                    |
   |                           +--------+---------+                         |
   |                           |      Server      |                         |
   |                           |                  |                         |
   |                           |  - Apply changes |                         |
   |                           |  - Return status |                         |
   |                           |  - Send updates  |                         |
   |                           +------------------+                         |
   |                                                                        |
   +------------------------------------------------------------------------+

   // Initialise local database
   const localDB = new PouchDB('field-data');

   // Configure remote database
   const remoteDB = new PouchDB('https://couchdb.example.org/field-data', {
     auth: {
       username: 'fielduser',
       password: 'secure-password'
     }
   });

   // Configure bidirectional sync with retry
   const sync = localDB.sync(remoteDB, {
     live: true,      // Continuous sync when online
     retry: true,     // Retry failed syncs
     batch_size: 100, // Documents per batch
     batches_limit: 5 // Concurrent batches
   });

   // Handle sync events
   sync.on('change', info => {
     console.log(`Synced: ${info.docs.length} documents`);
   });

   sync.on('paused', err => {
     if (err) {
       console.log('Sync paused due to error:', err);
     } else {
       console.log('Sync complete, waiting for changes');
     }
   });

   sync.on('error', err => {
     console.error('Sync failed:', err);
   });

   -- SQLite schema for offline queue
   CREATE TABLE sync_queue (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     operation TEXT NOT NULL,        -- 'create', 'update', 'delete'
     entity_type TEXT NOT NULL,      -- 'beneficiary', 'distribution', etc.
     entity_id TEXT NOT NULL,        -- UUID of the record
     payload TEXT NOT NULL,          -- JSON of the change
     created_at TEXT NOT NULL,       -- ISO 8601 timestamp
     attempts INTEGER DEFAULT 0,     -- Retry count
     last_attempt TEXT,              -- Last sync attempt timestamp
     status TEXT DEFAULT 'pending',  -- 'pending', 'syncing', 'failed', 'conflict'
     error_message TEXT,             -- Last error if failed
     conflict_data TEXT              -- Server version if conflict
   );

   CREATE INDEX idx_queue_status ON sync_queue(status);
   CREATE INDEX idx_queue_entity ON sync_queue(entity_type, entity_id);

   async function queueOperation(operation, entityType, entityId, payload) {
     const db = await openDatabase();
     await db.run(
       `INSERT INTO sync_queue
        (operation, entity_type, entity_id, payload, created_at)
        VALUES (?, ?, ?, ?, ?)`,
       [operation, entityType, entityId, JSON.stringify(payload), new Date().toISOString()]
     );
   }

   // Browser-based network detection
   window.addEventListener('online', () => {
     console.log('Connection restored, starting sync');
     startSync();
   });

   window.addEventListener('offline', () => {
     console.log('Connection lost, queueing operations');
   });

   // More reliable: periodic connectivity check
   async function checkConnectivity() {
     try {
       const response = await fetch('/api/ping', {
         method: 'HEAD',
         cache: 'no-store',
         timeout: 5000
       });
       return response.ok;
     } catch {
       return false;
     }
   }

   // Check every 30 seconds
   setInterval(async () => {
     const online = await checkConnectivity();
     if (online && hasQueuedOperations()) {
       startSync();
     }
   }, 30000);

   async function syncWithRetry(maxAttempts = 5) {
     let attempt = 0;
     let delay = 1000; // Start with 1 second

     while (attempt < maxAttempts) {
       try {
         await performSync();
         return { success: true };
       } catch (error) {
         attempt++;
         if (attempt >= maxAttempts) {
           return { success: false, error: error.message };
         }
         // Exponential backoff: 1s, 2s, 4s, 8s, 16s
         await new Promise(resolve => setTimeout(resolve, delay));
         delay *= 2;
       }
     }
   }

   // PouchDB automatic conflict resolution keeps winning revision
   // Losing revisions become conflict leaves

   // Check for conflicts
   localDB.get('doc-id', { conflicts: true })
     .then(doc => {
       if (doc._conflicts) {
         console.log('Conflicts detected:', doc._conflicts);
         // Delete losing revisions
         return Promise.all(
           doc._conflicts.map(rev =>
             localDB.remove('doc-id', rev)
           )
         );
       }
     });

   function mergeRecords(serverRecord, clientRecord, baseRecord) {
     const merged = { ...serverRecord };
     const conflicts = [];

     for (const field of Object.keys(clientRecord)) {
       if (field === '_id' || field === '_rev' || field === 'updated_at') {
         continue;
       }

       const serverValue = serverRecord[field];
       const clientValue = clientRecord[field];
       const baseValue = baseRecord ? baseRecord[field] : undefined;

       // Client changed, server unchanged: use client value
       if (clientValue !== baseValue && serverValue === baseValue) {
         merged[field] = clientValue;
       }
       // Server changed, client unchanged: use server value (already in merged)
       else if (serverValue !== baseValue && clientValue === baseValue) {
         // No action needed, server value already in merged
       }
       // Both changed to same value: no conflict
       else if (serverValue === clientValue) {
         // No action needed
       }
       // Both changed to different values: conflict
       else if (serverValue !== baseValue && clientValue !== baseValue) {
         conflicts.push({
           field: field,
           serverValue: serverValue,
           clientValue: clientValue,
           baseValue: baseValue
         });
       }
     }

     return { merged, conflicts };
   }

   function notifyConflict(record, conflicts) {
     // Store conflict for review
     const conflictEntry = {
       recordId: record._id,
       recordType: record.type,
       conflicts: conflicts,
       detectedAt: new Date().toISOString(),
       resolved: false
     };

     conflictStore.add(conflictEntry);

     // Show user notification
     if (Notification.permission === 'granted') {
       new Notification('Sync Conflict', {
         body: `Conflicting changes detected in ${record.type}. Review required.`,
         tag: `conflict-${record._id}`
       });
     }
   }

   function checkOfflineDuration() {
     const lastSync = localStorage.getItem('lastSyncTimestamp');
     if (!lastSync) {
       return { valid: false, reason: 'Never synchronised' };
     }

     const daysSinceSync = (Date.now() - new Date(lastSync)) / (1000 * 60 * 60 * 24);
     const maxOfflineDays = 14; // Configure per application

     if (daysSinceSync > maxOfflineDays) {
       return {
         valid: false,
         reason: `Last sync was ${Math.floor(daysSinceSync)} days ago (maximum: ${maxOfflineDays})`,
         daysSinceSync: daysSinceSync
       };
     }

     return { valid: true, daysSinceSync: daysSinceSync };
   }

   function getOfflineStatus() {
     const check = checkOfflineDuration();
     const warningThreshold = 11; // Warn 3 days before 14-day limit

     if (!check.valid) {
       return {
         status: 'expired',
         message: 'Offline period exceeded. Synchronisation required before continuing.',
         allowDataEntry: false
       };
     }

     if (check.daysSinceSync > warningThreshold) {
       return {
         status: 'warning',
         message: `Synchronise within ${14 - Math.floor(check.daysSinceSync)} days to continue offline access.`,
         allowDataEntry: true
       };
     }

     return {
       status: 'ok',
       message: `Last synchronised ${Math.floor(check.daysSinceSync)} days ago.`,
       allowDataEntry: true
     };
   }

   +------------------------------------------------------------------+
   |  [OFFLINE MODE - Last sync: 2024-11-10]                          |
   |                                                                  |
   |  +------------------------------------------------------------+  |
   |  |  Warning: 11 days since last synchronisation.              |  |
   |  |  Connect within 3 days to maintain offline access.         |  |
   |  +------------------------------------------------------------+  |
   |                                                                  |
   |  +------------------------------------------------------------+  |
   |  |                                                            |  |
   |  |  [Application Interface]                                   |  |
   |  |                                                            |  |
   |  +------------------------------------------------------------+  |
   |                                                                  |
   |  Queued changes: 47 | Storage used: 1.2 GB / 5 GB                |
   +------------------------------------------------------------------+

   Test Scenario: Complete Offline Workflow

   Preconditions:
   - Device configured per procedures above
   - Test user account with appropriate permissions
   - Sample data loaded (minimum 100 records)
   - Known server state (snapshot for comparison)

   Test Steps:
   1. Verify current sync status (all data present)
   2. Disconnect network (physical or software)
   3. Authenticate to device (cached credentials)
   4. Launch application
   5. Verify existing data accessible
   6. Create new record
   7. Modify existing record
   8. Delete record (if supported offline)
   9. Close and relaunch application
   10. Verify changes persisted locally
   11. Reconnect network
   12. Observe automatic sync
   13. Verify changes appear on server
   14. Verify server changes appear on device

   Expected Results:
   - Steps 1-10 complete without errors while offline
   - Step 11-14 complete within 5 minutes of reconnection
   - No data loss in either direction

   Conflict Test Scenario:

   1. Create record on Device A while online
   2. Sync completes to server
   3. Disconnect Device A
   4. Modify record on Device A (offline)
   5. Modify same record on server (different field)
   6. Reconnect Device A
   7. Observe conflict resolution

   Expected: Field-level merge preserves both changes

   Repeat with same-field modification:
   Expected: Configured strategy applies (last-write-wins, manual review, etc.)

// Browser storage analysis
async function analyzeStorage() {
  const estimate = await navigator.storage.estimate();
  const dbs = await indexedDB.databases();

  console.log('Storage Overview:');
  console.log(`  Total quota: ${Math.round(estimate.quota / 1024 / 1024)} MB`);
  console.log(`  Used: ${Math.round(estimate.usage / 1024 / 1024)} MB`);
  console.log(`  Available: ${Math.round((estimate.quota - estimate.usage) / 1024 / 1024)} MB`);
  console.log('  Databases:', dbs.map(d => d.name).join(', '));
}

// PouchDB sync debugging
PouchDB.debug.enable('pouchdb:http');

// Custom sync logging
sync.on('change', info => {
  console.log('Sync change:', JSON.stringify(info, null, 2));
});

sync.on('error', err => {
  console.error('Sync error:', {
    name: err.name,
    message: err.message,
    status: err.status,
    docId: err.docId
  });
});