"""The demo's page and its CPU views, built without a model.

Skipped when the `[app]` extra (gradio) is not installed. The views themselves are plain HTML
and need only numpy, so most of what is checked here is the markup they produce.
"""
import html
import importlib
import json
import os
import re

import numpy as np
import pytest

from test_runtime import make_trace
from ulens import runtime

gr = pytest.importorskip("gradio")


@pytest.fixture(scope="module")
def app():
    """The module with the import-time model load switched off."""
    os.environ["ULENS_APP_LOAD_MODEL"] = "0"
    from ulens import app
    return importlib.reload(app)        # honour the flag even if imported earlier in the session


def _payload(series_html: str) -> dict:
    m = re.search(r'<div hidden data-ul="data">(.*?)</div>', series_html, re.DOTALL)
    assert m, "the series view must carry the per-token data the hover reads"
    return json.loads(html.unescape(m.group(1)))


def test_build_returns_blocks_without_loading_a_model(app):
    assert app.RUNNER is None
    demo = app.build()
    assert isinstance(demo, gr.Blocks)


def test_the_theme_survives_gradio_s_built_in_comparison(app):
    """`launch` (with analytics on) compares the theme to every built-in theme, font by font;
    string fonts raise there. The comparison must run and the theme must not be a built-in."""
    from gradio import utils  # where launch() takes BUILT_IN_THEMES from
    t = app.theme()
    assert not any(t.to_dict() == b.to_dict() for b in utils.BUILT_IN_THEMES.values())
    assert "system-ui" in t.font


def test_the_page_has_one_palette_in_both_theme_modes(app):
    """Gradio's dark mode recolours every descendant of an HTML block with its dark text
    colour, on top of this page's light surface. The theme therefore carries no dark values
    at all: the `.dark` block Gradio emits must equal the root block, variable for variable."""
    t = app.theme()
    darks = [a for a in vars(t) if a.endswith("_dark")]
    assert darks and all(getattr(t, a) == getattr(t, a[:-5]) for a in darks)
    t._get_computed_value("body_background_fill_dark")   # what launch() reads; must not raise
    css = t._get_theme_css()
    root, dark = css.split(":root.dark", 1)
    pairs = re.compile(r"--([\w-]+): (.*?);")
    light_vars = dict(pairs.findall(root[root.index(":root {"):]))
    dark_vars = dict(pairs.findall(dark))
    assert light_vars["body-text-color"] == app.INK
    assert light_vars["body-background-fill"] == app.SURFACE
    for name, value in light_vars.items():
        assert dark_vars[name] == value, name
    assert "color-scheme: light" in app.CSS


def test_every_view_renders_from_a_synthetic_trace(app):
    tr = make_trace()
    head, tmap, ser = app.views(tr, smooth=9)
    assert head == ""                      # no status line: the controls and labels say it all
    # the map: one span per token, three segments, the boundary marked
    assert tmap.count('data-i="') == tr.n_tokens
    assert all(f'data-i="{i}"' in tmap for i in range(tr.n_tokens))
    for seg in ("ul-seg-prompt", "ul-seg-think", "ul-seg-answer"):
        assert seg in tmap
    assert f"end of think · token {tr.eot}" in tmap
    # the series: one directly labelled row per axis, then the entropy, each with a raw underlay
    assert ser.count('class="ul-row') == tr.n_axes + 1
    assert ser.count('class="smooth"') == tr.n_axes + 1
    assert ser.count('class="raw"') == tr.n_axes + 1
    for name in tr.names:
        assert f"<b>{name.replace('_', ' ')}</b>" in ser
    assert "<b>predictive entropy</b>" in ser


def test_the_score_is_not_on_the_page(app):
    """The demo is about the map, not the number; the API keeps the number."""
    tr = make_trace()
    page = "".join(app.views(tr))
    assert f"{tr.u_lens:.4f}" not in page and f"{tr.a_cone:.4f}" not in page
    assert "A_cone" not in page and "U-Lens" not in page
    assert tr.u_lens == tr.a_cone * tr.think_entropy        # still there, untouched


