"""End-to-end: the capture request and the per-leg encoder parameters follow
the selected quality preset.

`pickSurface()` asks the capture device for the *selected* preset's pixel
budget and frame rate instead of one hardcoded 4K/30 request, and `start()`
records which preset the live capture belongs to. The capture assertions read
the page's own request back through `window.__probe` (AGENTS.md §6):
`lastRequested` is the size the request named, `qualityKey` the preset it
came from.

The per-leg assertions read the *committed* sender parameters back from the
sharer's real RTCPeerConnection legs through the same `__probe` handle:
each leg encodes under `round(config.maxBitrateBps * preset.factor)` and the
preset's `degradationPreference`, read at call time — so a preset chosen
before a viewer joins lands on that leg's first offer. Media rules still
govern: pixel assertions are made on the *viewer's* `<video>`.

Delivered *capture* pixels are deliberately not asserted here: with
`--use-fake-device-for-media-stream` the synthetic device is a fixed
1280x720 and its clamping is not the behaviour under test (PLAN §5). Where
a real capturer runs (`MIRROR_REALDISPLAY=1`, the `realdisplay` suite) the
delivered pixels are asserted instead.

The late-joining-viewer case proves the *first offer* of a leg that comes
up under a preset chosen before that viewer joined carries the preset's cap:
a new `RTCPeerConnection` is wrapped on the sharer page (the same pattern the
other e2e suites use for their `RTCPeerConnection` probes) and the parameters
are read back at `setLocalDescription` — before `negotiate()`'s
post-negotiation re-apply has run, so the only code that could have written
them is `addPeer()`'s `sendEncodings`.
"""

from __future__ import annotations

import re
import time

import pytest
from playwright.sync_api import expect

from .conftest import _start, _stop, frames_matching, start_sharing, stop_sharing

pytestmark = [pytest.mark.e2e, pytest.mark.timeout(180)]


@pytest.fixture
def device(base_url, browser, request):
    """Open a page as its own device (isolated context, fresh peer id).

    `url` targets a different server than the session's (the zero-cap
    fixture); the default is the session server, which is what the capture-
    request tests use.
    """
    opened = []

    def _open(path: str = "/", errors: list | None = None, url: str | None = None):
        context = browser.new_context(viewport={"width": 1100, "height": 720})
        opened.append(context)
        request.addfinalizer(context.close)
        page = context.new_page()
        if errors is not None:
            page.on("pageerror", lambda error: errors.append(f"pageerror: {error}"))
        page.goto(f"{url or base_url}{path}", wait_until="domcontentloaded")
        expect(page.locator("#net")).to_have_attribute("data-state", "online", timeout=10_000)
        return page

    return _open


@pytest.fixture
def zero_cap_url():
    """A real `mirror serve` with `MIRROR_MAX_BITRATE=0` — the "uncapped"
    setting of the WebRTC API, which must not turn into a 0 bps leg."""
    url, process = _start(extra_env={"MIRROR_MAX_BITRATE": "0"})
    yield url
    _stop(process)


# Reads the video sender's committed parameters back from the sharer's live
# legs (copied per suite from test_sender_fidelity.py — one copy per suite is
# the convention). `state` is the leg's connectionState; `maxBitrate` is the
# cap the leg is actually encoding under (undefined when none was written —
# it reads back as null — which is exactly the "uncapped" state). If the
# server had written a 0 bps cap it would read back as 0, and the zero-cap
# test's `is None` assertion is what keeps the two apart.
SENDER_PROBE = """() => {
  const probe = window.__probe;
  if (!probe) return null;
  return [...probe.peers.values()].map((peer) => {
    const sender = peer.pc.getSenders().find(
      (s) => s.track && s.track.kind === "video"
    );
    if (!sender) return null;
    const params = sender.getParameters();
    const encodings = params.encodings || [];
    return {
      state: peer.pc.connectionState,
      degradationPreference: params.degradationPreference,
      maxBitrate: encodings.length ? encodings[0].maxBitrate : null,
    };
  });
}"""


