# SPDX-License-Identifier: Apache-2.0
"""Node detail screen tests: the mini-map, the tabbed page, and its route and topology helpers.

The screen only renders data and shows routes, so these tests run it with no terminal. The
tests build the display data by hand, in the same way as
:func:`~meshterm.ui.node_detail_screen.open_node_detail`. They render the screen and send
keys to it against a fake session. The tests of the trace screen and of the time machine
screen use the same method. The helpers that use the topology run against a real evidence
graph in memory.
"""

from __future__ import annotations

from types import SimpleNamespace

from rich.text import Text

from meshterm.core.geo import haversine_km
from meshterm.core.models import Contact, utcnow
from meshterm.services.topology import build_topology
from meshterm.services.trace_runner import (
    make_name_key_resolver,
    make_node_resolver,
    make_node_type_resolver,
)
from meshterm.ui.map_render import MapMarker
from meshterm.ui.minimap import MiniMap
from meshterm.ui.node_detail_screen import (
    NodeDetailScreen,
    _Action,
    _bearing,
    _range_text,
    _Route,
    _route_line,
    _routes_view,
    _RoutesView,
    _signal_row,
    _Tab,
)
from meshterm.ui.pathgraph import DST_NODE, SRC_NODE
from meshterm.ui.pathline import CRACK_HEAD, CRACK_TAIL, SELF_GLYPH, PathHop, PathLine
from meshterm.ui.tui.screen import CANCEL, ListWindow
from meshterm.ui.widgets import highlighted_hash, route_graph_style, tab_strip
from tests.conftest import plain as _plain  # the only helper that strips and joins the screen text

US = "aaaaaaaaaaaa"
HUB = Contact(
    name="Hub", public_key="3d63c6429436" + "0" * 52, key_prefix="3d63c6429436", node_type=2
)
FAR = Contact(name="Far", public_key="f2c24f54551e" + "0" * 52, key_prefix="f2c24f54551e")


class _FakeSession:
    def __init__(self) -> None:
        self.repaints = 0

    def invalidate(self) -> None:
        self.repaints += 1


class _OfflineSource:
    """A tile source with no basemap, so the mini-map draws markers on a blank grid."""

    available = False

    def load_tile(self, z: int, x: int, y: int):  # noqa: ANN201
        return None


# --- the mini-map ---------------------------------------------------------------


def test_minimap_offline_renders_markers_on_a_blank_grid() -> None:
    """With no basemap the preview still fills its box and draws the marker of the node."""
    mini = MiniMap(
        _FakeSession(),
        _OfflineSource(),
        14,
        center_lat=45.5,
        center_lon=-73.6,
        zoom=13,
        markers=[MapMarker(label="Hub", lat=45.5, lon=-73.6, is_repeater=True, key="3d63aa")],
    )
    lines = mini.render(40, 6)
    assert len(lines) == 6  # the canvas fills exactly the box of rows that the test requested
    assert mini.pending == 0 and mini.has_basemap is False  # offline: no downloads are planned
    assert any(ch != " " for ch in _plain(lines))  # the marker drew something


def test_minimap_clamps_zoom_to_the_source_ceiling() -> None:
    """A zoom above the maximum of the source (plus overzoom) is clamped. It does not grow."""
    mini = MiniMap(
        _FakeSession(),
        _OfflineSource(),
        10,
        center_lat=0.0,
        center_lon=0.0,
        zoom=99,
        markers=[],
    )
    assert mini._zoom == 12  # max_tile_zoom (10) + overzoom (2)


# --- geographic helpers ---------------------------------------------------------


def test_distance_and_bearing_are_sane() -> None:
    """The range in km and an 8-point compass bearing between two nearby points are correct."""
    # Approximately 1.11 km due north (0.01° latitude), so the bearing is N.
    assert 1.0 < haversine_km(45.5, -73.6, 45.51, -73.6) < 1.2
    assert _bearing(45.5, -73.6, 45.51, -73.6) == "N"
    assert _bearing(45.5, -73.6, 45.5, -73.59) == "E"  # due east


def test_range_text_omits_bearing_without_our_own_fix() -> None:
    """The location value has the range and the bearing only when our node has a position."""
    placed = _plain([_range_text(45.5, -73.6, 45.4, -73.5).plain])
    assert "45.5000, -73.6000" in placed and "km" in placed
    bare = _range_text(45.5, -73.6, None, None)
    assert "km" not in bare.plain and "45.5000" in bare.plain


def test_signal_row_summarizes_snr_and_rssi() -> None:
    """The signal row has the median SNR, the best SNR, and the last RSSI.

    If there is no measurement, the row is absent.
    """
    row = _signal_row(SimpleNamespace(median_snr=3.2, best_snr=7.0, last_rssi=-92.0))
    assert row is not None
    assert "median" in row.plain and "best" in row.plain and "RSSI -92" in row.plain
    # A node with no measurement (or our node) gives no row.
    assert _signal_row(SimpleNamespace(median_snr=None, best_snr=None, last_rssi=None)) is None
    assert _signal_row(None) is None


# --- the tab strip --------------------------------------------------------------


def test_tab_strip_boxes_every_tab_on_top_and_lights_the_active_one() -> None:
    """Each tab has a box across its top. Only the corners and fill of the active tab are lit."""
    group = tab_strip(["Map", "Routes"], 1, width=20)
    top, mid, bot = group.renderables
    assert mid.plain == "│  Map  │  Routes  │"  # both tabs have a box, with one shared vertical
    assert top.plain == "╭───────╭──────────╮"  # the left corner of the active tab opens (it wins)
    assert len(top.plain) == len(mid.plain) == len(bot.plain) == 20  # no fill is necessary yet


def test_tab_strip_bottom_is_a_continuous_rule_notched_at_the_active_tab() -> None:
    """The bottom border is flat under the inactive tabs and opens only under the active tab."""
    group = tab_strip(["Map", "Routes"], 1, width=20)
    top, mid, bot = group.renderables
    # A flat rule is under "Map" (it has no corner of its own). Then the notch turns up
    # (west and north, ╯) into "Routes". It is blank across the width of "Routes" (open into
    # the page). Then it goes down again (north and east, ╰) and continues.
    assert bot.plain == "────────╯          ╰"
    # It is one continuous line: each cell has the grey of the border, the colour of the
    # active tab. The colours are not mixed.
    assert {r.style for r in bot.spans} == {"border"}

    _, _, bot_first = tab_strip(["Map", "Routes"], 0, width=20).renderables
    assert bot_first.plain == "╯       ╰───────────"  # the notch is now under the first tab


def test_tab_strip_unselected_tabs_read_darker_than_muted() -> None:
    """The outlines of the inactive tabs use the dim ``faint`` shade, not the ``muted`` shade."""
    top, mid, _ = tab_strip(["Map", "Routes"], 1, width=20).renderables
    # The own left corner and fill of "Map" (columns 0-7). Its right corner at column 8 is
    # shared with the active "Routes" tab and has the accent, so the test does not use it.
    map_styles = {s.style for s in top.spans if s.start < 8} | {
        s.style for s in mid.spans if s.start < 8
    }
    assert map_styles == {"faint"}


def test_tab_strip_labels_hold_position_across_the_active_index() -> None:
    """If the user selects a different tab, only the corners change light. No label moves."""
    mid_first = tab_strip(["Map", "Routes"], 0, width=20).renderables[1]
    mid_second = tab_strip(["Map", "Routes"], 1, width=20).renderables[1]
    assert mid_first.plain == mid_second.plain == "│  Map  │  Routes  │"
    top_first = tab_strip(["Map", "Routes"], 0, width=20).renderables[0]
    assert top_first.plain == "╭───────╮──────────╮"  # the first tab keeps the plain leading corner