def test_a_truncated_trace_says_so_in_every_view(app):
    tr = make_trace(truncated=True, eot=19)              # never closed: the budget case
    assert not tr.readout_valid
    head, tmap, ser = app.views(tr, signed=True)
    assert "never closed" in head and "never closed" in tmap and "never closed" in ser
    assert "ul-seg-answer" not in tmap                     # there is no answer to show
    assert "budget" in head and 'class="ul-trunc"' in head  # the one status line, a warning
    assert "budget cut" in app.views(tr, panel="simplex")[2]


def test_a_trace_without_a_thinking_block_reads_as_prompt_then_answer(app):
    """Thinking off: the template closes the block inside the prompt, `eot` lands on the
    prompt's last token, and every generated token is answer. No empty segment, no red rule,
    no thinking-block wording — and the axis values are shown like any others."""
    tr = make_trace(prompt_len=6, eot=5)
    assert tr.think_len == 0 and not tr.truncated and not tr.readout_valid
    head, tmap, ser = app.views(tr, smooth=9)
    assert head == ""                                            # a mode, not a warning
    assert "ul-seg-think" not in tmap and "ul-seg-answer" in tmap
    assert 'class="ul-eotmark none"' in tmap and "end of think" not in tmap
    assert "thinking block" not in tmap                          # a bare rule, no caption
    assert tmap.count('data-i="') == tr.n_tokens                 # every token is painted
    assert "prompt · answer" in ser and "prompt · thinking" not in ser
    assert 'class="eot"' not in ser and "ul-caption" not in ser
    assert "thinking block" not in ser and ser.count("<small>") == 1   # the unit, once
    assert "<small>nats</small>" in ser
    assert ser.count('class="smooth"') == tr.n_axes + 1          # nothing greyed out
    sx = app.views(tr, smooth=9, panel="simplex")[2]
    assert 'class="eot"' not in sx and "Red ring" not in sx


def test_signed_view_draws_a_zero_line_on_the_axis_rows_only(app):
    tr = make_trace()
    assert app.series_html(tr, signed=False).count('class="zero"') == 0
    assert app.series_html(tr, signed=True).count('class="zero"') == tr.n_axes
    assert "points away" in app.token_map_html(tr, signed=True)
    assert "points away" not in app.token_map_html(tr, signed=False)
    # the value control already says "signed projections": the legend does not repeat it
    assert "signed projection" not in app.token_map_html(tr, signed=True)


def test_each_channel_paints_the_map_in_its_own_wash(app):
    """One channel at a time, in that channel's single-hue ramp: the reader never has to tell
    two of the paper's colours apart."""
    tr = make_trace()
    for ch in list(tr.names) + [app.ENTROPY]:
        html = app.token_map_html(tr, ch, smooth=1)
        w = app.WASH[ch]
        assert f"--w1:{w[0]}" in html and f"--w2:{w[1]}" in html and f"--w3:{w[2]}" in html
        assert f"<b>{app.channel_label(ch)}</b>" in html
        assert app.series_html(tr, ch).count('class="ul-row sel') == 1   # that row, only


def test_washes_are_single_hue_light_to_dark(app):
    """Three steps per channel, ordered light to dark (validated separately with the dataviz
    validator in --ordinal mode; this keeps the dict from drifting)."""
    def lum(h):
        return sum(int(h[i:i + 2], 16) for i in (1, 3, 5))
    for ch, steps in app.WASH.items():
        assert len(steps) == 3
        assert lum(steps[0]) > lum(steps[1]) > lum(steps[2]), ch


def test_tint_bins_follow_the_range_and_never_divide_by_zero(app):
    b = app.tint_bins(np.linspace(0, 1, 21))
    assert b.min() == 0 and b.max() == 3 and np.all(np.diff(b) >= 0)
    assert np.all(app.tint_bins(np.full(10, 2.0)) == 0)              # constant: no tint
    assert np.all(app.tint_bins(np.full(5, np.nan)) == 0)            # undefined: no tint
    s = app.tint_bins(np.array([-1.0, -0.1, 0.0, 0.5, 1.0]), signed=True)
    assert list(s) == [-1, 0, 0, 1, 3]                               # away / none / toward


