"""UvcSource must fail LOUD when a camera won't open, and try to REOPEN a camera that goes
dead mid-run — a USB cam on a 24/7 Pi browns out / gets unplugged, and today read() would
return (False, None) forever while the daemon looks perfectly healthy.

No hardware: a fake capture is injected via the `_open` factory."""
import pytest

from edge.adapters.uvc_source import UvcSource


class _FakeCap:
    def __init__(self, frames, opened=True):
        # frames: list of (ok, frame) tuples served in order; exhausted -> (False, None)
        self._frames = list(frames)
        self._opened = opened
        self.released = 0
        self.sets = 0

    def isOpened(self):
        return self._opened

    def read(self):
        return self._frames.pop(0) if self._frames else (False, None)

    def set(self, *a):
        self.sets += 1

    def release(self):
        self.released += 1


def test_open_failure_raises_loudly():
    # A device that never opens must raise at construction so build_runtimes logs+skips it,
    # not silently construct a dead capture.
    with pytest.raises(RuntimeError, match="failed to open"):
        UvcSource(0, mjpeg=False, _open=lambda dev: _FakeCap([], opened=False))


def test_read_proxies_a_live_frame():
    cap = _FakeCap([(True, "frameA")])
    src = UvcSource(0, mjpeg=False, _open=lambda dev: cap)
    assert src.read() == (True, "frameA")


def test_dead_camera_is_reopened_after_a_threshold():
    opens = []

    def opener(dev):
        cap = _FakeCap([], opened=True)   # opens fine but delivers no frames
        opens.append(cap)
        return cap

    src = UvcSource(0, mjpeg=False, reopen_after=3, _open=opener)
    assert len(opens) == 1
    for _ in range(3):                     # 3 consecutive dead reads -> exactly one reopen
        assert src.read() == (False, None)
    assert len(opens) == 2, "camera should be reopened after reopen_after failures"
    assert opens[0].released == 1, "the dead capture should be released before reopening"


def test_recovery_resets_the_failure_streak():
    # F, F, live, F, F with reopen_after=3 never has 3-in-a-row, so no reopen must fire.
    cap = _FakeCap([(False, None), (False, None), (True, "ok"), (False, None), (False, None)])
    opens = {"n": 0}

    def opener(dev):
        opens["n"] += 1
        return cap

    src = UvcSource(0, mjpeg=False, reopen_after=3, _open=opener)
    assert opens["n"] == 1                  # initial open only
    for _ in range(5):
        src.read()
    assert opens["n"] == 1, "a recovered read must reset the streak so no reopen fires"