def test_tab_strip_rule_fills_out_to_the_render_width() -> None:
    """The bottom rule of the tab strip runs the full render width.

    Unlike the tabs, the left margin does not indent it. The margin is part of the one
    continuous line.
    """
    top, _, bot = tab_strip(["Map", "Routes"], 1, width=25).renderables
    assert top.plain.startswith("  ╭")  # the tab boxes have an indent...
    assert bot.plain == "──────────╯          ╰───"  # ...but the rule goes straight through
    assert len(bot.plain) == 25


def test_tab_strip_skips_the_margin_when_there_is_no_room() -> None:
    """The left margin of two columns is there only when the width has space for it."""
    top, _, _ = tab_strip(["Map", "Routes"], 1, width=20).renderables
    assert top.plain.startswith("╭")  # width 20 is the natural width of the strip: no space


def test_tab_strip_collapses_a_lone_tab_to_a_plain_heading() -> None:
    """A single tab renders as the plain accent heading, with no box."""
    (lone,) = tab_strip(["Routes"], 0, width=40).renderables
    assert lone.plain == "── Routes ──"


# --- the folded-in route line ---------------------------------------------------


def test_route_line_names_its_hops() -> None:
    """A route line names each hop that it can place.

    The path line goes contact → relays → us, which is the same direction as on the Message
    paths screen. The tag is at the end of the context line.
    """
    path, context = _route_line(
        "Far",
        FAR.public_key,
        ("3d63c6429436",),
        "device",
        None,
        0,
        resolve=make_node_resolver([HUB]),
        node_known=True,
        self_name="Us",
        hash_bytes=1,
    )
    line = path.plain
    assert line.startswith("Far")  # the contact is at the left, with its name
    assert "Hub" in line  # the relay shows as the contact that it is, not as ``3d``
    assert "3d" not in line and "f2" not in line  # no hop repeats its hash after its name
    assert line.rstrip().endswith(SELF_GLYPH)  # our node is at the right, as the ★
    assert "Us" not in line  # …in one cell, not as a name that each row repeats
    # The context starts with the length of the route, then the tag of the firmware route.
    # Both come from the path line.
    assert context.plain == "1 hop  ·  device route"


def test_route_line_greys_hops_nobody_can_name() -> None:
    """A hop that nobody can name shows its hash, in the grey of an unknown node.

    A hop with a name has the hue that comes from its key. A page node with no name looks
    the same as each other node with no name, as the graph draws it.
    """
    from meshterm.ui.theme import node_style

    path, _context = _route_line(
        "f2c24f54551e",
        FAR.public_key,
        ("3d63c6429436", "abcd1234ef56"),
        "",
        None,
        0,
        resolve=make_node_resolver([HUB]),
        node_known=False,
        self_name="Us",
        hash_bytes=1,
    )
    styles = {path.plain[s.start : s.end]: str(s.style) for s in path.spans}
    assert styles.get("ab") == "node.unknown"  # no contact names it, so its hash is grey
    assert styles.get("f2") == "node.unknown"  # the page node with no name has a grey hash
    hued = {
        path.plain[s.start : s.end]
        for s in path.spans
        if str(s.style) == node_style("3d63c6429436")
    }
    assert "Hub" in hued  # the Hub is a contact with a name: its name has its own hue


def test_route_line_hash_width_follows_our_path_hash_mode() -> None:
    """A hash lane has the width that the path hash mode of the device sets.

    Only the hops that have no name to show use hash cells, and they use the cells at that
    width. Here the width is three bytes, not the default of one byte.
    """
    path, _context = _route_line(
        "f2c24f54551e",
        FAR.public_key,
        ("3d63c6429436", "abcd1234ef56"),
        "",
        None,
        0,
        resolve=make_node_resolver([HUB]),
        node_known=False,
        self_name="Us",
        hash_bytes=3,
    )
    line = path.plain
    assert "f2c24f" in line  # the page node with no name, at 3 bytes
    assert "abcd12" in line  # the relay with no name, at 3 bytes
    assert "Hub" in line and "3d63c6" not in line  # the hop with a name does not use them


def test_route_line_marks_the_best_route_and_its_context() -> None:
    """The best route has ★ best, and the context row ends with its weakest SNR and sample count."""
    _path, context = _route_line(
        "Far",
        FAR.public_key,
        ("3d63c6429436",),
        "best",
        6.5,
        4,
        resolve=make_node_resolver([HUB]),
        node_known=True,
        self_name="Us",
        hash_bytes=1,
    )
    line = context.plain
    assert "★ best" in line and "weakest" in line and "6.5" in line and "4×" in line


def test_route_line_direct_route_has_no_relay() -> None:
    """A zero-hop route is contact → us, with nothing between them."""
    path, _context = _route_line(
        "Far",
        FAR.public_key,
        (),
        "best",
        None,
        0,
        resolve=make_node_resolver([HUB]),
        node_known=True,
        self_name="Us",
        hash_bytes=1,
    )
    assert path.plain == f"Far → {SELF_GLYPH}"


# --- the routes view (list + graph callbacks) -----------------------------------


def _topo_with_route():  # noqa: ANN202
    """A graph where Far is reached through the Hub, from evidence of repeated traces."""
    from meshterm.persistence.repository import TracedPath

    walks = [
        TracedPath(when=utcnow(), hops=[("3d", 12.0), ("f2", -5.0), ("3d", -5.5), (None, 12.0)])
        for _ in range(4)
    ]
    return build_topology(
        self_id=US + "0" * 52,
        contacts=[HUB, FAR],
        trace_paths=walks,
        packet_paths=[],
        neighbour_links=[],
    )


def _view(topo, suggested, device_route, target, node_label, contacts, name_key=None):  # noqa: ANN001
    """Build a routes view in the same way as :func:`open_node_detail`, from the given evidence."""
    return _routes_view(
        topo,
        topo.scenarios(target, device_route=device_route),
        suggested,
        device_route,
        target,
        target,
        1,
        resolve=make_node_resolver(contacts),
        type_of=make_node_type_resolver(contacts),
        key_of=make_name_key_resolver(contacts),
        style=route_graph_style,
        self_name="Us",
        node_label=node_label,
        name_key=name_key or (target + "0" * 52),
        node_known=True,
        hash_bytes=1,
    )


def test_routes_view_draws_evidence_and_notes_its_absence() -> None:
    """With route evidence the view has routes to select. Without it, a muted note replaces them."""
    topo = _topo_with_route()
    view = _view(
        topo, topo.suggested("f2c24f54551e"), ("3d63c6429436",), "f2c24f54551e", "Far", [HUB, FAR]
    )
    assert view.routes and view.glyph_of is not None  # a graph, not a note
    assert view.legend is True  # the Hub is a repeater, so the type legend is necessary

    empty = build_topology(
        self_id=US + "0" * 52, contacts=[FAR], trace_paths=[], packet_paths=[], neighbour_links=[]
    )
    note = _routes_view(
        empty,
        empty.scenarios("f2c24f54551e"),
        None,
        None,
        "f2c24f54551e",
        "f2c24f54551e",
        1,
        resolve=make_node_resolver([FAR]),
        type_of=make_node_type_resolver([FAR]),
        key_of=make_name_key_resolver([FAR]),
        style=route_graph_style,
        self_name="Us",
        node_label="Far",
        name_key=FAR.public_key,
        node_known=True,
        hash_bytes=1,
    )
    assert not note.routes and "no route observed" in note.note