def test_block_selection_changes_the_values_not_the_trace(app):
    tr = make_trace()
    before = tr.field.copy()
    a = app.series_html(tr, block=tr.blocks[0])
    b = app.series_html(tr, block=tr.blocks[-1])
    assert a != b and _payload(a)["block"] == tr.blocks[0]
    assert f"block {tr.blocks[0]}" not in a                  # the control says which block
    assert app.header_html(tr, tr.blocks[0]) == ""           # and there is no status line
    sa = app.simplex_html(tr, block=tr.blocks[0])
    assert sa != app.simplex_html(tr, block=tr.blocks[-1]) and _payload(sa)["block"] == tr.blocks[0]
    np.testing.assert_array_equal(tr.field, before)
    with pytest.raises(KeyError):
        app.views(tr, block=999)


def test_token_strings_are_escaped_everywhere(app):
    tr = make_trace(token_strs=["<think>"] + [f"t{i}\n" for i in range(19)])
    strs = app._hover_strs(tr)
    assert "<think>" not in strs[0] and "&lt;think&gt;" in strs[0]
    assert "\n" not in strs[1]
    tmap = app.token_map_html(tr)
    assert "<think>" not in tmap and "&lt;think&gt;" in tmap
    assert tmap.count('class="nl">↵</i>\n') == 19     # a faint return mark, then a real break
    assert "¶" not in tmap                            # not a full-weight pilcrow mid-sentence


def test_the_hover_payload_matches_the_series(app):
    tr = make_trace()
    d = _payload(app.series_html(tr, smooth=1))
    assert d["T"] == tr.n_tokens and d["channels"] == list(tr.names) + [app.ENTROPY]
    assert d["seg"] == "".join(s[0] for s in tr.segments)
    assert len(d["raw"]) == tr.n_tokens and d["raw"][0][-1] is None  # entropy[0] is NaN
    assert d["raw"][3][0] == pytest.approx(float(tr.components()[3, 0]), abs=1e-4)
    assert d["smooth"] == d["raw"]                                     # w=1: nothing smoothed
    d9 = _payload(app.series_html(tr, smooth=9))
    assert d9["w"] == 9 and d9["smooth"] != d9["raw"]


def test_the_shipped_examples_load_without_a_model(app):
    paths = app.example_traces()
    assert len(paths) == 4
    seen_truncated = False
    for p in paths:
        tr = runtime.load(p)
        head, tmap, ser = app.views(tr, smooth=9)
        assert tmap.count('data-i="') == tr.n_tokens
        assert ser.count('class="ul-row') == tr.n_axes + 1
        seen_truncated |= "never closed" in head
    assert seen_truncated, "one example should be the never-closed thinking block"


def test_the_default_example_is_the_paper_s_teaser_run(app):
    """The page opens on the run behind the paper's teaser figure: its prompt, thinking off,
    seed 0, a 1024-token budget. Listed first whatever the other files are called."""
    paths = app.example_traces()
    assert paths[0].stem == app.DEFAULT_EXAMPLE
    tr = runtime.load(paths[0])
    assert tr.prompt == "Answer briefly. Was Hamlet left-handed, and did he love Ophelia?"
    assert tr.config["thinking"] is False and tr.config["seed"] == 0
    assert tr.config["max_new_tokens"] == 1024
    assert tr.think_len == 0 and not tr.truncated and tr.n_tokens > tr.prompt_len
    # the pill is the prompt and nothing else
    assert app._example_label(paths[0]) == tr.prompt
    for p in paths:
        lab = app._example_label(p)
        assert "tokens" not in lab and "—" not in lab and len(lab) <= 64


