/// The day's delivered dishes, offered to the log form one at a time. /// /// **A delivered meal is not an eaten meal.** This queue only ever *prefills* /// the form; the user still taps to log each dish. Nothing here writes a log /// entry, and nothing here may start doing so -- the gate would then satisfy /// its own checkpoint from a delivery note, and the log would record what the /// courier dropped off rather than what was eaten. /// /// Two things are load-bearing: /// /// * **The queue survives a submit.** After a dish is logged the next one is /// already in the form, so one tap walks the whole delivery. On the PC this /// regressed once into a dead letter -- every dish after the first stayed /// queued behind another click, and because the refresh there is unguarded /// that meant a fresh login-plus-three-requests *per dish*. /// * **The automatic refresh is guarded** by a device-local "already fetched /// today" marker, mirroring Python's `refresh_delivery_once`. Without it /// every logged meal would pay a login plus three requests against a third /// party. Only a *clean* fetch records the day, so an outage is retried. /// The settings button deliberately does **not** go through this: an /// explicit ask always goes and looks, matching `diet-guard kuchnia`. library; import 'package:diet_guard_app/models/kuchnia_dish.dart'; import 'package:diet_guard_app/services/document_store.dart'; import 'package:diet_guard_app/services/document_store_factory.dart'; import 'package:diet_guard_app/services/kuchnia_import.dart'; import 'package:diet_guard_app/services/kuchnia_orders.dart' show isoDay; import 'package:flutter/foundation.dart'; /// Holds today's delivered dishes and hands them out in the caterer's order. class KuchniaQueueService { KuchniaQueueService._(this._store); /// Document holding the last fetched day, one ISO date. /// /// Device-local on purpose: this is a rate limit, not shared state. Syncing /// it would let one device's fetch suppress another's. static const documentName = 'kuchnia_last_import.json'; static KuchniaQueueService? _instance; /// Returns the initialized singleton; throws if [init] was not called. static KuchniaQueueService get instance => _instance!; /// True once initialised, so callers can skip work in widget tests. static bool get isInitialized => _instance != null; final DocumentStore _store; final List _pending = []; String _lastImportDay = ''; /// The dishes not yet logged, in the caterer's own meal order. static List get pending => List.unmodifiable(_instance?._pending ?? const []); /// The next dish to offer, or null when the queue is empty. static KuchniaDish? get next => (_instance?._pending.isEmpty ?? true) ? null : _instance!._pending.first; /// How many dishes are still waiting to be logged. static int get remaining => _instance?._pending.length ?? 0; /// Initialises the singleton against the platform document store. /// /// Without this the queue silently no-ops on a real device: every entry /// point checks [isInitialized] first, so a missing call reads as "no /// delivery" rather than as an error. static Future init() async { if (_instance != null) return _instance!; // Resolving the platform store is a plugin call, not reachable from // `flutter test`. // coverage:ignore-start final service = KuchniaQueueService._(await openDocumentStore()); // coverage:ignore-end await service._load(); _instance = service; return service; } /// Initialises from [store], for tests. @visibleForTesting static Future initForTesting(DocumentStore store) async { final service = KuchniaQueueService._(store); await service._load(); _instance = service; return service; } /// Resets the singleton so [initForTesting] can run again. @visibleForTesting static void resetForTesting() => _instance = null; Future _load() async { final raw = await _store.read(documentName); if (raw != null) _lastImportDay = raw.trim(); } /// True when [day]'s delivery has already been fetched on this device. bool alreadyFetched(DateTime day) => _lastImportDay == isoDay(day); /// Records that [day]'s delivery was fetched cleanly. /// /// Best-effort: this is a rate limit, not state anyone depends on. Failing /// to write it costs one extra fetch, which is strictly better than failing /// an import that already succeeded. Future recordFetched(DateTime day) async { _lastImportDay = isoDay(day); try { await _store.write(documentName, _lastImportDay); } on Exception { // Ignore: an unrecorded fetch just means we look again. } } /// Replaces the queue with [dishes], dropping any already logged today. void offer(List dishes, {Set alreadyLogged = const {}}) { _pending ..clear() ..addAll( dishes.where((dish) => !alreadyLogged.contains(dish.bankKey)), ); } /// Removes [dish] from the queue once it has actually been logged. void markLogged(KuchniaDish dish) => _pending.removeWhere((queued) => queued.bankKey == dish.bankKey); /// Empties the queue, e.g. when the day rolls over. void clear() => _pending.clear(); /// Fetches [day]'s delivery unless it has already been fetched today. /// /// Returns an empty, successful result when the day was already fetched -- /// "nothing new", not an error. This is the entry point every *automatic* /// trigger uses; the settings button calls [refreshDelivery] directly. static Future refreshOnce(DateTime day) async { final service = _instance; if (service == null) return const KuchniaRefresh(); if (service.alreadyFetched(day)) return const KuchniaRefresh(); final result = await refreshDelivery(day); if (result.ok) await service.recordFetched(day); return result; } }