def test_routes_view_puts_the_contact_on_the_left_and_us_on_the_right() -> None:
    """The graph goes node → us (the inbound direction): the contact left, our star right."""
    topo = _topo_with_route()
    view = _view(
        topo, topo.suggested("f2c24f54551e"), ("3d63c6429436",), "f2c24f54551e", "Far", [HUB, FAR]
    )
    assert view.label_of(SRC_NODE) == "Far"  # the left end is the target contact
    assert view.glyph_of(DST_NODE)[0] == "★"  # the right end is the star of our node
    assert view.label_of(DST_NODE) == "Us"  # …with the label for our node


def test_routes_view_tags_every_relay_with_its_hash_byte_alone() -> None:
    """In the graph, a relay has only its first hash byte as its label.

    Only the two ends have names, also when a contact can name the relay. Thus a label is
    never longer than two cells, and it does not go across the lanes that are next to it.
    This is the same rule as the graph of the Message paths screen.
    """
    topo = _topo_with_route()
    view = _view(
        topo, topo.suggested("f2c24f54551e"), ("3d63c6429436",), "f2c24f54551e", "Far", [HUB, FAR]
    )
    assert view.label_of("3d63c6429436") == "3d"  # the Hub is a known contact: the label is ``3d``

    unnamed = _view(topo, None, ("abcd1234ef56",), "f2c24f54551e", "Far", [FAR])
    assert unnamed.label_of("abcd1234ef56") == "ab"  # a relay with no name has the same label


def test_routes_view_target_wears_its_node_type_glyph() -> None:
    """The left end shows the target's own map mark (a repeater ▲), not a plain dot."""
    from meshterm.persistence.repository import TracedPath

    leaf = Contact(name="Leaf", public_key="27d4396a2967" + "0" * 52, key_prefix="27d4396a2967")
    # Reach the Hub (a repeater) through the Leaf, so the Hub is the left end in the drawing.
    walks = [
        TracedPath(when=utcnow(), hops=[("27d4", 8.0), ("3d", 6.0), ("27d4", 6.0), (None, 8.0)])
        for _ in range(3)
    ]
    topo = build_topology(
        self_id=US + "0" * 52,
        contacts=[HUB, leaf],
        trace_paths=walks,
        packet_paths=[],
        neighbour_links=[],
    )
    view = _view(
        topo,
        topo.suggested("3d63c6429436"),
        None,
        "3d63c6429436",
        "Hub",
        [HUB, leaf],
        name_key=HUB.public_key,
    )
    assert view.glyph_of(SRC_NODE)[0] == "▲"  # the repeater that is the target keeps its glyph


def test_routes_view_draws_routes_inbound_reversing_the_hop_order() -> None:
    """A drawn route goes node → us: the outbound hops (from us) reverse to inbound order."""
    r1 = Contact(name="R1", public_key="111111111111" + "0" * 52, key_prefix="111111111111")
    r2 = Contact(name="R2", public_key="222222222222" + "0" * 52, key_prefix="222222222222")
    topo = build_topology(
        self_id=US + "0" * 52,
        contacts=[r1, r2, FAR],
        trace_paths=[],
        packet_paths=[],
        neighbour_links=[],
    )
    route = ("111111111111", "222222222222")  # us → r1 → r2 → target, outbound order
    view = _view(topo, None, route, "f2c24f54551e", "Far", [r1, r2, FAR])
    # The drawing goes contact → us, so the relay nearest the target is first and the relay
    # nearest us is last.
    assert view.routes[0].draw == ("222222222222", "111111111111")


def test_routes_view_draws_a_direct_line_for_a_bare_neighbour() -> None:
    """A node that was only heard directly still has its zero-hop line, not a muted note."""
    from meshterm.persistence.repository import PacketPath

    # One packet that we heard straight from Far to us: a direct link, with no relays and no route.
    topo = build_topology(
        self_id=US + "0" * 52,
        contacts=[FAR],
        trace_paths=[],
        packet_paths=[PacketPath(when=utcnow(), origin="f2c24f54551e", hops=[], snr=6.0)],
        neighbour_links=[],
    )
    view = _view(topo, topo.suggested("f2c24f54551e"), None, "f2c24f54551e", "Far", [FAR])
    assert view.routes and view.routes[0].draw == ()  # a straight line from end to end


def _topo_two_alternatives():  # noqa: ANN202
    """A graph that reaches Far two ways: a strong route through Hub and a weak one through Alt."""
    from meshterm.persistence.repository import TracedPath

    alt = Contact(name="Alt", public_key="a1a1a1a1a1a1" + "0" * 52, key_prefix="a1a1a1a1a1a1")
    now = utcnow()
    strong = [
        TracedPath(when=now, hops=[("3d", 12.0), ("f2", 10.0), ("3d", 10.0), (None, 12.0)])
        for _ in range(8)
    ]
    weak = [TracedPath(when=now, hops=[("a1", -14.0), ("f2", -14.0), ("a1", -14.0), (None, -14.0)])]
    topo = build_topology(
        self_id=US + "0" * 52,
        contacts=[HUB, alt, FAR],
        trace_paths=strong + weak,
        packet_paths=[],
        neighbour_links=[],
    )
    return topo


def test_good_alternatives_keeps_observed_routes_and_drops_outliers() -> None:
    """The grey alternatives are the observed routes that are good enough to trust.

    Outliers and the bare direct and device families do not get a lane.
    """
    from meshterm.ui.node_detail_screen import _good_alternatives

    topo = _topo_two_alternatives()
    scenarios = topo.scenarios("f2c24f54551e")
    kept = {s.hops for s in _good_alternatives(topo, scenarios, "f2c24f54551e")}
    assert ("3d63c6429436",) in kept  # the strong observed route stays
    assert ("a1a1a1a1a1a1",) not in kept  # the much weaker route is removed as an outlier
    assert () not in kept  # the bare direct family is never a grey lane


def test_route_freshness_drops_a_route_with_a_long_quiet_hop() -> None:
    """A route is stale, and MeshTerm removes it, when its stalest hop is past the horizon."""
    from datetime import timedelta

    from meshterm.persistence.repository import TracedPath
    from meshterm.ui.node_detail_screen import _route_is_fresh

    now = utcnow()
    hops = [("3d", 12.0), ("f2", -5.0), ("3d", -5.5), (None, 12.0)]
    fresh = build_topology(
        self_id=US + "0" * 52,
        contacts=[HUB, FAR],
        trace_paths=[TracedPath(when=now, hops=hops)],
        packet_paths=[],
        neighbour_links=[],
    )
    assert _route_is_fresh(fresh, ("3d63c6429436",), "f2c24f54551e", now) is True

    stale = build_topology(
        self_id=US + "0" * 52,
        contacts=[HUB, FAR],
        trace_paths=[TracedPath(when=now - timedelta(days=60), hops=hops)],
        packet_paths=[],
        neighbour_links=[],
    )
    assert _route_is_fresh(stale, ("3d63c6429436",), "f2c24f54551e", now) is False


def test_contract_bidir_clusters_folds_a_knot_but_keeps_the_rows() -> None:
    """A bidirectional knot of 3 or more nodes contracts to one super-node in the graph.

    The rows do not change. Each route row and its trace spec keep the name of each member,
    in order.
    """
    from meshterm.ui.node_detail_screen import _contract_bidir_clusters

    routes = [
        _Route(draw=("aa", "bb", "cc"), spec="s1", path=Text("A B C"), context=Text("")),
        _Route(draw=("cc", "bb", "aa"), spec="s2", path=Text("C B A"), context=Text("")),
    ]
    new, clusters = _contract_bidir_clusters(routes, lambda _n: 2)  # all repeaters
    ((cid, cluster),) = clusters.items()
    assert cluster.label == "3 repeaters" and cluster.glyph == "▲"
    assert [r.draw for r in new] == [(cid,), (cid,)]  # the members are one cluster stop
    assert [r.spec for r in new] == ["s1", "s2"]  # traces still use the real path
    assert [r.path.plain for r in new] == ["A B C", "C B A"]  # the list keeps the full order