def test_winner_lead_names_the_leading_axis_and_its_relative_lead(app):
    S = np.array([[1.0, 0.5, 0.2, 0.1],        # a clear leader
                  [0.4, 0.4, 0.1, 0.0],        # a tie: no lead
                  [0.3, 0.1, 2.0, 1.0],        # a different leader, half ahead
                  [np.nan, 1.0, 0.5, 0.2],     # one undefined axis: it is never the leader
                  [np.nan, np.nan, np.nan, 1.0]])   # no runner-up: no winner
    win, second, lead = app.winner_lead(S)
    assert win[0] == 0 and second[0] == 1 and lead[0] == pytest.approx(0.5)
    assert win[1] in (0, 1) and lead[1] == pytest.approx(0.0)
    assert win[2] == 2 and second[2] == 3 and lead[2] == pytest.approx(0.5)
    assert win[3] == 1 and second[3] == 2 and lead[3] == pytest.approx(0.5)
    assert win[4] == -1 and lead[4] == 0.0
    # signed values: nothing points toward any axis, so nothing leads
    win_s, _, lead_s = app.winner_lead(np.array([[-0.2, -0.5, -0.1, -0.9],
                                                 [0.6, -0.3, 0.1, 0.0]]), signed=True)
    assert list(win_s) == [-1, 0] and lead_s[0] == 0.0
    assert lead_s[1] == pytest.approx(min(1.0, (0.6 - 0.1) / 0.6))


def test_the_all_four_mode_paints_each_token_in_its_leading_axis(app):
    """Colour is not the only carrier: the tint's strength is the lead over the runner-up,
    the legend lists the four axes, the hover payload names the winner, and every axis row
    in the series is the selected one."""
    tr = make_trace(T=60, prompt_len=6, eot=50)
    tmap = app.token_map_html(tr, app.ALL, smooth=1)
    assert 'class="ul-map all"' in tmap and tmap.count('data-i="') == tr.n_tokens
    for k, name in enumerate(tr.names):
        assert f'class="chip ax{k}">{name.replace("_", " ")}</span>' in tmap
        assert f"--c{k}:{app._rgb(app.WASH[name][2])}" in tmap
    assert "<b>all four</b>" in tmap and "lead over the runner-up" in tmap
    assert "none</span>" not in tmap                  # the low/mid/high chips are not this legend
    R = app.axis_matrix(tr)
    win, _, lead = app.winner_lead(R)
    for i in range(tr.n_tokens):
        if lead[i] / app.LEAD_FULL >= 0.01:
            a = min(1.0, lead[i] / app.LEAD_FULL)
            assert f'class="t ax{win[i]}" data-i="{i}" style="--a:{a:.2f}"' in tmap
        else:
            assert f'class="t" data-i="{i}"' in tmap
    alphas = [float(a) for a in re.findall(r"--a:([\d.]+)", tmap)]
    assert alphas and max(alphas) <= 1.0 and min(alphas) >= 0.01
    assert len(set(alphas)) > 3                       # graded, not one flat colour
    ser = app.series_html(tr, app.ALL, smooth=1)
    assert ser.count('class="ul-row sel') == tr.n_axes
    d = _payload(ser)
    assert d["sel"] == app.ALL and d["win"] == [int(w) for w in win]
    assert len(d["second"]) == tr.n_tokens and d["lead"][3] == pytest.approx(lead[3], abs=1e-3)
    assert "D.sel === 'all'" in app.JS and "'no leading axis'" in app.JS


def test_the_all_four_mode_is_smoothed_and_corrected_like_the_rows(app):
    """The map's winner at each token is the series' winner: same block, same smoothing."""
    tr = make_trace(T=80, prompt_len=6, eot=70)
    tmap = app.token_map_html(tr, app.ALL, smooth=9, block=tr.blocks[1])
    d = _payload(app.series_html(tr, app.ALL, smooth=9, block=tr.blocks[1]))
    S = np.array([[v for v in row[:tr.n_axes]] for row in d["smooth"]])
    assert list(S.argmax(1)) == d["win"]
    for i, w in enumerate(d["win"]):
        if d["lead"][i] / app.LEAD_FULL >= 0.01:
            assert f'class="t ax{w}" data-i="{i}"' in tmap
    assert "smoothed over" not in tmap and f"block {tr.blocks[1]}" not in tmap
    # signed: a token whose every projection is negative has no leading axis and no tint
    tr2 = make_trace(T=12, prompt_len=2, eot=8)
    tr2.field[:, 5, :] = -1.0
    tm = app.token_map_html(tr2, app.ALL, signed=True, smooth=1)
    assert 'class="t" data-i="5"' in tm