def _wait_for(sharer, want: int, pred, timeout: float = 45.0) -> list:
    """Poll the sharer's legs until `want` of them satisfy `pred` (or give up)."""
    legs: list = []
    deadline = time.time() + timeout
    while time.time() < deadline:
        legs = sharer.evaluate(SENDER_PROBE) or []
        if len(legs) == want and all(leg and pred(leg) for leg in legs):
            return legs
        time.sleep(0.5)
    return legs


# The page's own request, the preset it came from, the track's contentHint
# (a pure read-back of what start() set — not a delivered pixel), and the
# inputs the page used: screen.width / devicePixelRatio are read *from the
# page* — under Playwright `screen` is the emulated viewport, so hardcoding
# a display size would make this environment-dependent.
REQUEST_PROBE = """() => {
  const probe = window.__probe;
  if (!probe) return null;
  const stream = document.querySelector('#preview').srcObject;
  const track = stream && stream.getVideoTracks()[0];
  return {
    requested: probe.lastRequested,
    qualityKey: probe.qualityKey,
    contentHint: track ? track.contentHint : null,
    screenWidth: screen.width,
    screenHeight: screen.height,
    dpr: window.devicePixelRatio || 1,
  };
}"""

# The pixel ceilings and the per-preset contentHint, the mirror of `PRESETS`
# in share.js: the request is min(screen * dpr, cap). This suite asserts the
# *request* the page built; the table itself is guarded by test_app.py's
# three-preset agreement test.
PRESETS_UNDER_TEST = {
    "sharp": {"cap": (3840, 2160), "contentHint": "detail"},
    "balanced": {"cap": (1920, 1200), "contentHint": "detail"},
    "light": {"cap": (960, 600), "contentHint": "motion"},
}


def _bitrate_format(bps: float) -> str:
    """The mirror of `bitrateFormat` in net.js — the panel's own renderer,
    so the test can recompute the exact line the panel must print."""
    if not bps or bps < 0:
        return "—"
    if bps >= 1e6:
        return f"{bps / 1e6:.1f} Mbps"
    return f"{round(bps / 1e3)} kbps"