def test_contract_leaves_a_two_node_pair_and_unclustered_routes_alone() -> None:
    """A tidy two-way pair keeps its own markers (JP likes this display). Nothing contracts."""
    from meshterm.ui.node_detail_screen import _contract_bidir_clusters

    routes = [
        _Route(draw=("aa", "bb"), spec="s1", path=Text("A B"), context=Text("")),
        _Route(draw=("bb", "aa"), spec="s2", path=Text("B A"), context=Text("")),
    ]
    new, clusters = _contract_bidir_clusters(routes, lambda _n: 2)
    assert clusters == {}
    assert [r.draw for r in new] == [("aa", "bb"), ("bb", "aa")]


def test_contract_labels_a_mixed_cluster_generically() -> None:
    """A knot of mixed types has a generic label.

    Its members are different node types, so it cannot have one type mark. Its label is
    ``n nodes`` under the plain dot.
    """
    from meshterm.ui.node_detail_screen import _contract_bidir_clusters

    routes = [
        _Route(draw=("aa", "bb", "cc"), spec="", path=Text(""), context=Text("")),
        _Route(draw=("cc", "bb", "aa"), spec="", path=Text(""), context=Text("")),
    ]
    _new, clusters = _contract_bidir_clusters(routes, lambda n: {"aa": 2, "bb": 3, "cc": 4}[n[:2]])
    ((_cid, cluster),) = clusters.items()
    assert cluster.label == "3 nodes" and cluster.glyph == "●"


def test_located_accepts_real_fixes_and_rejects_junk() -> None:
    """The location preview needs a real position. It rejects null island and bad adverts."""
    from meshterm.ui.node_detail_screen import _located

    assert _located(45.5, -73.6) is True
    assert _located(None, -73.6) is False  # a coordinate is missing
    assert _located(0.0, 0.0) is False  # null island (the value for no GPS)
    assert _located(-97.0, -1041.97) is False  # the out-of-range advert from Homestead


# --- the screen -----------------------------------------------------------------


def _header() -> Text:
    header = Text("▲ ", style="type.repeater")
    header.append("Hub", style="accent")
    header.append("   repeater", style="muted")
    return header


def _screen(**over) -> NodeDetailScreen:
    """A node detail screen with display data that the test builds by hand.

    It has an Info tab and a Routes tab that shows only a note.
    """
    kwargs = dict(
        title="Node — Hub",
        header=_header(),
        info_rows=[
            ("key", highlighted_hash("3d63c6429436" + "0" * 52, 1)),
            ("heard", Text("5m ago")),
            ("packets", Text("42")),
        ],
        tabs=[_Tab("Info", "info"), _Tab("Routes", "routes")],
        minimap=None,
        map_caption=None,
        routes=_RoutesView(note="no route observed yet — trace to discover one"),
        info_actions=[_Action("timemachine", "⏳", "", "Time machine — 42 receptions")],
        trace_action=_Action("trace", "🎯", "", "Trace — auto route …"),
    )
    kwargs.update(over)
    return NodeDetailScreen(**kwargs)


def test_node_detail_screen_renders_its_sections() -> None:
    """The Info tab has the vitals and its actions. The Routes tab has the stage and Trace."""
    screen = _screen()
    screen.note_viewport(30)
    body = _plain(screen.render_body(72))
    assert "Hub" in body and "repeater" in body  # the pinned identity header
    assert "│  Info  │" in body and "42" in body  # the vitals are in the Info tab, which has a box
    assert "Time machine" in body  # the Info tab's own action
    assert "Back" not in body  # no exit row anywhere: Esc leaves
    assert "────────" in body  # the faint rule that closes the stage
    assert "no route observed yet" not in body  # the Routes stage is only on its own tab

    screen.handle("tab")
    body = _plain(screen.render_body(72))
    assert "│  Routes  │" in body and "no route observed yet" in body
    assert "Trace" in body and "Back" not in body
    assert "packets" not in body  # the vitals stay on the Info tab
    # Each rendered line fits the 72-column standard.
    for line in screen.render_body(72):
        assert len(_plain([line])) <= 72
    assert len(screen.footer_hint) <= 72


def test_the_remove_row_is_tinted_and_keeps_its_tint_where_the_icon_lane_goes() -> None:
    """The destructive action has the ``err`` style on both platforms.

    On the desktop, this is the red 🗑 at the start of the row. On the PicoCalc, the whole
    icon lane is removed (``command_icon`` returns ``""``). If the tint went with the icon,
    a delete row looked the same as each other row. Thus the tint goes on the label, as
    :func:`~meshterm.ui.menus.marked_label` does for a menu row.
    """
    import re

    from meshterm.platforms import PICOCALC_LYRA, set_platform

    remove = _Action("remove", "🗑", "err", "Remove contact…")
    screen = _screen(info_actions=[remove])
    screen.note_viewport(30)
    line = screen._action_line(remove, selected=False, width=40)
    assert "🗑" in line and "Remove contact…" in _plain([line])

    set_platform(PICOCALC_LYRA)
    screen = _screen(info_actions=[remove])
    screen.note_viewport(30)
    folded = screen._action_line(remove, selected=False, width=40)
    assert "🗑" not in folded  # the icon lane is gone...
    assert "Remove contact" in _plain([folded])
    # ...and the tint of the icon is now on the words: a colour sequence starts the label.
    # Nothing starts the label of an action with no tint.
    assert re.search(r"\[[0-9;]*m *Remove contact", folded)
    plain_row = screen._action_line(
        _Action("timemachine", "⏳", "", "Time machine — 42 receptions"), False, 40
    )
    assert not re.search(r"\[[0-9;]*m *Time machine", plain_row)


def test_the_remove_row_resolves_its_own_token() -> None:
    """The Enter key on the remove row gives ``open_node_detail`` the token that it deletes with."""
    screen = _screen(info_actions=[_Action("remove", "🗑", "err", "Remove contact…")])
    resolved: list = []
    screen.resolve = lambda value: resolved.append(value)  # type: ignore[method-assign]
    screen.note_viewport(30)
    screen.render_body(72)
    screen.handle("enter")
    assert resolved == ["remove"]


def test_node_detail_screen_cursor_and_commit() -> None:
    """↑/↓ move the highlight (it stays visible). Enter resolves its key. Esc cancels."""
    screen = _screen()
    resolved: list = []
    screen.resolve = lambda value: resolved.append(value)  # type: ignore[method-assign]

    assert screen.cursor_line() is None  # the screen did not render yet
    screen.note_viewport(30)
    screen.render_body(72)
    # The highlight starts on the first row of the Info tab (Time machine), and the screen
    # always reports it. Thus the frame can keep it visible on a terminal that is too short
    # for the pinned layout.
    assert screen.cursor_line() is not None
    screen.render_body(72)
    screen.handle("enter")
    assert resolved == ["timemachine"]

    screen.handle("escape")
    assert resolved == ["timemachine", CANCEL]


def test_the_vitals_come_back_with_edge_scroll() -> None:
    """On a frame that is too short for the Info tab, ↑ on the first action scrolls the vitals back.

    When the user moves down the actions, the identity and the vitals scroll off the top.
    None of them can have the highlight. Before edge scroll, the only way back to them was
    the Home key. Now ↑ on the first action scrolls the page one line at a time to its top.
    """
    from meshterm.ui.tui import frame

    actions = [_Action(f"a{i}", "⏳", "", f"Action {i}") for i in range(4)]
    screen = _screen(info_actions=actions)

    def press(action: str) -> None:
        if not screen.edge_scroll(action):
            screen.handle(action)

    def view() -> list[str]:
        screen.note_viewport(5)
        visible, _above, _below = frame._visible_slice(screen, screen.render_body(60), 5)
        return [_plain([line]) for line in visible]

    view()
    for _ in range(3):
        press("down")
        view()
    for _ in range(3):
        press("up")
        view()
    assert "Action 0" in "\n".join(view())  # back on the first action…
    assert not any("Hub" in line for line in view())  # …the identity is still scrolled off
    for _ in range(10):
        press("up")  # edge scroll: the page moves, not the highlight
        view()
    page = view()
    assert "Hub" in page[0]  # the identity line is the top of the viewport again
    press("down")  # the snap-back shows the first action again before anything moves
    assert any("❯" in line and "Action 0" in line for line in view())