def test_the_axis_pills_carry_their_axis_s_colour(app):
    """The control and the map share one language: each axis pill is outlined in its line
    colour and filled, when selected, with its darkest wash, on which ink is legible; the
    entropy pill takes its slate; "all four" stays neutral."""
    css = app.CSS
    names = app._terms.categories()
    for pos, n in enumerate(names, start=1):
        assert (f".ul-axes-radio .wrap label:nth-child({pos}) "
                f"{{ --pc:{app.AXIS_COLOUR[n]}; --pf:{app.WASH[n][2]};") in css
    assert f"label:nth-child({len(names) + 1})" not in css          # all four: no rule
    assert (f"label:nth-child({len(names) + 2}) {{ --pc:{app.ENTROPY_COLOUR}; "
            f"--pf:{app.WASH[app.ENTROPY][2]};") in css
    assert app.channel_label(app.ALL) == "all four"


def test_no_view_restates_what_a_control_shows(app):
    """The control row says which block, which value, how much smoothing and whether the
    baseline is corrected; legends and captions carry only encodings a reader cannot infer."""
    tr = make_trace(T=60, prompt_len=6, eot=50)
    for ch in list(tr.names) + [app.ALL, app.ENTROPY]:
        for signed in (False, True):
            tmap = app.token_map_html(tr, ch, signed, smooth=9, block=tr.blocks[1])
            legend = re.search(r'<div class="ul-maplegend">(.*?)</div><div class="ul-mapbody"',
                               tmap, re.DOTALL).group(1)
            for echo in ("block", "smooth", "rectified", "signed projection", "percentile",
                         "trace range"):
                assert echo not in legend, (ch, signed, echo)
            assert "chat template" not in tmap
    ser = app.series_html(tr, smooth=9)
    assert "ul-caption" not in ser and "shared scale" not in ser
    assert ser.count("thinking-block mean") == tr.n_axes + 1    # a statistic shown nowhere else
    assert ser.count("nats") == 1
    # the simplex says only what the controls cannot: its extra smoothing, its zoom, its drop
    sx = app.simplex_html(tr, smooth=9)
    cap = re.search(r'<p class="ul-caption">(.*?)</p>', sx).group(1)
    assert f"further {app.PATH_SMOOTH} tokens" in cap and "magnitude is dropped" in cap
    assert "block" not in cap and "rectified" not in cap and "baseline" not in cap


