diet-guard/app/lib/services/log_storage_service.dart
Krzysztof kuhy Rudnicki 26d6a68ac0 Due-mode log screen, Claude button, photos
Action row 1A, due mode, catering auto-log rows with undo, relay interface, photo input.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWZHWP4KZ6x5TcXDBFC
2026-11-17 21:26:13 +01:00

250 lines
8.9 KiB
Dart

/// Local persistence for the food log, mirroring diet_guard's `_state.py`.
library;
import 'dart:convert';
import 'package:diet_guard_app/models/food_entry.dart';
import 'package:diet_guard_app/models/local_time.dart';
import 'package:diet_guard_app/models/meal_component.dart';
import 'package:diet_guard_app/models/nutrition.dart';
import 'package:diet_guard_app/models/slot.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/log_entry_lookup.dart';
import 'package:diet_guard_app/services/meal_schedule_service.dart';
import 'package:flutter/foundation.dart';
import 'package:uuid/uuid.dart';
/// The on-disk log shape: date key (`YYYY-MM-DD`) to that day's entries.
typedef DayLog = Map<String, List<FoodEntry>>;
/// Singleton service reading/writing `food_log.json` verbatim.
///
/// Stores plain JSON matching diet_guard's exact on-disk schema rather than
/// a SQL database: the canonical format already *is* this JSON (it is also
/// the sync payload, see Milestone 3), so a SQL schema would only add a
/// second representation to keep in lockstep for no query benefit --
/// autocomplete is small-corpus fuzzy string matching, not a relational
/// query.
class LogStorageService {
LogStorageService._(this._store);
/// Document name this service owns, unchanged from the pre-web on-disk
/// filename so an installed phone keeps reading its existing log.
static const documentName = 'food_log.json';
static LogStorageService? _instance;
/// Returns the initialized singleton; throws if [init] was not called.
static LogStorageService get instance => _instance!;
final DocumentStore _store;
/// Initializes the singleton against the platform document store (files on
/// Android, IndexedDB in the browser-hosted desktop app).
static Future<LogStorageService> init() async {
if (_instance != null) return _instance!;
final svc = LogStorageService._(await openDocumentStore());
_instance = svc;
return svc;
}
/// Resets the singleton so [init] can be called again in tests.
///
/// When [store] is given, subsequent reads/writes go there instead of the
/// real platform store, so a test can never touch real data.
@visibleForTesting
static void resetForTesting({DocumentStore? store}) {
_instance = store == null ? null : LogStorageService._(store);
}
/// Reads the full log, including tombstoned entries.
///
/// Returns an empty log on a missing or unparsable file, mirroring
/// `_state._read_raw_log`'s defensive read.
Future<DayLog> readLog() async {
final raw = await _store.read(documentName);
if (raw == null) return {};
Object? data;
try {
data = jsonDecode(raw);
} on FormatException {
return {};
}
if (data is! Map) return {};
final result = <String, List<FoodEntry>>{};
for (final mapEntry in data.entries) {
final key = mapEntry.key;
final value = mapEntry.value;
if (key is! String || value is! List<dynamic>) continue;
result[key] = value
.whereType<Map<dynamic, dynamic>>()
.map((m) => FoodEntry.fromJson(m.cast<String, dynamic>()))
.toList();
}
return result;
}
/// Persists the full log to the store, mirroring `_state._write_log`.
///
/// Atomicity against a concurrent reader is the store's job.
Future<void> writeLog(DayLog log) async {
final encoded = <String, Object?>{
for (final mapEntry in log.entries)
mapEntry.key: mapEntry.value.map((e) => e.toLocalJson()).toList(),
};
await _store.write(documentName, jsonEncode(encoded));
}
/// Appends an entry for [desc] to [when]'s day (today's when null).
///
/// Mirrors `_state.log_meal`: never computes an `hmac` (the phone never
/// holds the key; the PC re-signs on merge). [when] pre-logs a future
/// date/slot and must not be in the past. [slotMinute] is a minute of day
/// (`slotForLog`'s result), never an hour.
///
/// A caller-chosen [id] makes the write idempotent: an entry already
/// carrying it (live or tombstoned) is returned and nothing is written.
Future<FoodEntry> logMeal(
String desc,
Nutrition nutrition, {
int? slotMinute,
List<MealComponent>? components,
DateTime? when,
String? id,
}) async {
if (when != null && when.isBefore(DateTime.now())) {
throw ArgumentError.value(when, 'when', 'cannot log a meal in the past');
}
final now = when ?? DateTime.now();
final log = await readLog();
if (id != null) {
final existing = findEntryById(log, id);
if (existing != null) return existing;
}
final entry = FoodEntry(
id: id ?? const Uuid().v4(),
time: isoLocalSeconds(now),
desc: desc,
grams: nutrition.grams,
kcal: nutrition.kcal,
proteinG: nutrition.proteinG,
carbsG: nutrition.carbsG,
fatG: nutrition.fatG,
source: nutrition.source,
slotMinute: slotMinute,
components: components,
);
log.putIfAbsent(localDateKey(now), () => []).add(entry);
await writeLog(log);
return entry;
}
/// Tombstones today's most recently logged, not-yet-undone entry.
///
/// Mirrors `_state.undo_last_today`: marks the entry `deleted` in place
/// rather than removing it, so a later sync merge can't resurrect a
/// stale copy of the same entry from another device.
Future<FoodEntry?> undoLastToday() async {
final log = await readLog();
final today = localDateKey(DateTime.now());
final entries = log[today];
if (entries == null || entries.isEmpty) return null;
for (var i = entries.length - 1; i >= 0; i--) {
if (entries[i].deleted) continue;
final tombstoned = entries[i].copyWithDeleted();
entries[i] = tombstoned;
log[today] = entries;
await writeLog(log);
return tombstoned;
}
return null;
}
/// Returns today's non-tombstoned entries, mirrors `_state.today_entries`.
Future<List<FoodEntry>> todayEntries() async {
final log = await readLog();
final entries = log[localDateKey(DateTime.now())] ?? const <FoodEntry>[];
return entries.where((e) => !e.deleted).toList();
}
/// Returns every non-tombstoned entry across all days, newest first.
Future<List<FoodEntry>> allEntriesNewestFirst() async {
final log = await readLog();
final entries =
[
for (final dayEntries in log.values)
...dayEntries.where((e) => !e.deleted),
]..sort((a, b) {
final aTime = DateTime.tryParse(a.time);
final bTime = DateTime.tryParse(b.time);
if (aTime == null || bTime == null) return 0;
return bTime.compareTo(aTime);
});
return entries;
}
/// Today's total calories, mirrors `_state.today_total_kcal`.
Future<double> todayTotalKcal() async {
final entries = await todayEntries();
var total = 0.0;
for (final entry in entries) {
total += entry.kcal;
}
return double.parse(total.toStringAsFixed(1));
}
/// Tombstones the entry with [id] wherever it appears in the log.
///
/// Silently does nothing when the id is not found or the entry is already
/// deleted — covers both legacy null-id entries and double-delete races.
Future<void> deleteEntry(String id) async {
final log = await readLog();
for (final entries in log.values) {
for (var i = 0; i < entries.length; i++) {
if (entries[i].id == id && !entries[i].deleted) {
entries[i] = entries[i].copyWithDeleted();
await writeLog(log);
return;
}
}
}
}
/// Replaces the stored entry matching [original] with [updated].
///
/// Matches by [FoodEntry.id] when present; falls back to
/// `time + desc` for legacy entries that predate UUID support.
/// Silently does nothing when no match is found.
Future<void> updateEntry(FoodEntry original, FoodEntry updated) async {
final log = await readLog();
for (final entries in log.values) {
for (var i = 0; i < entries.length; i++) {
final e = entries[i];
final matches = original.id != null
? e.id == original.id
: e.time == original.time && e.desc == original.desc;
if (matches) {
entries[i] = updated;
await writeLog(log);
return;
}
}
}
}
/// Returns today's slot minutes already satisfied, mirrors
/// `_state.logged_slots_today`.
///
/// Each entry satisfies the slot *nearest* its recorded minute under the
/// schedule in force now. Stored minutes are never rewritten, so an exact
/// match would let a schedule edit (07:00 -> 07:15) un-log a meal already
/// eaten and re-nag for it -- and disagree with the PC, which snaps too.
Future<Set<int>> loggedSlotsToday() async {
final entries = await todayEntries();
return satisfiedSlots([
for (final entry in entries) ?entry.slotMinute,
], MealScheduleService.current);
}
}