def test_node_detail_carries_no_exit_row() -> None:
    """The page has no Back row. Esc leaves, and we removed the row that repeated it.

    The page has only its own verbs. Thus the highlight on the actions never stops on a row
    that does nothing.
    """
    screen = _screen()
    resolved: list = []
    screen.resolve = lambda value: resolved.append(value)  # type: ignore[method-assign]

    screen.note_viewport(30)
    assert "Back" not in _plain(screen.render_body(72))
    screen.handle("escape")
    assert resolved == [CANCEL]


def _two_routes() -> _RoutesView:
    """A routes view with two routes to select, in the form that the assembly code returns."""
    return _RoutesView(
        routes=[
            _Route(draw=("3d63c6429436",), spec="3d,f2,3d", path=Text("via Hub"), context=Text("")),
            _Route(draw=("a1a1a1a1a1a1",), spec="a1,f2,a1", path=Text("via Alt"), context=Text("")),
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )


def test_node_detail_screen_route_selection_arms_the_trace() -> None:
    """↑/↓ on the route rows moves the graph highlight and the spec that a trace uses."""
    screen = _screen(routes=_two_routes(), tabs=[_Tab("Routes", "routes")])
    # The rows that can have the highlight are route 0 and route 1. When the page lists
    # routes, the rows are the places where a trace starts. Thus no separate Trace action
    # row renders, and the tab has no other row.
    assert screen.selected_spec() == "3d,f2,3d"
    screen.handle("down")  # onto route 1
    assert screen._route_sel == 1 and screen.selected_spec() == "a1,f2,a1"
    screen.note_viewport(30)
    body = _plain(screen.render_body(72))
    assert "via Hub …" in body and "via Alt …" in body  # both rows drew, with … as the opener mark
    assert "Trace" not in body  # the row for the auto route shows only when no routes are listed


def test_node_detail_routes_stage_spends_the_caption_and_top_air_on_the_fan() -> None:
    """On the PicoCalc the Routes stage uses the caption row and the top air row for the fan.

    The fan starts directly under the tab strip and has no caption. Both rows that MeshTerm
    gets back go into the graph, never into a taller gap (JP, 2026-08-09).

    The own end padding of the graph leaves one empty canvas row above its top label. The
    stage draws one row over its ceiling and removes that row. Thus the removal does not
    cost a row.
    """
    from meshterm.platforms import PICOCALC_LYRA, REGULAR, set_platform

    # A fan with so many routes that the row ceiling, not its own ideal height, sets its
    # size. Thus the rows that MeshTerm gets back show as lanes and not as free space.
    busy = _RoutesView(
        routes=[
            _Route(draw=(h * 12,), spec=f"{h}{h},f2", path=Text(f"via {h}{h}"), context=Text(""))
            for h in "123456"
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )

    def _stage(viewport: int) -> list[str]:
        screen = _screen(routes=busy, tabs=[_Tab("Info", "info"), _Tab("Routes", "routes")])
        screen.handle("tab")  # onto Routes
        screen.note_viewport(viewport)
        lines = screen.render_body(49)

        def is_strip(ln):
            return "Routes" in _plain([ln]) and "│" in _plain([ln])

        strip_idx = next(i for i, ln in enumerate(lines) if is_strip(ln))
        rule_idx = next(
            i for i, ln in enumerate(lines) if set(_plain([ln])) == {"─"} and i > strip_idx
        )
        return [_plain([ln]) for ln in lines[strip_idx + 2 : rule_idx]]  # after the strip rule

    set_platform(PICOCALC_LYRA)
    pico = _stage(22)
    assert pico[0].strip(), "no blank row between the tab strip and the fan"
    assert not any("selected route" in line for line in pico), "the caption is dropped"

    set_platform(REGULAR)
    desktop = _stage(22)
    assert not desktop[0].strip()  # the desktop keeps its air…
    assert any("node → you, as heard" in line for line in desktop)  # …and its caption
    # Both rows go into the drawing, not into the chrome. From the same viewport, the
    # console gives this fan, which the ceiling limits, two more canvas rows than the desktop
    # stage that has a caption.
    drawn = [ln for ln in desktop if "node → you" not in ln]
    assert len(pico) == len(drawn) + 2


def _mark() -> Text:
    mark = Text("▲ ", style="type.repeater")
    mark.append("Hub", style="#ff8800")
    return mark


def _busy_routes() -> _RoutesView:
    """Four routes through a shared relay: the row ceiling, not its height, sets the fan size."""
    return _RoutesView(
        routes=[
            _Route(
                draw=(h * 12, "f2" * 6),
                spec=f"{h}{h},f2",
                path=Text(f"via {h}{h}"),
                context=Text(""),
            )
            for h in "1234"
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )


def test_a_short_frame_wears_the_identity_in_the_title_bar() -> None:
    """On the Cardputer the title bar shows ``▲ Hub`` in the node colours. The identity line goes.

    The glyph replaces the word ``Node``, and the name has its own hue. The line under the
    bar said the same, so it said it two times (JP, 2026-10-04). A tall frame keeps both
    as they were.
    """
    from meshterm.platforms import CARDPUTER_ZERO, set_platform
    from meshterm.ui.tui import frame

    set_platform(CARDPUTER_ZERO)
    screen = _screen(mark=_mark())
    screen.note_viewport(12)  # the body of the Cardputer, under the bar and over the lane
    body = _plain(screen.render_body(53))
    assert screen.title == "▲ Hub"
    assert "repeater" not in body  # the identity line is gone…
    assert body.splitlines()[0].startswith("──┤ Info ├")  # …the tab strip is first on the page
    bar = frame._title_bar(screen, 53, False, False)
    start = bar.plain.index("▲")
    styles = {str(s.style) for s in bar.spans if s.start <= start < s.end}
    assert "type.repeater" in styles
    hub = bar.plain.index("Hub")
    assert "#ff8800" in {str(s.style) for s in bar.spans if s.start <= hub < s.end}

    tall = _screen(mark=_mark())
    tall.note_viewport(30)
    body = _plain(tall.render_body(53))
    assert tall.title == "Node — Hub" and "repeater" in body
    # If there is no mark to show, a short frame keeps its title and the identity line.
    bare = _screen()
    bare.note_viewport(12)
    assert "repeater" in _plain(bare.render_body(53)) and bare.title == "Node — Hub"


def test_a_short_frame_gives_the_route_graph_the_rows_it_freed() -> None:
    """There is no identity line and no rule under the graph, so both rows go to the graph.

    Between the tab strip and the route list there is only the fan. The fan gets each row
    that the guaranteed list window leaves.
    """
    from meshterm.platforms import CARDPUTER_ZERO, set_platform

    set_platform(CARDPUTER_ZERO)
    screen = _screen(mark=_mark(), routes=_busy_routes())
    screen.handle("tab")  # onto Routes
    screen.note_viewport(12)
    lines = [_plain([line]) for line in screen.render_body(53)]
    assert "Routes ├" in lines[0]
    first_route = next(i for i, line in enumerate(lines) if "via 11" in line)
    graph = lines[1:first_route]
    assert not any(set(line.strip()) == {"─"} for line in graph)  # no rule under the fan
    assert len(graph) == 12 - 1 - 4  # all rows but the strip and the four rows of the list
    assert [line.strip() for line in lines[first_route:]] == [
        "❯ via 11 …",
        "via 22 …",
        "via 33 …",
        "via 44 …",
    ]


def test_node_detail_screen_context_hangs_under_the_pathline() -> None:
    """The context (weakest, samples, tag) has its own line, with an indent under the path line."""
    routes = _RoutesView(
        routes=[
            _Route(
                draw=("3d63c6429436",),
                spec="3d,f2,3d",
                path=Text("f2 3d aa"),
                context=Text("weakest -6.0 dB  ·  3×  ·  ★ best"),
            ),
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    lines = screen.render_body(72)
    body = _plain(lines)
    assert "f2 3d aa …" in body  # the path line, with the opener mark
    assert "weakest -6.0 dB" in body and "★ best" in body  # the context is also drawn
    path_idx = next(i for i, ln in enumerate(lines) if "f2 3d aa" in _plain([ln]))
    assert _plain([lines[path_idx]]).startswith("❯ f2 3d aa")  # the pointer starts the path line
    context_line = _plain([lines[path_idx + 1]])
    assert context_line.startswith("  weakest")  # it hangs two columns under it, with no pointer


def test_node_detail_screen_context_line_absent_when_theres_nothing_to_show() -> None:
    """A route that has no context draws only its path line.

    If there is no weakest SNR, sample count, or tag, there is no empty hanging line under it.
    """
    routes = _RoutesView(
        routes=[_Route(draw=(), spec="", path=Text("f2 aa"), context=Text(""))],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    lines = screen.render_body(72)
    path_idx = next(i for i, ln in enumerate(lines) if "f2 aa" in _plain([ln]))
    # Nothing hangs under a route that has no context. The path line is the last item that
    # the page draws (the tab has no action rows). It is not a muted context line.
    rest = _plain(lines[path_idx + 1 :]).strip()
    assert not rest.startswith("weakest") and not rest


def test_node_detail_screen_hscrolls_the_selected_pathline() -> None:
    """A path line that is too wide for the lane scrolls with ←/→, on the highlighted row only.

    If the highlight moves off the row, the scroll stops. A long row that is not selected
    has an ellipsis.
    """
    long_path = Text("f2 " + " ".join(f"{i:02x}" for i in range(40)) + " aa")
    routes = _RoutesView(
        routes=[
            _Route(draw=("3d",), spec="s0", path=long_path.copy(), context=Text("")),
            _Route(draw=("a1",), spec="s1", path=Text("f2 3d aa"), context=Text("")),
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    body = _plain(screen.render_body(72))
    assert "f2 00 01 02" in body  # with no scroll, the start of the chain shows
    assert "←→ scroll" in screen.footer_hint  # the overflow causes the footer atom

    row = next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯"))
    assert row.rstrip().endswith("…")  # the right edge marks the remainder, before a scroll

    screen.handle("right")
    screen.handle("right")
    body = _plain(screen.render_body(72))
    assert "f2 00 01 02" not in body  # the view moved away from the start
    row = next(ln for ln in body.splitlines() if ln.startswith("❯"))
    assert row.startswith("❯ …")  # …and now a mark says that the line also continues behind

    screen.handle("left")
    body = _plain(screen.render_body(72))
    assert "f2 00 01 02" not in body  # one step back, but not yet at the start

    for _ in range(20):  # run the scroll to its stop
        screen.handle("right")
    row = next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯"))
    # The clamp stops where the tail is readable: the end of the line, its last hop, is on
    # the screen. It is not cut behind a mark at the right edge that promises more text that
    # the keys cannot reach. Only the left mark is drawn. The `…` that shows that Enter
    # opens more is outside the lane, so a window that is full to its edge is the case where
    # it is not shown.
    assert row.rstrip().endswith("aa") and row.count("…") == 1
    screen.handle("right")  # …and the stop holds: nothing moves past it
    assert (
        next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯")) == row
    )

    screen.handle("down")  # onto route 1: the scroll of route 0 stops, a short row cannot scroll
    screen.render_body(72)
    assert "←→ scroll" not in screen.footer_hint  # the short path line of route 1 has no hint

    screen.handle("up")  # back onto route 0
    body = _plain(screen.render_body(72))
    assert "f2 00 01 02" in body  # the shift is reset, back at the start
    assert "←→ scroll" in screen.footer_hint  # route 0 overflows again


def test_node_detail_route_row_cracks_a_chip_path_at_both_edges() -> None:
    """In chips, a route row has a crack at both edges instead of an ellipsis.

    At each edge that the route goes past, the chip breaks on a half block. The row shows
    part of a route that continues, and a cracked segment says this. Three dots mean
    that a word is shortened.
    """
    chips = PathLine(
        [PathHop(f"NODE{i:02d}", key=f"{i:02x}aa") for i in range(12)], mode="powerline"
    ).text()
    routes = _RoutesView(
        routes=[
            _Route(draw=("3d",), spec="s0", path=chips.copy(), context=Text("")),
            _Route(draw=("a1",), spec="s1", path=Text("f2 3d aa"), context=Text("")),
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)

    def selected_row() -> str:
        return next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯"))

    row = selected_row()
    assert row.rstrip().endswith(CRACK_TAIL) and "…" not in row  # cut at the edge of the lane
    screen.handle("right")
    screen.handle("right")
    row = selected_row()
    assert row.startswith("❯ " + CRACK_HEAD)  # the start is now off to the left, with a crack
    assert row.rstrip().endswith(CRACK_TAIL) and "…" not in row


def test_node_detail_route_row_spends_no_lane_cells_on_the_opens_marker() -> None:
    """A route that fills its lane exactly stays whole. The ``…`` does not use lane cells.

    The mark says what the Enter key does. It is chrome, not route. MeshTerm reserved two
    cells for it, and a chain that fitted had a crack on its last chip (JP, 2026-08-10).
    The row said that the walk continued when it had arrived. The crack was only the closing
    cap with half of it removed. Now the path is fitted to the whole lane, and the mark uses
    the cells that are left. On a full lane, no cells are left.
    """
    avail = 72 - 2  # the lane of the row: the width less the pointer column
    exact = Text("x" * avail)
    routes = _RoutesView(
        routes=[_Route(draw=("3d",), spec="s0", path=exact.copy(), context=Text(""))],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    row = next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯"))
    assert row == "❯ " + "x" * avail  # whole, not cut, and no mark pushed in
    # …and if there is nothing to scroll, ←→ do nothing and the hint does not show them.
    assert "←→ scroll" not in screen.footer_hint

    # The mark needs two cells, and two cells are free here, so the screen draws it.
    roomy = _RoutesView(
        routes=[_Route(draw=("3d",), spec="s0", path=Text("x" * (avail - 2)), context=Text(""))],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=roomy, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    row = next(ln for ln in _plain(screen.render_body(72)).splitlines() if ln.startswith("❯"))
    assert row == "❯ " + "x" * (avail - 2) + " …"


#: A key of 64 digits where each byte is different (``000102…1e1f``). Thus the first digits
#: of a window show where the lane was cut. A shift that is wrong by one shows ``0001…`` as
#: ``00102…``.
_LONG_KEY = "".join(f"{i:02x}" for i in range(32))


def _key_row(screen: NodeDetailScreen, width: int) -> str:
    """Render the Info tab and read its key lane, as one plain line."""
    screen.note_viewport(30)
    rows = [_plain([line]) for line in screen.render_body(width)]
    return next(row for row in rows if row.startswith("key"))


def test_node_detail_key_lane_hscrolls_instead_of_wrapping() -> None:
    """The key lane has one line and slides under ←/→ instead of wrapping.

    The windows are aligned to bytes. A faint ``…`` mark is at each edge where the key
    continues. The slide clamps at both ends.
    """
    screen = _screen(info_rows=[("key", highlighted_hash(_LONG_KEY, 1)), ("heard", Text("5m ago"))])

    row = _key_row(screen, 53)
    assert row.startswith("key      0001") and row.endswith("…")  # the head, with more at the right
    assert "1e1f" not in row and len(row) <= 53  # the tail is outside the lane, not wrapped
    assert "←→ scroll key" in screen.footer_hint  # …and the overflow causes its footer atom

    screen.handle("right")
    row = _key_row(screen, 53)
    # The shift is four whole bytes: the window starts on byte 4 (``04``), with a mark at
    # both edges.
    assert row.startswith("key      …0405") and row.endswith("…")

    for _ in range(6):
        screen.handle("right")  # run to the end: the shift clamps where the tail ends
    row = _key_row(screen, 53)
    assert row.endswith("1e1f")  # the last byte of the key, with no mark: this is the end
    assert row.startswith("key      …")  # …and the head is now off to the left

    for _ in range(6):
        screen.handle("left")  # then the other way, and it clamps at the head
    assert _key_row(screen, 53).startswith("key      0001")


def test_node_detail_key_lane_scroll_survives_the_cursor_and_resets_on_tab() -> None:
    """The key is pinned chrome, not a row that can have the highlight.

    If the user moves over the action rows, the key keeps its scroll. If the user leaves the
    tab, the scroll resets. A key that fits has no ←→ in the hint.
    """
    screen = _screen(info_rows=[("key", highlighted_hash(_LONG_KEY, 1)), ("heard", Text("5m ago"))])
    _key_row(screen, 53)
    screen.handle("right")
    screen.handle("down")  # onto Back: the window stays where the user left it
    assert _key_row(screen, 53).startswith("key      …0405")

    screen.handle("tab")  # over to Routes…
    screen.render_body(53)
    assert "←→" not in screen.footer_hint  # nothing there is too wide to scroll
    screen.handle("tab")  # …and back: the lane starts at the head again
    assert _key_row(screen, 53).startswith("key      0001")

    # A lane that is wide enough for the whole key shows it whole, with no mark and no hint.
    row = _key_row(screen, 100)
    assert row.startswith(f"key      {_LONG_KEY}") and "…" not in row
    assert "←→" not in screen.footer_hint
    screen.handle("right")  # does nothing, because no text is past the edge
    assert _key_row(screen, 100).startswith(f"key      {_LONG_KEY}")


def test_node_detail_enter_on_a_route_row_opens_its_trace() -> None:
    """The Enter key on a route row prepares a trace on that route. No Trace row is necessary."""
    screen = _screen(routes=_two_routes(), tabs=[_Tab("Routes", "routes")])
    resolved: list = []
    screen.resolve = lambda value: resolved.append(value)  # type: ignore[method-assign]
    screen.handle("down")  # onto route 1
    screen.handle("enter")
    assert resolved == ["trace"] and screen.selected_spec() == "a1,f2,a1"


def test_route_labels_light_through_a_coalesced_hop() -> None:
    """A route that has a short hop id lights the wide marker that the graph merges it into.

    The route evidence comes to the page with different hash widths. For example, a trace
    hop of 1 byte (``3d``) is on one route, and the full id of the same relay is on a sibling
    route. The graph merges the short id into the one wide marker. Thus the dimming of the
    nodes that are not on the route must check membership against the drawn ids. When it
    used the raw draw hops, the relay of the selected route was muted, and the white line
    went straight through it (the report from TSFCT SUTTON-680M).
    """
    lit: list[str] = []

    def base_rgb(node: str) -> tuple[int, int, int]:
        lit.append(node)  # the widget calls this only for nodes on the selected route
        return (200, 200, 200)

    routes = _RoutesView(
        routes=[
            _Route(
                draw=("bf61f2fb1d9e", "3d63c6429436"),
                spec="s0",
                path=Text("wide"),
                context=Text(""),
            ),
            _Route(draw=("bf61f2fb1d9e", "3d"), spec="s1", path=Text("short"), context=Text("")),
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=base_rgb,
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    screen.handle("down")  # select the short-hop route
    screen.render_body(72)
    assert "3d63c6429436" in lit  # the relay that the route goes through keeps its hue


def test_node_detail_route_list_windows_inside_the_page() -> None:
    """The route list scrolls in a list window inside the page. It does not make the page taller.

    If there are more routes than fit, edge markers show, and the pinned chrome stays
    visible. This is true for each number of routes of a busy node.
    """
    routes = _RoutesView(
        routes=[
            _Route(
                draw=(f"{i:x}{i:x}" * 6,),
                spec=f"s{i}",
                path=Text(f"route {i}"),
                context=Text(""),
            )
            for i in range(12)
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    lines = screen.render_body(72)
    assert len(lines) <= 30  # the body fits the viewport, so nothing scrolls off
    body = _plain(lines)
    assert "↓" in body and "more" in body  # the edge marker counts the routes that are hidden
    assert "── Routes ──" in body  # the pinned chrome above the list stays
    assert "PgUp/PgDn scroll" in screen.footer_hint  # the hint shows paging only when necessary

    # If the highlight moves to the last route, the window slides down to keep it visible.
    for _ in range(11):
        screen.handle("down")
    lines = screen.render_body(72)
    assert len(lines) <= 30
    assert "route 11" in _plain(lines) and screen.cursor_line() is not None


def test_node_detail_route_cursor_clamps_at_both_ends() -> None:
    """The route list window does not wrap around.

    ↑ on the first row and ↓ after the last row stay where they are. They do not move the
    window from one end to the other end.
    """
    routes = _RoutesView(
        routes=[
            _Route(
                draw=(f"{i:x}{i:x}" * 6,),
                spec=f"s{i}",
                path=Text(f"route {i}"),
                context=Text(""),
            )
            for i in range(12)
        ],
        glyph_of=lambda n: ("●", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
    )
    screen = _screen(routes=routes, tabs=[_Tab("Routes", "routes")])
    screen.note_viewport(30)
    screen.render_body(72)
    screen.handle("up")
    assert screen._row_index == 0
    for _ in range(20):
        screen.handle("down")
    assert screen._row_index == 11


def test_fit_blocks_walks_wrapped_rows_into_view() -> None:
    """The fit for rows of different heights moves wrapped rows into the viewport.

    It keeps whole blocks. It uses marker lines only when rows are hidden. It moves the
    window down to the highlighted row.
    """
    window = ListWindow()
    top, count = window.fit_blocks([2, 2, 2, 2], 5, 3)  # the highlight is on the last 2-line row
    assert top + count == 4 and top == 2  # it slid to the tail, and the last two rows fit
    assert window.page == count  # the capacity that the fit set is the size of a page step
    top, count = window.fit_blocks([1, 1], 5, 0)
    assert (top, count) == (0, 2)  # everything fits: no window, no markers


def test_node_detail_screen_tabs_switch_the_stage() -> None:
    """←→ (and Tab) change the tab that fills the stage. The footer shows the switch only then."""
    mini = MiniMap(
        _FakeSession(),
        _OfflineSource(),
        14,
        center_lat=45.5,
        center_lon=-73.6,
        zoom=13,
        markers=[MapMarker(label="Hub", lat=45.5, lon=-73.6, key="3d63aa")],
    )
    screen = _screen(
        minimap=mini,
        map_caption=Text("Hub · centred here", style="faint"),
    )
    screen.note_viewport(30)
    assert "Tab/⇧Tab switch" in screen.footer_hint  # there are two tabs, so the hint has the switch
    # The screen starts on the Info tab. The vitals, the caption of the preview with a
    # position, and its braille edge scrub are all part of this tab.
    body = _plain(screen.render_body(72))
    assert "│  Info  │" in body and "centred here" in body
    assert screen.consume_edge_scrub() == 2

    # The F-key chip names the tab that the switch goes to, so it changes with the stage.
    assert screen.picocalc_lyra_lane[2].label == "Routes"
    screen.handle("tab")  # switch to the Routes tab
    body = _plain(screen.render_body(72))
    assert "│  Routes  │" in body and "no route observed yet" in body
    assert screen.consume_edge_scrub() == 0  # the braille preview is not visible now
    assert screen.picocalc_lyra_lane[2].label == "Info"


def test_node_detail_preview_keeps_its_minimum_except_on_a_short_frame() -> None:
    """The preview shows at its minimum when the actions leave less. A short frame has none.

    A contact page has many action rows, so on a terminal of 24 rows they leave the preview
    less than its minimum. The preview keeps its minimum and the page scrolls. The 11-row
    viewport of the Cardputer is a short frame, and there the preview is not shown.
    """
    mini = MiniMap(
        _FakeSession(),
        _OfflineSource(),
        14,
        center_lat=45.5,
        center_lon=-73.6,
        zoom=13,
        markers=[MapMarker(label="Hub", lat=45.5, lon=-73.6, key="3d63aa")],
    )
    actions = [_Action(f"a{i}", "⚙", "", f"Action {i}") for i in range(8)]
    screen = _screen(
        minimap=mini,
        map_caption=Text("Hub · centred here", style="faint"),
        info_actions=actions,
    )
    screen.note_viewport(21)
    body = _plain(screen.render_body(72)).splitlines()
    caption = next(i for i, line in enumerate(body) if "centred here" in line)
    vitals = next(i for i, line in enumerate(body) if line.startswith("packets"))
    assert caption - vitals - 2 >= 5  # the rows between the blank line and the caption
    assert len(body) > 21  # the preview did not shrink under its minimum: the page scrolls

    screen.note_viewport(11)
    assert "centred here" not in _plain(screen.render_body(53))


def test_node_detail_single_tab_hides_the_switch_hint() -> None:
    """A page with only one tab does not have the ←→ tab atom in its footer."""
    screen = _screen(tabs=[_Tab("Info", "info")])  # our node: no Routes tab
    assert "←→ tab" not in screen.footer_hint
    assert "↑↓ move" in screen.footer_hint and screen.footer_hint.endswith("Esc back")
    # There is no tab to switch to, so the lane leaves the slot empty. It does not dim it.
    assert screen.picocalc_lyra_lane[2] is None


def test_toggling_the_lock_rewrites_the_rows_and_keeps_the_cursor_on_it() -> None:
    """Lock becomes Unlock on the same row, and Archive is not offered while the lock is on."""
    tm = _Action("timemachine", "⏳", "", "Time machine — 42 receptions")
    delete = _Action("remove", "🗑", "err", "Delete contact…")
    screen = _screen(
        info_actions=[
            tm,
            _Action("lock", "🔒", "", "Lock contact"),
            _Action("archive", "💾", "", "Archive contact"),
            delete,
        ]
    )
    resolved: list = []
    screen.resolve = lambda value: resolved.append(value)  # type: ignore[method-assign]
    screen.note_viewport(30)
    screen.render_body(72)
    screen.handle("down")
    screen.handle("enter")
    assert resolved == ["lock"]

    screen.replace_info_actions([tm, _Action("unlock", "🔓", "", "Unlock contact"), delete])
    screen.render_body(72)
    screen.handle("enter")
    assert resolved == ["lock", "unlock"]
    assert [a.key for a in screen._info_actions] == ["timemachine", "unlock", "remove"]


def test_routes_legend_steps_aside_on_a_short_frame() -> None:
    """The legend is under the fan, except on a short frame such as the frame of the Cardputer.

    On a short frame, the rows go to the graph and the route list, as for the fan of the
    message paths.
    """
    view = _RoutesView(
        routes=[_Route(draw=("3d" * 6,), spec="3d,f2", path=Text("via 3d"), context=Text(""))],
        glyph_of=lambda n: ("▲", "#ffffff"),
        label_of=lambda n: n[:2],
        label_rgb_of=lambda n: (200, 200, 200),
        legend=True,
    )

    def stage(viewport: int) -> str:
        screen = _screen(routes=view, tabs=[_Tab("Info", "info"), _Tab("Routes", "routes")])
        screen.handle("tab")  # onto Routes
        screen.note_viewport(viewport)
        return _plain(screen.render_body(53))

    assert "▲ repeater" in stage(22)  # the body of the PicoCalc
    assert "▲ repeater" not in stage(11)  # the body of the Cardputer


def test_a_page_that_may_only_lock_shows_only_the_lock_row() -> None:
    """The management group of a page that a conversation opens is only Lock or Unlock.

    Archive, restore, and delete belong to the list that the contact is in. A lock removes
    nothing, so a conversation can offer it (JP, 2026-10-19). A page that manages keeps its
    full group, in the same order as before.
    """
    from meshterm.ui.node_detail_screen import _management_rows

    def keys(**state: bool) -> list[str]:
        base = {"locked": False, "lockable": True, "manageable": False, "archived": False}
        return [row.key for row in _management_rows(**{**base, **state}, whole_key=True)]

    assert keys() == ["lock"]
    assert keys(locked=True) == ["unlock"]
    assert keys(lockable=False) == []
    assert keys(manageable=True) == ["lock", "archive", "remove"]
    assert keys(manageable=True, locked=True) == ["unlock", "remove"]
    assert keys(manageable=True, lockable=False, archived=True) == ["restore", "remove"]


async def test_a_conversation_opens_the_author_page_with_its_lock_row(monkeypatch) -> None:  # noqa: ANN001
    """^O in a conversation opens the page to look, with the lock as its only verb."""
    import meshterm.ui.node_detail_screen as nd

    calls: list[tuple] = []

    async def _fake(ctx, contact, *, manage=True, lock=None):  # noqa: ANN001, ANN202
        calls.append((contact, manage, lock))
        return False

    monkeypatch.setattr(nd, "open_node_detail", _fake)
    await nd.ContactPages(None, []).show(None)  # type: ignore[arg-type]
    assert calls == [(None, False, True)]


def test_contact_pages_read_and_write_the_lock_of_a_live_contact(tmp_path) -> None:  # noqa: ANN001
    """The pages lock a contact with a full key, and nothing without a store or a device key."""
    from meshterm.core.contact_store import ContactStore
    from meshterm.ui.node_detail_screen import ContactPages

    store = ContactStore(tmp_path / "contacts.json")
    dev = "cc" * 32
    alice = Contact(name="Alice", public_key="a1" * 32, key_prefix="a1" * 6)
    prefix_only = Contact(name="Bob", public_key="", key_prefix="b2" * 6)
    pages = ContactPages(SimpleNamespace(contact_store=store), [alice], self_key=dev)  # type: ignore[arg-type]
    assert pages.can_lock
    assert pages.lock_state(alice) is False
    pages.set_locked(alice, True)
    assert pages.lock_state(alice) is True and store.is_locked(dev, "a1" * 32)
    assert pages.lock_state(prefix_only) is None

    # An archived contact has no lock: the lock exists to keep a contact out of the archive.
    store.set_locked(dev, alice, False)
    store.archive(dev, alice, when=1_700_000_000)
    assert pages.lock_state(alice) is None

    assert ContactPages(SimpleNamespace(contact_store=store), [alice]).can_lock is False  # type: ignore[arg-type]
    assert ContactPages(None, [alice], self_key=dev).can_lock is False  # type: ignore[arg-type]