def test_the_simplex_panel_draws_one_disc_per_token_in_its_leading_axis(app):
    """The third view: shares of the smoothed rectified components as barycentric
    coordinates, every token a disc coloured by its leader and sized by its lead, prompt
    tokens grey, the end-of-think token ringed; the frame is the four axes."""
    from ulens import simplex as sx
    tr = make_trace(T=60, prompt_len=6, eot=50)
    html = app.simplex_html(tr, app.ALL, smooth=9)
    assert 'class="ul-simplex"' in html and html.count('<svg class="fig"') == 1
    assert html.count('class="d p"') == tr.prompt_len                     # grey prompt discs
    assert html.count('class="d"') == tr.n_tokens - tr.prompt_len
    assert html.count("<line ") == 6 and html.count('class="eot"') == 1   # frame, eot ring
    for name in tr.names:
        assert f'fill="{app.axis_colour(name)}">{name.replace("_", " ")}</text>' in html
    # colour and radius follow the leader and the lead of the doubly smoothed composition
    S, W, P = app.simplex_composition(tr, 9)
    win, _, lead = app.winner_lead(S)
    np.testing.assert_allclose(W.sum(1), 1.0)
    assert W.shape == (tr.n_tokens, tr.n_axes) and (W >= 0).all()
    assert (sx.boundary_fraction(P) <= 1.0 + 1e-9).all()                 # inside the frame
    found = re.findall(r'<circle class="d" data-i="(\d+)" cx="[-\d.]+" cy="[-\d.]+" '
                       r'r="([\d.]+)" fill="(#[0-9a-fA-F]{6})"', html)
    discs = {int(i): (float(r), c) for i, r, c in found}
    assert len(discs) == tr.n_tokens - tr.prompt_len
    lo, hi = app.SIMPLEX_R
    for i, (r, colour) in discs.items():
        assert colour == app.axis_colour(tr.names[win[i]])
        assert r == pytest.approx(lo + (hi - lo) * min(lead[i] / app.LEAD_FULL, 1.0), abs=0.06)
    assert len({c for _r, c in discs.values()}) > 1                       # more than one leader
    # extra smoothing beyond the page's, declared; nothing escapes the tetrahedron when zoomed
    S9 = app.smooth_tokens(app.axis_matrix(tr).T, 9).T
    assert not np.allclose(S, S9)
    np.testing.assert_allclose(S, app.smooth_tokens(S9.T, app.PATH_SMOOTH).T, atol=1e-5)
    k = float(re.search(r"drawn ×([\d.]+) about the centre", html).group(1))
    assert 1.0 < k <= app.SIMPLEX_ZOOM_MAX
    xs = [float(v) for v in re.findall(r'<circle class="d[ p]*" data-i="\d+" cx="([-\d.]+)"', html)]
    assert xs and max(abs(x) for x in xs) <= app.SIMPLEX_SCALE * 1.0001
    # the hover payload is the series' payload plus the shares, so the tooltip keeps working
    d = _payload(html)
    assert d["T"] == tr.n_tokens and len(d["share"]) == tr.n_tokens
    assert d["share"][7] == pytest.approx(list(W[7]), abs=1e-3)
    assert "D.share" in app.JS and ".ul-simplex" in app.JS and "nearestDisc" in app.JS
    # the panel switch: the third element of views() is whichever panel is asked for
    assert app.views(tr, panel="simplex")[2].startswith('<div class="ul-simplex"')
    assert app.views(tr, panel="series")[2].startswith('<div class="ul-series"')
    assert app.views(tr)[2].startswith('<div class="ul-series"')
    assert [k for _l, k in app.PANELS] == ["series", "simplex"]


def test_the_simplex_honours_the_correction_and_always_reads_rectified_components(app):
    """The baseline correction moves the path like every other view; the value control does
    not, because shares need non-negative parts — and the legend says so when it is set."""
    tr = make_trace(T=60, prompt_len=6, eot=50)
    if app.BASELINE is None or app.BASELINE.model != tr.model:
        pytest.skip("no shipped baseline for the fixture's model at its block")
    tr.readout_block = app.BASELINE.block
    tr.blocks = [app.BASELINE.block - 1, app.BASELINE.block, app.BASELINE.block + 1]
    tr.field = tr.field[:3]
    _s, W_raw, _p = app.simplex_composition(tr, 9, None, "none")
    _s, W_cor, _p = app.simplex_composition(tr, 9, None, "centre")
    assert not np.allclose(W_raw, W_cor)
    assert (W_cor >= 0).all() and (W_raw >= 0).all()
    html_signed = app.simplex_html(tr, signed=True, smooth=9, correction="centre")
    html_rect = app.simplex_html(tr, signed=False, smooth=9, correction="centre")
    assert "rectified components, not signed" in html_signed and "not signed" not in html_rect

    def discs(h):
        return re.findall(r'<circle class="d[ p]*" data-i="\d+" cx="[-\d.]+" cy="[-\d.]+" '
                          r'r="[\d.]+"', h)
    assert discs(html_signed) == discs(html_rect) and len(discs(html_rect)) == tr.n_tokens
    assert discs(html_rect) != discs(app.simplex_html(tr, smooth=9, correction="none"))


