diet-guard/diet_guard/_gatelock_fillall.py

"""The lock screen's "Fill all" button: today's catering into every empty slot.

Two clicks, never one. The first fetches the day's delivery off the Tk thread
and shows exactly what would be written; the button relabels to "Confirm (N)".
Only the second click writes. A delivered meal is not an eaten meal, so the
user sees the dishes and the slots before anything lands -- and no modal
dialog asks instead, because a pop-up over a fullscreen grab risks stealing the
very keyboard grab the lock depends on.

This is *composed* into the gate rather than mixed in: pylint's
``max-parents`` already counts every class in the gate's MRO, so a new mixin
fails the hook, and module functions reaching into the gate trip ``SLF001``.
The gate hands this object the few callables it needs instead.

Which slots get filled -- every slot today, skipping any that already holds an
entry -- is :func:`diet_guard._kuchnia_log.fill_plan`, shared with
``diet-guard kuchnia --log`` so the CLI and the gate cannot disagree.
"""

from __future__ import annotations

from importlib import import_module
import queue
from typing import TYPE_CHECKING, NamedTuple

from diet_guard import _gatelock_glyphs as g
from diet_guard._gatelock_fetch import FETCH_POLL_MS
from diet_guard._gatelock_kuchnia import start_delivery_fetch
from diet_guard._kuchnia_log import fill_plan, log_dishes
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

if TYPE_CHECKING:  # pragma: no cover - typing only
    from collections.abc import Callable, Sequence
    from datetime import date
    import tkinter as tk

    from diet_guard._gatelock_kuchnia import DeliveryResult, RefreshFn
    from diet_guard._kuchnia_parse import Dish
    from diet_guard._kuchnia_spread import SlottedDish

#: The button's resting label; also what it returns to after each attempt.
FILL_LABEL = f"{g.FILL_ALL} {g.DELIVERY}"

#: ``(unlock reason, nothing-new status)`` for the gate's post-write reconcile:
#: a fill that covered only later slots must not report "found in sync" --
#: catering logged, and the food field is what the current slot still needs.
RECONCILE_LABELS = (
    f"{g.OK} {g.DELIVERY}",
    f"{g.OK} {g.DELIVERY}  {g.FOOD}",
)

#: "Every slot already has a meal": nothing left for the fill to take.
_NOTHING_TO_FILL = f"{g.OK} {g.CLOCK}"


def _refresh_delivery(day: date) -> tuple[Sequence[Dish], str | None]:
    """Fetch ``day``'s dishes, importing the HTTP stack only when clicked.

    ``_kuchnia_import`` reaches ``requests``; the gate's frequent not-due tick
    imports this module and must not pay for it.
    """
    refresh: RefreshFn = import_module("diet_guard._kuchnia_import").refresh_delivery
    return refresh(day)


class FillHooks(NamedTuple):
    """What the flow calls back into the gate."""

    #: The gate's status-line writer.
    set_status: Callable[..., None]
    #: Called after a write, so the gate drops the slots it now covers and
    #: unlocks when none remain.
    on_logged: Callable[[], None]


class FillAllFlow:
    """Drives one gate's "Fill all" button through fetch, confirm and log."""

    def __init__(
        self,
        root: tk.Misc,
        label: tk.StringVar,
        hooks: FillHooks,
        *,
        demo_mode: bool,
    ) -> None:
        """Bind the flow to a gate.

        Args:
            root: Schedules the poll on the Tk thread.
            label: The button's text, shared by its copy on every monitor.
            hooks: The gate callbacks the flow drives.
            demo_mode: A demo window refuses: it must never write real
                entries from a delivery note.
        """
        self._root = root
        self._label = label
        self._demo_mode = demo_mode
        self._set_status = hooks.set_status
        self._on_logged = hooks.on_logged
        self._result: queue.Queue[DeliveryResult] | None = None
        self._plan: list[SlottedDish] = []
        self._plan_day: date | None = None

    def click(self) -> None:
        """First click fetches and proposes; a second click confirms."""
        if self._demo_mode:
            self._set_status(f"{g.DEMO_ONLY} {g.FILL_ALL}")
            return
        if self._result is not None:
            return  # a fetch is in flight; a double-click must not start two
        today = now_local().date()
        if self._plan and self._plan_day == today:
            self._confirm()
            return
        # No plan, or one proposed before midnight: fetch (again). The day is
        # pinned here, not when the result lands, so a fetch still in flight
        # at midnight can never confirm yesterday's menu into today.
        self._reset()
        self._plan_day = today
        self._set_status(f"{g.BUSY} {g.DELIVERY}")
        self._result = start_delivery_fetch(_refresh_delivery, today)
        self._root.after(FETCH_POLL_MS, self._poll)

    def _poll(self) -> None:
        """On the Tk thread: turn the fetched dishes into a proposal."""
        result = self._result
        if result is None:
            return
        try:
            outcome = result.get_nowait()
        except queue.Empty:
            self._root.after(FETCH_POLL_MS, self._poll)
            return
        self._result = None
        if outcome.reason is not None:
            self._set_status(f"{g.ERROR} {g.DELIVERY}", error=True)
            return
        if not outcome.dishes:
            self._set_status(f"{g.EMPTY} {g.DELIVERY}")
            return
        plan = fill_plan(assign_slots(outcome.dishes, day_slots(current_schedule())))
        if not plan:
            self._set_status(_NOTHING_TO_FILL)
            return
        self._plan = plan
        self._label.set(f"{g.OK} {len(plan)}")
        total = sum(item.dish.kcal for item in plan)
        # The proposal: slot time and dish name (catering content) per row.
        listing = "   ".join(
            f"{slot_label(item.slot)} {item.dish.name}" for item in plan
        )
        self._set_status(f"{g.DELIVERY} {len(plan)}  {total:g} kcal   {listing}")

    def _confirm(self) -> None:
        """Write the proposed dishes into the slots still empty right now."""
        # Re-checked at write time: a meal typed in between the two clicks
        # has taken its slot, and must keep it.
        plan = fill_plan(self._plan)
        self._reset()
        if not plan:
            self._set_status(_NOTHING_TO_FILL)
            return
        written = log_dishes(plan)
        self._set_status(f"{g.OK} {g.DELIVERY} {len(written)}")
        self._on_logged()

    def _reset(self) -> None:
        """Forget any proposal and restore the button's label."""
        self._plan = []
        self._plan_day = None
        self._label.set(FILL_LABEL)