diet-guard/app/lib/services/kuchnia_spread.dart
Krzysztof kuhy Rudnicki f83938bfe3 app: minute-of-day slots (phase 2 of 3: every app consumer)
- FoodEntry.slot -> slotMinute: read via entrySlotMinute, written via
  slotFields (whole-hour stays byte-identical, else slot_min), kept by
  copyWithDeleted and the edit screen, so the phone never republishes a
  stripped copy of a PC entry. Out-of-range peer values echo, never throw.
- Satisfaction is nearest-slot snapping (satisfiedSlots) everywhere:
  loggedSlotsToday, due check, kuchnia occupancy, future-day logged set
  (that day's schedule), slot selector. Schedule edits no longer un-log.
- Future pre-log builds DateTime from slot ~/ 60, slot % 60.
- Schedule history + sync go through scheduleToWire/scheduleFromWire.
- Notifications: ids are slot minutes; syncToSlots cancels whatever the
  platform reports active (getActiveNotifications, reminder channel) that
  is not due, covering legacy hour ids; full 0..1439 sweep only if the
  lookup throws.
- Settings: 15-minute dropdowns + "Custom..." (24h showTimePicker), off-grid
  values always selectable, counts capped by grid capacity; editor moved
  to widgets/meal_schedule_editor.dart + meal_time_dropdown.dart.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015npsYVB2PdtWkG7MPAi4tn
2026-10-10 19:55:26 +02:00

116 lines
4.7 KiB
Dart

/// Assigns catering dishes to meal slots, in the provider's own order.
///
/// The Dart mirror of `diet_guard/_kuchnia_spread.py`.
///
/// The panel returns each dish with a `mealPriority` (1..N: Śniadanie, II
/// śniadanie, Obiad, Podwieczorek, Kolacja) -- the order the catering intends
/// them to be eaten in. That beats inferring an order from the dish names, and
/// it beats spreading them arithmetically.
///
/// Counts rarely match: a 5-meal plan against the default 4 slots means two
/// dishes share the first slot. The mapping is `i * S ~/ N`, which is
/// monotonic non-decreasing, keeps the first dish on the first slot and the
/// last on the last, and doubles up the earliest slots rather than dropping
/// anything.
///
/// **Integer `~/` only, never `round()`.** Repo convention for slot arithmetic
/// (`docs/meal-schedule.md`): Python's `round` is banker's and Dart's is
/// half-away-from-zero, so a float path silently desyncs the two devices --
/// and a slot one device offers while the other does not is a checkpoint that
/// can never be satisfied, i.e. a permanent lock. `index`, `span` and `count`
/// are all `int`, so `~/` matches Python's `//` exactly (`~/` on doubles
/// truncates toward zero where `//` floors).
///
/// KEEP IN SYNC WITH `diet_guard/_kuchnia_spread.py`, gated by
/// `tests/fixtures/kuchnia_day.json`.
library;
import 'package:diet_guard_app/models/kuchnia_dish.dart';
/// A dish paired with the meal-slot minute it was assigned to.
class SlottedDish {
/// Pairs [dish] with the [slot] minute it should be logged against.
const SlottedDish({required this.dish, required this.slot});
/// The dish itself.
final KuchniaDish dish;
/// The slot's minute of day, e.g. `720` for the 12:00 checkpoint.
final int slot;
}
/// Pairs each dish with a slot minute, following the provider's meal order.
///
/// Returns an empty list when either input is empty -- a day with no delivery
/// and a schedule with no slots are both "nothing to assign", not errors.
List<SlottedDish> assignSlots(List<KuchniaDish> dishes, List<int> slots) {
if (dishes.isEmpty || slots.isEmpty) return const [];
// Ties fall back to name so the result is deterministic; a bank import that
// reshuffled between runs would look like a change and re-stamp every
// record.
//
// The payload index is the final tiebreak because `List.sort` is *not*
// stable in Dart while Python's `sorted` is: two dishes sharing both
// priority and name would otherwise be free to swap here and not on the PC.
// With the index in the comparator the ordering is total, so both languages
// agree without relying on either sort's stability.
final indexed = <(int, KuchniaDish)>[
for (var i = 0; i < dishes.length; i++) (i, dishes[i]),
]..sort((a, b) {
final byPriority = a.$2.priority.compareTo(b.$2.priority);
if (byPriority != 0) return byPriority;
final byName = a.$2.name.compareTo(b.$2.name);
if (byName != 0) return byName;
return a.$1.compareTo(b.$1);
});
final count = indexed.length;
final span = slots.length;
return [
for (var index = 0; index < count; index++)
SlottedDish(
dish: indexed[index].$2,
slot: slots[index * span ~/ count],
),
];
}
/// Returns [dishes] ordered by the provider's own meal priority.
///
/// So the dish offered for the slot being filled is the one the catering
/// actually intends for it, rather than whatever order the payload arrived in.
List<KuchniaDish> dishesInSlotOrder(
List<KuchniaDish> dishes,
List<int> slots,
) => [for (final item in assignSlots(dishes, slots)) item.dish];
/// Returns `(portionGrams, (kcal, protein, carbs, fat))` as form strings.
///
/// Phone-only, deliberately: this form logs the fields as typed, so writing
/// the dish's whole-portion macros into them is correct. The PC gate's form
/// scales its macros from a "per" basis to the amount eaten, so it goes
/// through `_kuchnia_log.dish_nutrition` (basis = the dish's own grams)
/// instead -- filling its fields this way logged 3.5x the calories.
/// Formatted here rather than in the widget so the numeric formatting is
/// covered by a test that needs no display.
///
/// Python uses `f"{value:g}"`, which drops a trailing `.0`; Dart's
/// `toStringAsFixed` would keep it and `toString` would render `435.0`. So a
/// whole number is printed as an integer and anything else keeps its
/// decimals -- the form should read "435", not "435.0".
(String, (String, String, String, String)) dishFieldValues(KuchniaDish dish) {
String format(double value) => value == value.roundToDouble()
? value.toInt().toString()
: value.toString();
return (
format(dish.grams),
(
format(dish.kcal),
format(dish.proteinG),
format(dish.carbsG),
format(dish.fatG),
),
);
}