"""Shared poll-loop scaffolding for the provider job pollers.

``runpod/jobs.py:poll_job`` and ``vast/jobs.py:poll_vast_job`` are independent live
poll loops with provider-specific terminal-state logic, but they share three verbatim
blocks: a timestamped ``say()`` logger, a consecutive-poll-error retry/give-up counter,
and the heartbeat progress-surfacing block (key on (stage, step, ts), log
``worker: stage=… step=… reward=…``). Only those provider-neutral pieces live here; each
poller keeps its own status/terminal handling inline.
"""

from __future__ import annotations

import time
from collections.abc import Callable
from typing import Any


def make_say(log) -> Callable[[str], None]:
    """A timestamped line logger that no-ops when ``log`` is None."""

    def say(msg: str) -> None:
        if log is not None:
            print(f"[{time.strftime('%H:%M:%S')}] {msg}", file=log, flush=True)

    return say


class PollErrorTracker:
    """Counts consecutive poll errors and decides when to give up.

    Encapsulates the identical retry block both pollers use: on a transient fetch
    error, log it, give up after ``max_errors`` consecutive failures, otherwise sleep
    a linear backoff (capped at 60 s) before the caller retries.
    """

    def __init__(self, say: Callable[[str], None], interval_s: float, max_errors: int = 8) -> None:
        self._say = say
        self._interval_s = interval_s
        self._max_errors = max_errors
        self._count = 0

    def reset(self) -> None:
        self._count = 0

    def record(self, exc: Exception) -> bool:
        """Register a poll error. Returns True if the caller should give up (too many),
        else sleeps the backoff and returns False (caller should ``continue``)."""
        self._count += 1
        self._say(f"poll error ({self._count}): {exc}")
        if self._count >= self._max_errors:
            return True
        time.sleep(min(60, self._interval_s * self._count))
        return False


def surface_heartbeat(
    heartbeat_reader: Callable[[], Any] | None,
    last_hb_key: tuple | None,
    say: Callable[[str], None],
) -> tuple[tuple | None, str | None]:
    """Read a heartbeat and, if it advanced, log worker progress.

    Returns ``(hb_key, stage)`` where ``hb_key`` is the new (stage, step, ts) key (or the
    unchanged ``last_hb_key`` when nothing advanced) and ``stage`` is the stage of the new
    heartbeat when it advanced (else None). Callers use the returned ``stage`` for their
    own setup-vs-training stall bookkeeping.
    """
    if heartbeat_reader is None:
        return last_hb_key, None
    try:
        hb = heartbeat_reader()
    except Exception:
        hb = None
    if not hb:
        return last_hb_key, None
    key = (hb.get("stage"), hb.get("step"), hb.get("ts"))
    if key == last_hb_key:
        return last_hb_key, None
    stage = hb.get("stage")
    step = hb.get("step")
    reward = hb.get("reward")
    say(
        f"worker: stage={stage}"
        + (f" step={step}" if step is not None else "")
        + (f" reward={reward:.3f}" if isinstance(reward, (int, float)) else "")
    )
    return key, stage