"""The gamepad, as it arrives from `dora-joy`.

The pad itself lives in another node now. What reaches this one is a plain
reading on the `joy` input, and this module is the seam the loop reads it
through: :class:`Sample` is what the rest of the node sees, exactly as it did
when the pad was read in-process.

**The safety-critical part is :meth:`JoyInput.read`.** Moving the pad into
another process added a way for it to go away that did not exist before — that
process dying — and from here that looks like silence rather than like an
unplugged pad. So silence past `JOY_TTL_S` reads as *absent*, which is the same
answer, because a reading nobody is refreshing is not evidence of anything.
`dora-joy` publishes on every tick whether or not the pad moved, so silence
means one thing only.
"""

import time
from dataclasses import dataclass, field


@dataclass(frozen=True)
class Sample:
    """One reading of the pad.

    ``present`` is the one that matters for safety: a pad that has been
    unplugged reads as absent rather than as centred, so the difference between
    "the operator let go" and "the operator's pad fell off the desk" is not lost.
    """

    axes: list[float] = field(default_factory=list)
    buttons: list[bool] = field(default_factory=list)
    present: bool = False


ABSENT = Sample()


def decode(event: dict) -> Sample:
    """Read one `joy` message into a reading.

    A message this node cannot make sense of reads as absent rather than as
    centred, for the same reason an unplugged pad does.
    """
    value = event["value"]
    if not len(value):
        return ABSENT
    row = value[0].as_py()
    return Sample(
        axes=list(row.get("axes") or []),
        buttons=[bool(down) for down in row.get("buttons") or []],
        present=bool(row.get("present")),
    )


class JoyInput:
    """The latest reading, and how long ago it arrived."""

    def __init__(self, ttl_s: float):
        self.ttl_s = ttl_s
        self._sample = ABSENT
        self._seen_at = 0.0

    def accept(self, sample: Sample, moment: float) -> None:
        """Take one reading off the wire."""
        self._sample = sample
        self._seen_at = moment

    def read(self, moment: float) -> Sample:
        """Return the current reading, or absence if nobody is still sending one.

        A stale reading is not a reading. `dora-joy` publishes every tick, so
        silence means it died, and a dead pad node is indistinguishable from an
        unplugged pad as far as the arm is concerned — which is the only safe
        way to read it.
        """
        if moment - self._seen_at > self.ttl_s:
            return ABSENT
        return self._sample


def now() -> float:
    """Return the clock the deadman runs on: monotonic, so it cannot step backwards."""
    return time.monotonic()