diet-guard/app/lib/services/kuchnia_spread.dart
Krzysztof kuhy Rudnicki d2df4c51eb
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
file-length / file length <= 250 lines (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (push) Waiting to run
Tests / test (push) Waiting to run
release-apk / release (APK) (push) Waiting to run
Record why the gate's delivery prefill must set the dish's grams as its basis
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-20 08:44:20 +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 hour it was assigned to.
class SlottedDish {
/// Pairs [dish] with the [slot] hour it should be logged against.
const SlottedDish({required this.dish, required this.slot});
/// The dish itself.
final KuchniaDish dish;
/// The slot hour, e.g. `12` for the 12:00 checkpoint.
final int slot;
}
/// Pairs each dish with a slot hour, 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),
),
);
}