diet-guard/diet_guard/_cli_kuchnia.py

"""CLI handler for the ``kuchnia`` subcommand.

Fetches today's catering delivery, banks the dishes, and -- only with an
explicit confirmation -- logs them.  Dry run by default: the whole point of
this feature is that a *delivered* meal is not an *eaten* meal, so writing
entries is always something the user asks for, never something that happens
because a command ran.

Structured like :mod:`diet_guard._cli_prune`: lazy attributes so registering
the subparser drags no HTTP stack into every other command, ``emit`` passed in
rather than imported, and an int exit code.
"""

from __future__ import annotations

from importlib import import_module
import sys
from typing import TYPE_CHECKING

from diet_guard._kuchnia_spread import assign_slots
from diet_guard._meal_schedule_store import current_schedule
from diet_guard._slots import day_slots, slot_label
from diet_guard._state import now_local
from diet_guard._sync_events import publish_after_log

if TYPE_CHECKING:  # pragma: no cover - typing only
    import argparse
    from collections.abc import Callable, Sequence

    from diet_guard._kuchnia_spread import SlottedDish

# ``_kuchnia_import`` reaches ``requests``; registering this subparser must not
# make every other command pay for an HTTP stack.
_LAZY_ATTRS = {
    "refresh_delivery": ("diet_guard._kuchnia_import", "refresh_delivery"),
    "log_dishes": ("diet_guard._kuchnia_log", "log_dishes"),
    "fill_plan": ("diet_guard._kuchnia_log", "fill_plan"),
}


def __getattr__(name: str) -> object:
    """Resolve the deferred import helpers on first attribute access."""
    target = _LAZY_ATTRS.get(name)
    if target is None:
        msg = f"module {__name__!r} has no attribute {name!r}"
        raise AttributeError(msg)
    module_name, attr = target
    return getattr(import_module(module_name), attr)


def register_kuchnia_subparser(sub: argparse._SubParsersAction) -> None:
    """Register the ``kuchnia`` subcommand on ``sub``."""
    kuchnia = sub.add_parser(
        "kuchnia",
        help="Import today's Kuchnia Wikinga delivery into the food bank.",
    )
    kuchnia.add_argument(
        "--log",
        action="store_true",
        help="Also log the dishes into today's empty slots (asks first unless --yes).",
    )
    kuchnia.add_argument(
        "--yes",
        action="store_true",
        help="Skip the confirmation prompt for --log (for scripting).",
    )


def cmd_kuchnia(
    emit: Callable[[str], None],
    ask: Callable[[str], str],
    *,
    log: bool,
    yes: bool,
) -> int:
    """Import today's delivery; with ``--log``, offer to log it too.

    Args:
        emit: A one-line output sink.
        ask: A prompt function (``_cli._ask``), used only for the confirmation.
        log: Offer to write log entries as well as banking the dishes.
        yes: Skip the confirmation prompt.

    Returns:
        0 on success, 1 when the catering panel could not be read.
    """
    module = sys.modules[__name__]
    # now_local() is the repo's tz-aware clock; its date is the same local
    # calendar day the log is keyed by.
    today = now_local().date()
    dishes, reason = module.refresh_delivery(today)
    if reason is not None:
        emit(f"catering unavailable: {reason}")
        return 1
    if not dishes:
        emit("no catering delivery today.")
        return 0

    slotted = assign_slots(dishes, day_slots(current_schedule()))
    emit(f"{len(dishes)} dish(es) delivered today, banked:")
    for item in slotted:
        emit(
            f"  {slot_label(item.slot)}  {item.dish.name}  "
            f"({item.dish.kcal:g} kcal, {item.dish.grams:g} g)",
        )
    total = sum(dish.kcal for dish in dishes)
    emit(f"  total: {total:g} kcal")

    if not log:
        emit("not logged -- pass --log to record these as eaten.")
        return 0
    _log_into_empty_slots(module.fill_plan(slotted), emit, ask, yes=yes)
    return 0


def _log_into_empty_slots(
    plan: Sequence[SlottedDish],
    emit: Callable[[str], None],
    ask: Callable[[str], str],
    *,
    yes: bool,
) -> None:
    """Confirm, then log ``plan`` -- the same rule as the gate's "Fill all".

    Args:
        plan: The dishes whose slots are still empty today (``fill_plan``).
        emit: A one-line output sink.
        ask: A prompt function, used only for the confirmation.
        yes: Skip the confirmation prompt.
    """
    if not plan:
        emit("every slot already logged today; nothing to add.")
        return
    question = f"log {len(plan)} into today's empty slots as eaten? [y/N] "
    if not yes and ask(question).strip().lower() != "y":
        emit("nothing logged.")
        return
    module = sys.modules[__name__]
    written = module.log_dishes(plan)
    emit(f"logged {len(written)} meal(s).")
    # Push now, like every other write path: until a peer sees these, the
    # phone keeps offering the same dishes and invites a double log.
    failure = publish_after_log()
    if failure is not None:
        emit(f"saved locally, not yet published ({failure}).")