/// Cross-device log sync orchestration for the diet_guard companion app. /// /// Pulls every other device's pushed log from GitHub-backed dumb storage via /// crdt_sync's shared transport ([GitHubClient]/[syncLog]), merges with the /// local log via crdt_sync's shared CRDT scheme (`sync_merge.dart` adapts /// [FoodEntry]s to/from [Record]), rebuilds the food bank, and pushes this /// device's own merged log back up in the new Record-based wire format. /// /// The daily budget syncs alongside the food log in the same tick (see /// [_syncBudget]): a sibling `budget.json` per device, merged /// last-writer-wins by edit time rather than union-of-immutable-entries, /// since a budget (unlike a food-log entry) can be edited repeatedly. library; import 'dart:developer'; import 'package:crdt_sync/crdt_sync.dart'; import 'package:diet_guard_app/models/food_entry.dart'; import 'package:diet_guard_app/services/export_keyring_default.dart'; import 'package:diet_guard_app/services/export_keyring_sync.dart'; import 'package:diet_guard_app/services/foodbank_service.dart'; import 'package:diet_guard_app/services/kuchnia_credential_service.dart'; import 'package:diet_guard_app/services/log_storage_service.dart'; import 'package:diet_guard_app/services/sync_body.dart'; import 'package:diet_guard_app/services/sync_budget_local.dart'; import 'package:diet_guard_app/services/sync_device_id.dart'; import 'package:diet_guard_app/services/sync_e2e.dart'; import 'package:diet_guard_app/services/sync_merge.dart'; import 'package:diet_guard_app/services/sync_merge_kuchnia.dart'; import 'package:diet_guard_app/services/sync_state_factory.dart'; const String _devicesDir = syncDevicesDir; /// Runs one full sync tick: pull, merge, persist, push. /// /// [backend] is the outermost raw store (the Firebase/GitHub mirror); /// everything goes through its end-to-end encrypted view, and a locked /// device throws [SyncLockedException] before a single read or write. /// /// Returns the merged log as it now sits on disk locally. Propagates any /// [GitHubSyncError] from the client for the caller (auto-sync / the manual /// "Sync now" action) to decide how to report. Future runSync( RemoteStore backend, { SyncStateStore? stateStore, }) async { final client = await openDietGuardStore(backend); final wakeAlarm = await openWakeAlarmStore(backend); final logService = LogStorageService.instance; final local = await logService.readLog(); final mergedLog = await syncLog( client: client, deviceId: currentSyncDeviceId, legacyDeviceId: legacySyncDeviceId, pathPrefix: _devicesDir, revsPath: syncRevsDir, localLog: dayLogToLog(local), encode: encodeLogForPush, decode: parseRemoteLog, filename: 'food_log.json', commitMessage: 'diet_guard_app sync', // Without this every sync re-downloads every peer's whole food log -- // hundreds of KB -- whether or not anything changed, and re-pushes an // unchanged one. That is the traffic the Firebase free tier's monthly // budget depends on not happening. stateStore: stateStore ?? await openSyncStateStore(), ); final merged = logToDayLog(mergedLog); await logService.writeLog(merged); await FoodBankService.instance.rebuildAndPersist(merged); await _syncBudget(client); await _syncFoodBank(client); await _syncManualBank(client); await _syncKuchniaCredential(client); await _syncExportKeys(client); await syncBody(client, devicesDir: _devicesDir, wakeAlarm: wakeAlarm); return merged; } /// Pulls, merges, persists and pushes the log-derived food bank. /// /// Runs after the local rebuild above, so this device's records already /// reflect the merged log; the merge then unions in whatever another device /// knows, max-count winning per food. Mirrors `_sync._sync_food_bank`. Future _syncFoodBank(RemoteStore client) async { final merged = await syncLog( client: client, deviceId: currentSyncDeviceId, legacyDeviceId: legacySyncDeviceId, pathPrefix: _devicesDir, revsPath: syncRevsDir, localLog: foodBankToLog(await FoodBankService.instance.readBank()), encode: encodeFoodBankForPush, decode: parseRemoteFoodBank, filename: 'food_bank.json', commitMessage: 'diet_guard_app sync', ); await FoodBankService.instance.writeBank(logToFoodBank(merged)); } /// Pulls, merges, persists and pushes the hand-curated food bank. /// /// Curated entries are the one part of the bank that is not derivable from /// the food log, so unlike `food_bank.json` they need a real merge: /// last-writer-wins per food name by edit time, union across devices. Mirrors /// `_sync._sync_manual_bank`. Future _syncManualBank(RemoteStore client) async { final local = await FoodBankService.instance.readManualBank(); final merged = await syncLog( client: client, deviceId: currentSyncDeviceId, legacyDeviceId: legacySyncDeviceId, pathPrefix: _devicesDir, revsPath: syncRevsDir, localLog: manualBankToLog(local), encode: encodeManualBankForPush, decode: parseRemoteManualBank, filename: 'food_bank_manual.json', commitMessage: 'diet_guard_app sync', ); await FoodBankService.instance.applyMergedManualBank(logToManualBank(merged)); } /// Pulls other devices' budgets, merges, applies the winner locally, pushes. Future _syncBudget(RemoteStore client) async { final mergedBudgetLog = await syncLog( client: client, deviceId: currentSyncDeviceId, legacyDeviceId: legacySyncDeviceId, pathPrefix: _devicesDir, revsPath: syncRevsDir, localLog: localBudgetLog(), encode: encodeBudgetForPush, decode: parseRemoteBudget, filename: 'budget.json', commitMessage: 'diet_guard_app sync', ); await applyBudgetLog(mergedBudgetLog); } /// Syncs the export keyring; best effort, since sync must not fail on it. Future _syncExportKeys(RemoteStore client) async { try { await syncExportKeys( client, keyring: defaultKeyring(), devicesDir: _devicesDir, ); } on Object catch (error, stackTrace) { log( 'export key sync failed', level: 900, error: error, stackTrace: stackTrace, ); } } /// Pulls peers' catering credentials, merges, applies the winner locally. /// /// The phone runs its own catering importer, so it cannot fetch anything until /// the panel password reaches it -- that is the whole reason this credential /// syncs at all. Sealed end-to-end like the rest of the synced state. /// /// A device that has no credential contributes an empty log, so it neither /// blocks nor clobbers a peer's real value -- it relays it. Mirrors /// `diet_guard/_sync_kuchnia.py`. Future _syncKuchniaCredential(RemoteStore client) async { if (!KuchniaCredentialService.isInitialized) return; final merged = await syncLog( client: client, deviceId: currentSyncDeviceId, legacyDeviceId: legacySyncDeviceId, pathPrefix: _devicesDir, revsPath: syncRevsDir, localLog: credentialToLog( KuchniaCredentialService.username, KuchniaCredentialService.password, KuchniaCredentialService.editedAt, ), encode: encodeCredentialForPush, decode: parseRemoteCredential, filename: 'kuchnia.json', commitMessage: 'diet_guard_app sync', ); final credential = logToCredential(merged); if (credential == null) return; await KuchniaCredentialService.instance.applySynced( credential.username, credential.password, credential.editedAt, ); }