def test_legends_show_the_mark_and_name_it(app):
    """A legend renders a sample of the mark beside a word or two. No legend on the page is
    a dot-separated run of `label: description` pairs, and no view prints its own name as a
    heading under the control that already names it."""
    tr = make_trace(T=60, prompt_len=6, eot=50)
    runon = re.compile(r"\w: \w[^<]* · \w[^<]*: ")
    # the simplex key: four discs in the axes' colours, the two radius extremes outlined, the
    # prompt's grey disc, the red ring — each drawn, each named, on one strip
    sx = app.simplex_html(tr, smooth=9)
    keys = re.search(r'<div class="ul-keys">(.*?)</div><svg class="fig"', sx, re.DOTALL).group(1)
    assert not runon.search(sx) and "disc: one token" not in sx and "grey: prompt" not in sx
    assert "<b>simplex</b>" not in sx and "ul-maplegend" not in sx
    assert keys.count('class="k"') == 4 and keys.count("<svg") == 4
    for name in tr.names:
        assert '<circle class="kd" cx="' in keys and f'fill="{app.axis_colour(name)}"/>' in keys
    lo, hi = app.SIMPLEX_R
    assert f'<circle class="ko" cx="{lo + 1:g}" cy="9" r="{lo:g}"/>' in keys
    assert f'r="{hi:g}"/>' in keys and keys.count('class="ko"') == 2
    assert keys.count('class="kp"') == 1 and keys.count('class="ke"') == 1
    for word in ("leading axis", "lead over the runner-up", "prompt", "end of think"):
        assert f"</svg>{word}</span>" in keys, word
    assert "Red ring" not in sx                               # the ring is in the key, drawn
    assert "not signed" not in keys
    assert "rectified components, not signed" in app.simplex_html(tr, signed=True, smooth=9)
    # no thinking block: no ring is drawn, so none is in the key; a budget cut names itself
    sx0 = app.simplex_html(make_trace(prompt_len=6, eot=5), smooth=9)
    assert 'class="ke"' not in sx0 and "end of think" not in sx0
    sxt = app.simplex_html(make_trace(truncated=True, eot=19), smooth=9)
    assert 'class="ke"' in sxt and "</svg>budget cut</span>" in sxt
    # the all-four map: the four chips and a sample of the tint, faint to full, beside its
    # name; nothing that defines what a token is
    tmap = app.token_map_html(tr, app.ALL, smooth=9)
    legend = re.search(r'<div class="ul-maplegend">(.*?)</div><div class="ul-mapbody"', tmap,
                       re.DOTALL).group(1)
    assert not runon.search(legend) and "each token" not in legend and "strength =" not in legend
    assert '<span class="key"><i class="grad"></i>lead over the runner-up</span>' in legend
    assert legend.count('class="chip ax') == tr.n_axes and 'class="unit"' not in legend
    assert ".ul-maplegend .grad" in app.CSS and ".ul-keys .ko" in app.CSS
    # one axis: the swatch and name, then the wash's steps as chips, as before
    one = app.token_map_html(tr, tr.names[0], smooth=9)
    assert one.count('class="chip b') == 4 and not runon.search(one)
    # the hover reads the figure, not the key's samples
    assert "'.ul-simplex svg.fig'" in app.JS