class TestQualityPresets:
    def test_each_preset_asks_the_capture_for_its_own_budget(self, device):
        """Each preset drives the capture request: `sharp` is the old
        hardcoded 4K cap (the no-regression argument), `balanced` 1080p-class,
        `light` a small and cheap budget — and the page records which preset
        the live capture belongs to."""
        errors: list = []
        for key, preset in PRESETS_UNDER_TEST.items():
            cap_w, cap_h = preset["cap"]
            sharer = device("/mirror", errors)
            sharer.select_option("#quality", key)
            start_sharing(sharer)
            result = sharer.evaluate(REQUEST_PROBE)
            assert result, "the __probe handle is missing"
            assert result["qualityKey"] == key, result
            # The page's own arithmetic, recomputed from the page's own inputs:
            # min(round(screen * dpr), cap).
            expected_w = min(round(result["screenWidth"] * result["dpr"]), cap_w)
            expected_h = min(round(result["screenHeight"] * result["dpr"]), cap_h)
            assert result["requested"]["width"] == expected_w, result
            assert result["requested"]["height"] == expected_h, result
            # Text-first presets take `detail`; `light` is glanceable, so
            # motion wins over glyph crispness.
            assert result["contentHint"] == preset["contentHint"], result
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_a_light_leg_encodes_at_the_presets_share(self, device, base_url):
        """A leg that comes up under `light` encodes at the preset's share
        of the server's ceiling and with the preset's degradation preference —
        both read from the preset *at call time*: `light` was selected before
        sharing started, so the viewer's leg must carry them from its first
        offer, and the wall must still be moving (a cheaper picture must not
        be a dead one)."""
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        errors: list = []
        sharer = device("/mirror", errors)
        sharer.select_option("#quality", "light")
        start_sharing(sharer)

        viewer = device("/watch", errors)
        expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)

        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs
        assert legs[0]["maxBitrate"] == round(cap * 0.35), legs
        assert legs[0]["degradationPreference"] == "maintain-framerate", legs

        # The cheaper picture still has to be a live one.
        frames = frames_matching(viewer, ".tile video")
        assert frames["distinct"] >= 2, f"a light leg froze: {frames}"
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_each_preset_commits_its_sender_parameters(self, device, base_url):
        """The full committed-parameter matrix, `sharp` first so the
        no-regression leg is the first thing it proves: each preset's live
        leg commits `round(cap * factor)` and the preset's
        `degradationPreference` — read at call time, so the preset selected
        before sharing lands on the leg from its first offer — and the wall
        stays moving on the viewer in every case (a cheaper picture must not
        be a dead one). `sharp` is phase 02's behaviour verbatim: full cap,
        `maintain-resolution`.
        """
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        # The committed-parameter mirror of PRESETS_UNDER_TEST: the factor the
        # server's ceiling is scaled by and the degradation preference the
        # encoder commits to, per preset. `sharp` first: full cap and
        # maintain-resolution is the unchanged phase 02 behaviour.
        committed = {
            "sharp": (1.0, "maintain-resolution"),
            "balanced": (0.6, "balanced"),
            "light": (0.35, "maintain-framerate"),
        }
        for key, (factor, degradation) in committed.items():
            errors: list = []
            sharer = device("/mirror", errors)
            sharer.select_option("#quality", key)
            start_sharing(sharer)
            viewer = device("/watch", errors)
            expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)

            legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
            assert legs and legs[0]["state"] == "connected", (key, legs)
            assert legs[0]["maxBitrate"] == round(cap * factor), (key, legs)
            assert legs[0]["degradationPreference"] == degradation, (key, legs)

            # The picture still has to be a live one in every preset.
            frames = frames_matching(viewer, ".tile video")
            assert frames["distinct"] >= 2, f"the {key} leg froze: {frames}"
            assert errors == [], f"uncaught browser errors on {key}: {errors}"

            # Tear the whole iteration down before the next preset: the
            # contexts outlive the iteration, and the wall auto-subscribes
            # *every live viewer* to *every new mirror* — an uncleaned
            # viewer would stack a second (third, ...) leg on the next
            # preset's sharer and break the one-leg expectation. Stop the
            # share first, so the viewer's tile (and its peer connection)
            # is torn down before its page goes away.
            stop_sharing(sharer)
            viewer.close()
            sharer.close()

    def test_a_zero_cap_stays_uncapped_under_light(self, device, zero_cap_url):
        """`MIRROR_MAX_BITRATE=0` is a real setting — "uncapped" in the
        WebRTC API. `legCap()` must return 0 and no `maxBitrate` may be
        written: an uncapped leg must not become a 0 bps leg. The preset's
        degradation preference still lands, and the picture still moves.
        """
        import httpx

        config = httpx.get(f"{zero_cap_url}/api/config", timeout=5).json()
        assert config["maxBitrateBps"] == 0, config

        errors: list = []
        sharer = device("/mirror", errors, url=zero_cap_url)
        sharer.select_option("#quality", "light")
        start_sharing(sharer)

        viewer = device("/watch", errors, url=zero_cap_url)
        expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)

        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs
        # No maxBitrate written at all: an uncapped leg, not a 0 bps one.
        assert legs[0]["maxBitrate"] is None, legs
        assert legs[0]["degradationPreference"] == "maintain-framerate", legs

        frames = frames_matching(viewer, ".tile video")
        assert frames["distinct"] >= 2, f"the uncapped leg froze: {frames}"
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_changing_quality_mid_share_re_prices_the_live_leg(self, device, base_url):
        """A preset change made while a leg is live re-prices that leg —
        ``setParameters`` commits without an offer, so the CPU/egress
        change is instant and no second RTCPeerConnection is needed for it —
        and the viewer keeps decoding moving frames across the switch. The
        roster must tell the truth in *both* outcomes: its width/height
        equal the track's own ``getSettings()``, whatever the engine
        settled on (the synthetic device clamps; delivered pixels are the
        ``realdisplay`` suite's, task 06)."""
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        errors: list = []
        sharer = device("/mirror", errors)
        start_sharing(sharer)  # the default preset: sharp
        viewer = device("/watch", errors)
        expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)
        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs

        # The switch, mid-share, through the control the user has.
        sharer.select_option("#quality", "light")

        # The single live leg re-prices in place: ``setParameters`` commits
        # within ~5 s of the change, and the connection state returns to /
        # stays ``connected`` (a leg that comes up fresh for the new size
        # reads ``legCap()`` at its first offer, so the cap lands either way).
        def repriced(leg):
            return leg["state"] == "connected" and leg["maxBitrate"] == round(cap * 0.35)

        re = _wait_for(sharer, 1, repriced, timeout=5.0)
        # No second RTCPeerConnection: the roster of live legs is still the
        # one the viewer was subscribed on.
        assert sharer.evaluate("() => window.__probe.peers.size") == 1
        assert re and re[0]["maxBitrate"] == round(cap * 0.35), re
        assert re[0]["state"] == "connected", re

        # The switch did not freeze anybody.
        frames = frames_matching(viewer, ".tile video")
        assert frames["distinct"] >= 2, frames

        # The roster tells the truth: whatever the engine settled on, the
        # published width/height equal the track's own settings. Do not
        # assert a *delivered* size here — the synthetic device clamps, and
        # task 06 owns delivered pixels on a real desktop.
        def track_settings():
            return sharer.evaluate(
                "() => { const s = document.querySelector('#preview').srcObject;"
                " const t = s && s.getVideoTracks()[0];"
                " return t ? t.getSettings() : null; }"
            )

        def roster_agrees():
            settings = track_settings()
            if not settings or not settings.get("width"):
                return False, None, settings
            mirror = httpx.get(f"{base_url}/api/streams", timeout=5).json()["mirrors"]
            assert len(mirror) == 1, mirror
            mirror = mirror[0]
            agrees = mirror["width"] == settings["width"] and mirror["height"] == settings["height"]
            return agrees, mirror, settings

        deadline = time.time() + 10.0
        agrees, mirror, settings = roster_agrees()
        while not agrees and time.time() < deadline:
            time.sleep(0.5)
            agrees, mirror, settings = roster_agrees()
        assert agrees, f"roster does not match the track's own settings: {mirror!r} vs {settings!r}"
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_a_device_that_cannot_rescale_still_changes_rate(self, device, base_url):
        """A display that cannot rescale answers the full constraint with the
        named ``OverconstrainedError``: the retry applies the frame rate
        alone, the leg is still re-priced, the viewer still moves, the
        toast says the size lands on the next share (it does not pretend
        the capture rescaled), and the roster stays truthful."""
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        errors: list = []
        sharer = device("/mirror", errors)
        start_sharing(sharer)
        viewer = device("/watch", errors)
        expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)
        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs

        # Simulate the display: a constraint that carries a size fails with
        # the named error; the frame-rate-only retry passes. (This is the
        # real-world behaviour the retry exists for — a capturer that holds
        # its size — and nothing else in the path is stubbed.)
        sharer.evaluate(
            "() => { const s = document.querySelector('#preview').srcObject;"
            " const t = s.getVideoTracks()[0];"
            " const orig = t.applyConstraints.bind(t);"
            " t.applyConstraints = (c) => (c && c.width)"
            " ? Promise.reject(new DOMException('size cannot be applied', 'OverconstrainedError'))"
            " : orig(c); }"
        )
        sharer.select_option("#quality", "light")

        # The toast lands with the settle (before the leg is measured
        # again), so it is read first: the preset is named, and because
        # the size was never applied the line says it lands next share.
        toast = sharer.locator("#toast")
        expect(toast).to_contain_text("Light", timeout=5_000)
        text = toast.text_content() or ""
        assert "next share" in text, text

        # The leg is still re-priced, and the switch did not freeze anybody.
        def repriced(leg):
            return leg["state"] == "connected" and leg["maxBitrate"] == round(cap * 0.35)

        re = _wait_for(sharer, 1, repriced, timeout=5.0)
        assert re and re[0]["maxBitrate"] == round(cap * 0.35), re
        frames = frames_matching(viewer, ".tile video")
        assert frames["distinct"] >= 2, frames

        # The roster tells the truth about whatever the device delivered.
        def track_settings():
            return sharer.evaluate(
                "() => { const s = document.querySelector('#preview').srcObject;"
                " const t = s && s.getVideoTracks()[0];"
                " return t ? t.getSettings() : null; }"
            )

        def roster_agrees():
            settings = track_settings()
            if not settings or not settings.get("width"):
                return False, None, settings
            mirror = httpx.get(f"{base_url}/api/streams", timeout=5).json()["mirrors"]
            assert len(mirror) == 1, mirror
            mirror = mirror[0]
            agrees = mirror["width"] == settings["width"] and mirror["height"] == settings["height"]
            return agrees, mirror, settings

        deadline = time.time() + 10.0
        agrees, mirror, settings = roster_agrees()
        while not agrees and time.time() < deadline:
            time.sleep(0.5)
            agrees, mirror, settings = roster_agrees()
        assert agrees, f"roster does not match the track's own settings: {mirror!r} vs {settings!r}"
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_a_viewer_who_joins_after_a_switch_gets_the_new_cap(self, device, base_url):
        """The `addPeer` path, not just the re-apply path.

        A preset change mid-share re-prices the *existing* leg (task 04's
        re-apply). This proves the other half: a viewer who subscribes
        *after* the switch gets a leg whose **first offer** already carries
        the new cap — `legCap()` is read at call time in `addPeer()` and
        written into `sendEncodings` before any negotiation exists. The
        sharer's `RTCPeerConnection` is wrapped (the same pattern the other
        e2e suites use for their peer-connection probes) so the parameters
        are read back at `setLocalDescription`, i.e. before `negotiate()`'s
        post-negotiation re-apply has run: the only code that could have
        written them is `addPeer()`'s `sendEncodings`.
        """
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        errors: list = []
        sharer = device("/mirror", errors)
        start_sharing(sharer)  # the default preset: sharp
        first = device("/watch", errors)
        expect(first.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)
        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs
        assert legs[0]["maxBitrate"] == cap, legs

        # The switch, mid-share: the existing leg re-prices via the re-apply.
        sharer.select_option("#quality", "light")

        def repriced(leg):
            return leg["state"] == "connected" and leg["maxBitrate"] == round(cap * 0.35)

        re = _wait_for(sharer, 1, repriced, timeout=5.0)
        assert re and re[0]["maxBitrate"] == round(cap * 0.35), re

        # From here on, every new RTCPeerConnection on the sharer page is
        # the late joiner's leg: the wrapper records the committed parameters
        # at setLocalDescription time, before negotiate()'s re-apply.
        assert sharer.evaluate(
            """() => {
              window.__firstOffers = [];
              const RealPC = window.RTCPeerConnection;
              window.RTCPeerConnection = function (config) {
                const pc = new RealPC(config);
                const orig = pc.setLocalDescription.bind(pc);
                pc.setLocalDescription = (d) => orig(d).then(() => {
                  const sender = pc.getSenders().find(
                    (s) => s.track && s.track.kind === 'video'
                  );
                  const params = sender ? sender.getParameters() : {};
                  const enc = (params.encodings || [])[0] || {};
                  window.__firstOffers.push({
                    maxBitrate: 'maxBitrate' in enc ? enc.maxBitrate : null,
                    degradationPreference: params.degradationPreference || null,
                  });
                  return pc;
                });
                return pc;
              };
              window.RTCPeerConnection.prototype = RealPC.prototype;
              window.RTCPeerConnection.static = RealPC.static;
              return true;
            }"""
        )

        late = device("/watch", errors)
        expect(late.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)

        # Both legs are now live under the switched preset.
        legs = _wait_for(sharer, 2, lambda leg: leg["state"] == "connected")
        assert legs and all(leg["state"] == "connected" for leg in legs), legs

        offers = sharer.evaluate("() => window.__firstOffers") or []
        assert offers, "no first offer was captured from the late joiner's leg"
        # The first offer carried the new cap: addPeer's sendEncodings, not
        # the post-negotiation re-apply, which ran later on the same leg.
        assert offers[-1]["maxBitrate"] == round(cap * 0.35), offers
        # And the settled leg is still capped — nothing drifted after.
        assert all(leg["maxBitrate"] == round(cap * 0.35) for leg in legs), legs
        assert sharer.evaluate("() => window.__probe.peers.size") == 2

        # The late joiner's picture is a live one, and the sharer agrees
        # that two viewers are watching.
        frames = frames_matching(late, ".tile video")
        assert frames["distinct"] >= 2, f"the late joiner froze: {frames}"
        expect(sharer.locator("#viewer-count")).to_have_text("2", timeout=10_000)
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_the_panel_shows_the_budget_and_the_codec(self, device, base_url):
        """The panel says what the share is actually costing (phase 06 task
        05): the quality budget in force — the selected preset, its capture
        ceiling, its frame rate and its per-leg share of the server's cap —
        and the codec the leg actually negotiated, resolved in the same
        `getStats()` read the 1 s tick already makes. The codec is `—` where
        the engine does not report it: the panel must never guess. Both
        lines reset to `—` when the share stops."""
        import httpx

        cap = httpx.get(f"{base_url}/api/config", timeout=5).json()["maxBitrateBps"]
        assert cap > 0

        errors: list = []
        sharer = device("/mirror", errors)
        sharer.select_option("#quality", "balanced")
        start_sharing(sharer)

        # The budget line is written by start() from state: an exact match,
        # not a substring — the panel must not misprice the share. The cap
        # is read live from /api/config (never hardcoded) and scaled by the
        # preset's factor, exactly as legCap() does.
        expected = (
            f"balanced · ≤1920×1200 @24fps · "  # noqa: RUF001 (the panel line itself carries the multiplication sign)
            f"{_bitrate_format(round(cap * 0.6))} /viewer"
        )
        expect(sharer.locator("#stat-quality")).to_have_text(expected, timeout=10_000)

        viewer = device("/watch", errors)
        expect(viewer.locator(".tile[data-state='live']")).to_have_count(1, timeout=25_000)
        legs = _wait_for(sharer, 1, lambda leg: leg["state"] == "connected")
        assert legs and legs[0]["state"] == "connected", legs

        # The codec line is written once per 1 s stats tick (no extra
        # getStats() call): let a tick run after the leg is up, then read it.
        time.sleep(2.5)
        codec = (sharer.locator("#stat-codec").text_content() or "").strip()
        # The shape, not the codec: which one the engine negotiates is not a
        # contract. `—` is the honest floor where the engine does not expose
        # the outbound codec; a name must be the short form
        # (`video/VP8` → `VP8`), never a guess.
        assert codec == "—" or re.fullmatch(r"[A-Z0-9/]{2,16}", codec), codec

        # The share is still a live one while the panel reports on it.
        frames = frames_matching(viewer, ".tile video")
        assert frames["distinct"] >= 2, frames

        # Stopping resets both lines: `—`, not a stale reading.
        stop_sharing(sharer)
        expect(sharer.locator("#stat-quality")).to_have_text("—", timeout=10_000)
        expect(sharer.locator("#stat-codec")).to_have_text("—", timeout=10_000)
        assert errors == [], f"uncaught browser errors: {errors}"

    def test_q_cycles_the_preset_and_says_so(self, device):
        """``q`` cycles the preset on the share page (sharp → balanced →
        light → sharp) and toasts the new one, naming it and its budget;
        a ``q`` typed into ``#name`` is text, not a command, and never
        changes the select (the router's text-field guard)."""
        errors: list = []
        page = device("/mirror", errors)
        toast = page.locator("#toast")

        page.keyboard.press("q")
        expect(page.locator("#quality")).to_have_value("balanced", timeout=5_000)
        assert page.evaluate("() => window.__probe.qualityKey") == "balanced"
        expect(toast).to_contain_text("Balanced", timeout=5_000)
        text = toast.text_content() or ""
        assert "≤1920×1200" in text, text  # noqa: RUF001 (the toast itself carries the multiplication sign)
        # Nothing is shared yet: the capture size lands on the next share,
        # and the line says so rather than pretending it rescaled.
        assert "next share" in text, text

        page.keyboard.press("q")
        expect(page.locator("#quality")).to_have_value("light")
        expect(toast).to_contain_text("Light", timeout=5_000)

        page.keyboard.press("q")
        expect(page.locator("#quality")).to_have_value("sharp")
        expect(toast).to_contain_text("Sharp", timeout=5_000)

        # A ``q`` typed into #name is text, not a command: the select stays.
        page.locator("#name").click()
        page.keyboard.type("q")
        expect(page.locator("#quality")).to_have_value("sharp")

        assert errors == [], f"uncaught browser errors: {errors}"