def test_the_link_bar_renders_only_what_is_configured(app, monkeypatch):
    """The paper, the blog and the code have built-in targets; each environment variable
    overrides its target, and set empty drops the link. A label with neither is not rendered
    — no dead href, no placeholder — and with nothing left the bar is absent and the head is
    exactly the bare one. "Try it locally" is the hosting command, shown as code, never a
    link, and has no built-in value while the package is not on PyPI."""
    labels = [lab for lab, _var, _default in app.LINKS]
    assert labels == ["Read the paper", "Read the blog", "Try it locally", "See the code"]
    defaults = {var: d for _lab, var, d in app.LINKS}
    assert defaults["ULENS_LINK_PAPER"].startswith("https://arxiv.org/abs/")
    assert defaults["ULENS_LINK_BLOG"].startswith("https://") and defaults["ULENS_LINK_CODE"]
    assert defaults[app.LOCAL_ENV] == ""                 # not until the command works
    bar = app.links_html({})
    assert bar.count("<a ") == 3 and "Try it locally" not in bar and "<code>" not in bar
    for var in ("ULENS_LINK_PAPER", "ULENS_LINK_BLOG", "ULENS_LINK_CODE"):
        assert f'href="{defaults[var]}"' in bar
    assert bar.index("Read the paper") < bar.index("Read the blog") < bar.index("See the code")
    assert 'target="_blank" rel="noopener"' in bar and "coming soon" not in bar.lower()
    assert "ul-links" not in app.INTRO and "<nav" not in app.INTRO
    assert 'class="ul-links"' in app.intro_html(bar)
    # an override replaces one target and leaves the others; empty or blank drops it
    one = app.links_html({"ULENS_LINK_PAPER": "https://example.org/paper.pdf"})
    assert one.count("<a ") == 3 and 'href="https://example.org/paper.pdf"' in one
    assert defaults["ULENS_LINK_PAPER"] not in one and defaults["ULENS_LINK_CODE"] in one
    two = app.links_html({"ULENS_LINK_BLOG": "   "})
    assert two.count("<a ") == 2 and "Read the blog" not in two
    none = {"ULENS_LINK_PAPER": "", "ULENS_LINK_BLOG": "", "ULENS_LINK_CODE": ""}
    assert app.links_html(none) == "" and app.intro_html(app.links_html(none)) == app.INTRO
    # try it locally: the command, as code, line by line, and never a link
    cmd = app.links_html(dict(none, ULENS_LINK_LOCAL='pip install "ulens[app]"\nulens app'))
    assert "<a " not in cmd and cmd.count('class="cmd"') == 1
    assert ('<span class="cmd">Try it locally<code>pip install &quot;ulens[app]&quot;\n'
            'ulens app</code></span>') in cmd
    assert "<a " not in app.links_html(dict(none, ULENS_LINK_LOCAL="https://example.org/x"))
    assert "white-space: pre-line" in app.CSS and "user-select: all" in app.CSS
    # the head carries the bar on its top line, beside the mark
    page = app.intro_html(bar)
    assert page.index('class="ul-mark"') < page.index('class="ul-links"') < page.index("<h1>")
    # build() reads the environment: the defaults, an override, or nothing at all

    def heads(demo):
        return [b.value for b in demo.blocks.values()
                if isinstance(b, gr.HTML) and b.value and "ul-links" in b.value]

    for var in defaults:
        monkeypatch.delenv(var, raising=False)
    h = heads(app.build())
    assert len(h) == 1 and h[0].count("<a ") == 3 and "Try it locally" not in h[0]
    monkeypatch.setenv("ULENS_LINK_LOCAL", "pip install ulens")
    monkeypatch.setenv("ULENS_LINK_BLOG", "")
    h = heads(app.build())
    assert len(h) == 1 and "<code>pip install ulens</code>" in h[0]
    assert "Read the blog" not in h[0] and h[0].count("<a ") == 2
    for var in defaults:
        monkeypatch.setenv(var, "")
    assert heads(app.build()) == []


def test_the_panel_switch_is_the_panel_s_header(app):
    """The series/simplex switch belongs to the right-hand panel, not to the control row:
    it is styled as tabs on a rule, wears no pill, and the panel prints no heading under it."""
    import inspect
    src = inspect.getsource(app.build)
    m = re.search(r'gr\.Radio\(choices=list\(PANELS\).*?\)', src, re.DOTALL)
    assert m and '"ul-panel"' in m.group(0) and "ul-radio" not in m.group(0)
    assert ".ul-panel .wrap label" in app.CSS and "border-bottom: 1px solid var(--grid)" in app.CSS
    tr = make_trace()
    for panel in ("series", "simplex"):
        right = app.views(tr, panel=panel)[2]
        assert f"<b>{panel}</b>" not in right


def test_the_mark_is_on_the_page_and_is_the_favicon(app):
    from ulens import simplex as sx
    assert sx.mark_svg() in app.INTRO and 'class="ul-mark"' in app.INTRO
    assert ".ul-mark svg" in app.CSS
    import inspect
    assert "favicon_path=str(_simplex.MARK_PATH)" in inspect.getsource(app.main)


def test_the_separation_table_is_off_the_page_but_in_the_package(app):
    import ulens
    assert not hasattr(app, "separation_html")
    assert "Axis separation" not in app.CSS and "ul-cos" not in app.CSS
    assert callable(ulens.anatomy.separation)
    from pathlib import Path
    assert "Axis separation" not in Path(app.__file__).read_text()