//! The app's own affordances, emitted once per document.
//!
//! [`Chrome`] names keys that work from every screen and what they call. This
//! is the webview's answer to them: one hidden element per binding, carrying
//! the same transport attributes any control gets, fired by a key event on the
//! body rather than by a click on itself. No custom JS, and no per-app copy of
//! the palette's plumbing.
//!
//! Plus [`Chrome::panels`], the things the app keeps on screen whatever screen
//! is showing: one element each, carrying the panel's id and holding its node
//! drawn the way any node is drawn. The id is what an answer aims at, so a route
//! that has changed what a panel says reaches it through
//! [`Response::also`](quasi_router::Response::also) with no second mechanism.
//! Where each sits is left to the stylesheet, which is this host's answer to the
//! placement question the description declines: a browser has a stylesheet, and
//! the class is the hook.
//!
//! Since `71aa29b4` there can be several, and each carries a
//! [`Role`](quasi_router::Role). The role rides out as `data-role`, beside the
//! shared `chrome-panel` class rather than instead of it: the class is what a
//! stylesheet written before roles existed selects on, and an app with one panel
//! gets the same element it always did plus one attribute.
//!
//! Plus [`Chrome::nav`], the places the app has. Drawn as a `nav` of links, one
//! level of nesting for the places inside a place, and marked with
//! `aria-current="page"` where the screen said it is. That is the same attribute
//! [`Row::current`](quasi_router::screen::Row::current) already emits, because
//! it is the same claim: this is the one showing.
//!
//! Plus the overlay container, which is where an
//! [`Outcome::Over`](quasi_router::Outcome::Over) lands. It is emitted empty
//! and stays empty until something is drawn into it, so a document with chrome
//! and no overlay open is a document with one spare `div` in it. That spare
//! `div` is the rule and not an edge case: any app declaring chrome gets one,
//! because a route can answer `Over` without a binding to open it, and
//! [`overlay_target`](quasi_http::Serves::overlay_target) promises this
//! renderer has a container to aim at whatever the app declared.
//!
//! # Interpreting a key name is this crate's job, not the description's
//!
//! [`Binding::key`](quasi_router::Binding::key) is text — "ctrl+k", "?" —
//! because the vocabulary of keys is the host's. This is a host, so here is
//! where the text becomes something concrete: an htmx trigger filter over
//! `KeyboardEvent`. A name this renderer cannot parse is ignored, which is the
//! rule `Act::key` already states for a key one host wants and another has
//! never heard of.

use makeover_webview::Emit;
use makeover_webview::form::escape_into;
use quasi_router::{Band, Binding, Brand, Chrome, Disclose, Panel, Place};

use crate::node::{Doc, Fires, action_attrs, class_into, node_html};

/// The element an overlay is drawn into.
///
/// A fixed id rather than a configurable one: the router names the outcome and
/// the renderer names the place, and a host that could rename it is a host that
/// can rename it to something the retarget header does not point at.
pub const OVERLAY_ID: &str = "quasi-overlay";

/// The bindings, the overlay container and the panel, for the end of a
/// document's body.
///
/// Empty when the app declares no chrome. An app that declares none gets a
/// document byte-for-byte the same as before chrome existed, which is what
/// makes this additive.
pub(crate) fn chrome_html(chrome: &Chrome, opts: &Emit, doc: &Doc<'_>, out: &mut String) {
    for binding in &chrome.bindings {
        binding_html(binding, out);
    }
    // Emitted whenever the app declares any chrome, because a route can answer
    // `Outcome::Over` without a binding being involved: a control on a screen
    // calls a route, and the route answers with an overlay. Bindings were the
    // wrong condition. They were the only way an overlay was opened when this
    // was written, and goingson opens one from a row's control with no binding
    // anywhere in its chrome, so the guard dropped the container out of exactly
    // the document that needed it.
    //
    // Not unconditional, so an app declaring no chrome at all still gets the
    // byte-for-byte document above.
    //
    // The comment rides in front rather than inside: an overlay swap replaces
    // the container's contents, so a comment within it would be destroyed by
    // the first `Over` and gone by the time anyone inspected the element.
    if !chrome.bindings.is_empty() || !chrome.panels.is_empty() || !chrome.nav.is_empty() {
        out.push_str("<!-- quasi: overlay container; an Outcome::Over lands here -->");
        out.push_str("<div id=\"");
        out.push_str(OVERLAY_ID);
        out.push_str("\" data-chrome=\"overlay\"></div>");
    }
    for panel in &chrome.panels {
        panel_html(panel, opts, doc, out);
    }
}

/// The id of the checkbox a disclosed nav is opened by.
///
/// A fixed id for [`OVERLAY_ID`]'s reason: the label points at it by name, and
/// a host that could rename it is a host that can rename it to something the
/// label does not reach.
pub const DISCLOSE_ID: &str = "quasi-disclose";

/// The header band: the brand, the disclosure, the search box and the nav, as
/// one element before the content.
///
/// One element is the whole point of the member. A stylesheet cannot make a bar
/// out of siblings that are not siblings, and a narrow-viewport menu written as
/// a checkbox styling what follows it matches nothing when the checkbox and the
/// nav are in different parents. So this emits `<header>` and the nav goes
/// inside it, rather than [`nav_html`] running on its own.
///
/// # The order, and why it is not the description's
///
/// Brand, checkbox, label, search, nav. The checkbox comes before everything it
/// is meant to disclose, because `~` reaches forward and only forward: a
/// toggle written after the search box could never style it. That is a fact
/// about CSS rather than about the app, which is exactly the kind of thing a
/// description should not be carrying.
///
/// # No JavaScript
///
/// The checkbox is the mechanism, the same one the hand-written headers this
/// replaces already used. A disclosure that needed a script would be a
/// disclosure that does not work while the bundle is loading, which is when a
/// reader on a phone first reaches for the menu.
/// The header a document opens with: the band when the app declared one, the
/// bare nav when it did not, and nothing when it has neither.
///
/// Public because a host that assembles its own body needs it and cannot reach
/// what [`Parts`](crate::Parts) carries: `Parts::body_chrome` is the *end* of
/// the body -- the bindings, the overlay container and the panels -- and a
/// header goes before the content that host is about to write. Without this a
/// host with Askama pages beside its described ones has to hand-write the
/// header for the templated half, which is exactly the divergence
/// [`Chrome::band`] exists to end.
///
/// `at` is the [`Place::key`] of the place showing, or `None` where the host
/// has no screen to ask. Nothing is marked in that case, rather than the last
/// place staying lit.
#[must_use]
pub fn header_html(chrome: &Chrome, at: Option<&str>, opts: &Emit) -> String {
    let mut out = String::with_capacity(512);
    match &chrome.band {
        Some(band) => band_html(band, &chrome.nav, at, opts, &Doc::bare(), &mut out),
        None => nav_html(&chrome.nav, at, opts, &mut out),
    }
    out
}

pub(crate) fn band_html(
    band: &Band,
    places: &[Place],
    at: Option<&str>,
    opts: &Emit,
    doc: &Doc<'_>,
    out: &mut String,
) {
    out.push_str("<header class=\"");
    class_into("chrome-band", opts, out);
    out.push_str("\" role=\"banner\" data-chrome=\"band\">");

    if let Some(brand) = &band.brand {
        brand_html(brand, opts, out);
    }

    if band.disclose == Disclose::Narrow {
        disclose_html(opts, out);
    }

    if let Some(search) = &band.search {
        out.push_str("<div class=\"");
        class_into("chrome-search", opts, out);
        out.push_str("\" role=\"search\">");
        // The same field emitter every question goes through. A search box in
        // the header is not a second kind of box, and this crate has never had
        // a second field emitter to give it one.
        node_html(
            &quasi_router::Node::Field(Box::new(search.clone())),
            opts,
            doc,
            out,
        );
        out.push_str("</div>");
    }

    nav_html(places, at, opts, out);

    out.push_str("</header>");
}

/// The wordmark: the name, with its one marked run drawn as the mark.
///
/// A link, because it goes somewhere, and for [`place_html`]'s reasons: a
/// middle click opens it in a tab and the status bar says where it goes.
///
/// The mark is not hidden from a screen reader. `Makenot.work` is a domain and
/// hearing "Makenot dot work" is hearing the name; the hand-written header this
/// replaces marked the dot `aria-hidden`, which left the accessible name as
/// "Makenotwork", something the app is not called.
fn brand_html(brand: &Brand, opts: &Emit, out: &mut String) {
    let (before, mark, after) = brand.parts();
    out.push_str("<a class=\"");
    class_into("chrome-brand", opts, out);
    out.push('"');
    action_attrs(&brand.action, Fires::Click, None, None, false, out);
    out.push('>');
    escape_into(before, out);
    if !mark.is_empty() {
        out.push_str("<span class=\"");
        class_into("chrome-brand-mark", opts, out);
        out.push_str("\">");
        escape_into(mark, out);
        out.push_str("</span>");
    }
    escape_into(after, out);
    out.push_str("</a>");
}

/// The checkbox and its label, for a nav that hides when there is no room.
///
/// A `<label>` and not a button: the checkbox holds the state, and a button
/// would need a script to change it. The three spans are the bars of the
/// control, left to the stylesheet to draw, which is this renderer's standing
/// answer to a placement question a description declines.
fn disclose_html(opts: &Emit, out: &mut String) {
    out.push_str("<input type=\"checkbox\" id=\"");
    out.push_str(DISCLOSE_ID);
    out.push_str("\" class=\"");
    class_into("chrome-disclose-state", opts, out);
    out.push_str("\" aria-hidden=\"true\"><label for=\"");
    out.push_str(DISCLOSE_ID);
    out.push_str("\" class=\"");
    class_into("chrome-disclose", opts, out);
    out.push_str("\" aria-label=\"Toggle navigation menu\">");
    out.push_str("<span></span><span></span><span></span></label>");
}

/// The nav: the app's places, as links, with the current one marked.
///
/// Emitted before the screen rather than with the rest of the chrome, and that
/// is the one placement decision this renderer makes. It makes it in document
/// order and not in pixels: a navigation that comes after the content is a
/// landmark a screen reader reaches last and a block a stylesheet has to lift
/// with `position: fixed` and then pay for in padding. Where it lands visually
/// is still the stylesheet's, the same as a panel's.
///
/// A `nav` element and not a list of buttons. These are addresses, so they are
/// links: middle-click opens one in a tab, the status bar shows where it goes,
/// and a screen reader lands on a navigation landmark. None of that is
/// available to a button that calls a route.
///
/// One level of nesting, which is the depth [`Place::within`] describes. The
/// inner list is emitted inside its place's item rather than beside it, so the
/// structure a description stated is the structure the document has and a
/// stylesheet can draw either level whichever way it likes.
pub(crate) fn nav_html(places: &[Place], at: Option<&str>, opts: &Emit, out: &mut String) {
    if places.is_empty() {
        return;
    }
    out.push_str("<nav class=\"");
    class_into("chrome-nav", opts, out);
    out.push_str("\" data-chrome=\"nav\">");
    place_list(places, at, opts, out);
    out.push_str("</nav>");
}

/// One level of places, as a list.
fn place_list(places: &[Place], at: Option<&str>, opts: &Emit, out: &mut String) {
    out.push_str("<ul>");
    for place in places {
        out.push_str("<li>");
        place_html(place, at, opts, out);
        if !place.within.is_empty() {
            place_list(&place.within, at, opts, out);
        }
        out.push_str("</li>");
    }
    out.push_str("</ul>");
}

/// One place, as the link that goes there.
///
/// A place holding others is marked when the screen is any of them, which is
/// what [`Place::holds`] answers. Asked of the nav rather than worked out here,
/// so the three renderers cannot disagree about how deep the search goes.
fn place_html(place: &Place, at: Option<&str>, opts: &Emit, out: &mut String) {
    let current = at.is_some_and(|key| place.holds(key));
    out.push_str("<a class=\"");
    class_into("chrome-place", opts, out);
    out.push('"');
    // The key, so a host script can find a place it cares about. `Place::key`
    // is an identifier the app chose and never display text, which is exactly
    // what a selector wants; without it a script looking for one place has only
    // the label, which is renamed, translated and reworded to fit.
    //
    // A data attribute rather than an id: two places may carry one key -- the
    // vocabulary says so, and calls it an app pointing at itself twice -- and
    // two elements under one id is markup a browser resolves by picking the
    // first.
    out.push_str(" data-place=\"");
    escape_into(&place.key, out);
    out.push('"');
    if current {
        // The same attribute a current row emits. A CSS hook and an
        // accessibility fact in one, rather than a class the stylesheet knows
        // and a screen reader does not.
        out.push_str(" aria-current=\"page\"");
    }
    action_attrs(&place.action, Fires::Click, None, None, false, out);
    out.push('>');
    escape_into(&place.label, out);
    out.push_str("</a>");
}

/// The panel: its id, its class, and its node inside.
///
/// The id is the address rather than decoration. An out-of-band swap aimed at
/// the panel writes `innerHTML:#<id>`, so the element survives the swap and
/// keeps the class the stylesheet places it by, which is the same arrangement
/// every region already has.
fn panel_html(panel: &Panel, opts: &Emit, doc: &Doc<'_>, out: &mut String) {
    out.push_str("<div id=\"");
    escape_into(&panel.id, out);
    out.push_str("\" class=\"");
    class_into("chrome-panel", opts, out);
    // Beside the class rather than instead of it. A stylesheet written when
    // there was one panel selects `.chrome-panel` and still finds this one.
    out.push_str("\" data-role=\"");
    out.push_str(role_name(panel.role));
    out.push_str("\">");
    node_html(&panel.content, opts, doc, out);
    out.push_str("</div>");
}

/// What a role is called in the document.
///
/// Spelled here rather than derived, so a variant renamed in the vocabulary is
/// a compile error at this match instead of a silently different attribute.
fn role_name(role: quasi_router::Role) -> &'static str {
    match role {
        quasi_router::Role::Activity => "activity",
        quasi_router::Role::Status => "status",
    }
}

/// One binding: the transport of a control, the trigger of a keystroke.
fn binding_html(binding: &Binding, out: &mut String) {
    let Some(filter) = trigger_filter(&binding.key) else {
        // A key name this renderer does not understand. Ignored rather than
        // guessed at, and ignored silently for the same reason a webview
        // ignores a key a terminal wanted: it is not this host's keyboard.
        return;
    };

    out.push_str("<button type=\"button\" hidden data-chrome aria-label=\"");
    escape_into(&binding.label, out);
    out.push('"');

    // The answer goes into the overlay container. A binding whose route
    // answers with something other than `Over` overrides this by naming its
    // own target on the action, which `action_attrs` emits after this.
    //
    // Unless nothing is coming back. A binding that goes back makes no request,
    // so a target would say an answer lands in the overlay when there is no
    // answer -- the same lie the `Local` branch of `action_attrs` refuses to
    // write an address for.
    if !binding.action.destination.is_back() {
        out.push_str(" hx-target=\"#");
        out.push_str(OVERLAY_ID);
        out.push('"');
    }

    action_attrs(&binding.action, Fires::Key(&filter), None, None, false, out);
    out.push_str("></button>");
}

/// A key name as an htmx trigger filter, or `None` if it is not one.
///
/// `"ctrl+k"` becomes `key=='k'&&ctrlKey&&!altKey&&!metaKey`. The negatives are
/// stated rather than left open: without them `ctrl+k` also fires on
/// `ctrl+alt+k`, and an app that bound both would fire both.
fn trigger_filter(key: &str) -> Option<String> {
    let mut ctrl = false;
    let mut alt = false;
    let mut shift = false;
    let mut meta = false;
    let mut base = None;

    for part in key.split('+') {
        let part = part.trim();
        if part.is_empty() {
            return None;
        }
        match part.to_ascii_lowercase().as_str() {
            "ctrl" | "control" => ctrl = true,
            "alt" | "option" => alt = true,
            "shift" => shift = true,
            "meta" | "cmd" | "super" => meta = true,
            // The last non-modifier wins nothing: two of them is a name this
            // renderer does not understand, not a chord it can guess at.
            _ if base.is_some() => return None,
            _ => base = Some(part.to_string()),
        }
    }

    let base = base?;
    // A single printable character, or a name the DOM already uses for a key
    // that prints nothing. `KeyboardEvent.key` is what both are compared
    // against, and its names are capitalised.
    let value = if base.chars().count() == 1 {
        base
    } else {
        named_key(&base)?
    };

    let mut filter = format!("key=='{}'", js_string(&value));
    for (held, name) in [
        (ctrl, "ctrlKey"),
        (alt, "altKey"),
        (meta, "metaKey"),
        (shift, "shiftKey"),
    ] {
        // Shift is asserted when asked for and never denied: a printable key
        // that needs shift to type reports it held, so `?` on a US layout
        // arrives as shift+/ and denying shift would make it unreachable.
        if held {
            filter.push_str("&&");
            filter.push_str(name);
        } else if name != "shiftKey" {
            filter.push_str("&&!");
            filter.push_str(name);
        }
    }
    Some(filter)
}

/// The `KeyboardEvent.key` name for a key that prints nothing.
///
/// A short list rather than every name in the spec: these are the ones a
/// description plausibly binds, and a name absent here is ignored rather than
/// passed through. Passing an unknown name through would emit a filter that
/// silently never matches, which is worse than not emitting one.
fn named_key(name: &str) -> Option<String> {
    let named = match name {
        "escape" | "esc" => "Escape",
        "enter" | "return" => "Enter",
        "tab" => "Tab",
        "space" => " ",
        "backspace" => "Backspace",
        "delete" | "del" => "Delete",
        "up" | "arrowup" => "ArrowUp",
        "down" | "arrowdown" => "ArrowDown",
        "left" | "arrowleft" => "ArrowLeft",
        "right" | "arrowright" => "ArrowRight",
        "home" => "Home",
        "end" => "End",
        "pageup" => "PageUp",
        "pagedown" => "PageDown",
        _ => return None,
    };
    Some(named.to_string())
}

/// A key value as the inside of a single-quoted JS string.
///
/// The value reaches the browser inside an attribute inside a filter, so it is
/// escaped twice by two different rules: this one, then HTML escaping by
/// `action_attrs`. A key of `'` is the case that needs it.
fn js_string(value: &str) -> String {
    value.replace('\\', "\\\\").replace('\'', "\\'")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_modifier_key_names_what_is_held_and_what_is_not() {
        let filter = trigger_filter("ctrl+k").expect("parsed");
        assert!(filter.contains("key=='k'"));
        assert!(filter.contains("&&ctrlKey"));
        // Stated, so ctrl+alt+k does not also fire a ctrl+k binding.
        assert!(filter.contains("&&!altKey"));
        assert!(filter.contains("&&!metaKey"));
    }

    #[test]
    fn shift_is_asserted_when_asked_for_and_never_denied() {
        // A printable key that needs shift to type reports it held, so denying
        // it would make `?` unreachable on a US layout.
        let plain = trigger_filter("?").expect("parsed");
        assert!(!plain.contains("shiftKey"));
        let held = trigger_filter("shift+a").expect("parsed");
        assert!(held.contains("&&shiftKey"));
        assert!(!held.contains("!shiftKey"));
    }

    #[test]
    fn a_key_that_prints_nothing_is_named_the_way_the_dom_names_it() {
        assert!(
            trigger_filter("escape")
                .expect("parsed")
                .contains("'Escape'")
        );
        assert!(
            trigger_filter("arrowup")
                .expect("parsed")
                .contains("'ArrowUp'")
        );
    }

    #[test]
    fn a_name_this_renderer_does_not_understand_is_ignored() {
        // Not guessed at: an unknown name passed through would emit a filter
        // that silently never matches.
        assert!(trigger_filter("dpad-left").is_none());
        assert!(trigger_filter("ctrl+j+k").is_none());
        assert!(trigger_filter("ctrl+").is_none());
        assert!(trigger_filter("").is_none());
    }

    #[test]
    fn a_quote_in_a_key_cannot_close_the_filter_it_sits_in() {
        let filter = trigger_filter("'").expect("parsed");
        assert!(filter.contains("\\'"), "{filter}");
    }

    #[test]
    fn a_bound_key_that_goes_back_listens_for_that_key_and_calls_no_route() {
        // `33c27e81`. The whole point of one destination rather than
        // `Chrome::back(Action)`: a binding and a visible Close cannot disagree
        // about where back goes, because neither of them names it.
        //
        // The gesture has to be in the program. This button is `hidden` and
        // never focused, so it is never clicked, and a program that only
        // listened for a click would leave every bound key silently doing
        // nothing.
        let mut out = String::new();
        chrome_html(
            &Chrome::new().bind("escape", "Back", quasi_router::Action::back()),
            &Emit::default(),
            &Doc::bare(),
            &mut out,
        );

        assert!(out.contains("call history.back()"), "{out}");
        assert!(out.contains("keydown[key==&#39;Escape&#39;"), "{out}");
        assert!(out.contains("from window"), "{out}");
        // No route is asked for, and above all no empty address: an `hx-get`
        // with none is what htmx reads as "ask the page you are on". No target
        // either, because nothing is coming back to put anywhere.
        assert!(!out.contains("hx-get"), "{out}");
        assert!(!out.contains("hx-trigger"), "{out}");
        assert!(!out.contains("hx-target"), "{out}");
    }

    #[test]
    fn an_app_with_no_chrome_emits_nothing_at_all() {
        let mut out = String::new();
        chrome_html(&Chrome::new(), &Emit::default(), &Doc::bare(), &mut out);
        assert!(out.is_empty());
    }

    #[test]
    fn a_panel_carries_the_address_an_answer_aims_at() {
        use quasi_router::Node;

        let chrome = Chrome::new().presenting(
            "timer",
            quasi_router::Role::Activity,
            Node::text("00:12:04"),
        );
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);
        assert!(out.contains("id=\"timer\""), "{out}");
        assert!(out.contains("chrome-panel"), "{out}");
        assert!(out.contains("00:12:04"), "{out}");
        // A panel and no bindings, which is goingson's chrome, and the case
        // that used to lose the container: its Focus control calls a route
        // that answers `Over`, and the retarget aimed at an element the
        // document did not have.
        assert!(out.contains(OVERLAY_ID), "{out}");
    }

    #[test]
    fn the_overlay_container_says_what_it_is_and_says_it_outside_itself() {
        use quasi_router::Node;

        let chrome = Chrome::new().presenting(
            "timer",
            quasi_router::Role::Activity,
            Node::text("00:12:04"),
        );
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);
        // The annotation is for whoever finds an empty div in devtools, so it
        // has to survive the swap that fills the div. Before the element, not
        // within it.
        let comment = out.find("<!-- quasi: overlay").expect("annotated");
        let container = out.find("<div id=\"quasi-overlay\"").expect("emitted");
        assert!(comment < container, "{out}");
        assert!(out.contains("data-chrome=\"overlay\""), "{out}");
    }

    #[test]
    fn two_panels_each_say_what_they_are_for_and_keep_the_class_a_stylesheet_knows() {
        use quasi_router::{Node, Role};

        let chrome = Chrome::new()
            .presenting("timer", Role::Activity, Node::text("00:12:04"))
            .presenting("sync", Role::Status, Node::text("Synced"));
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);

        assert!(out.contains("id=\"timer\""), "{out}");
        assert!(out.contains("id=\"sync\""), "{out}");
        assert!(out.contains("data-role=\"activity\""), "{out}");
        assert!(out.contains("data-role=\"status\""), "{out}");
        // Beside the class rather than instead of it: a stylesheet written when
        // there was one panel still finds both.
        assert_eq!(out.matches("chrome-panel").count(), 2, "{out}");
    }

    #[test]
    fn the_nav_is_links_because_the_places_are_addresses() {
        use quasi_router::{Action, Place};

        let places = [Place::new("time", "Time", Action::get("/day"))];
        let mut out = String::new();
        nav_html(&places, None, &Emit::default(), &mut out);

        // A link and not a button: middle-click opens a tab, the status bar
        // shows where it goes, and a screen reader lands on a landmark.
        assert!(out.contains("<nav"), "{out}");
        assert!(out.contains("data-chrome=\"nav\""), "{out}");
        assert!(out.contains("<a "), "{out}");
        assert!(out.contains("Time"), "{out}");
    }

    #[test]
    fn the_place_the_screen_names_is_the_one_marked_current() {
        use quasi_router::{Action, Place};

        let places = [
            Place::new("work", "Work", Action::get("/tasks")).within([
                Place::new("tasks", "Tasks", Action::get("/tasks")),
                Place::new("board", "Board", Action::get("/board")),
            ]),
            Place::new("time", "Time", Action::get("/day")),
        ];

        let mut out = String::new();
        nav_html(&places, Some("board"), &Emit::default(), &mut out);

        // The place itself, and the place holding it. Both are where the user
        // is, and a tab bar that lit the pill and not the tab would be lying
        // about the tab.
        assert_eq!(out.matches("aria-current=\"page\"").count(), 2, "{out}");
        let work = out.find("Work").expect("drawn");
        let time = out.find("Time").expect("drawn");
        assert!(out[..work].contains("aria-current"), "the tab is marked");
        assert!(!out[time - 60..time].contains("aria-current"), "{out}");
    }

    #[test]
    fn a_screen_that_is_not_a_place_marks_nothing() {
        use quasi_router::{Action, Place};

        // A confirmation drawn over one, a detail reached from a row. The last
        // place staying lit would be the nav claiming the user is somewhere
        // they left.
        let places = [Place::new("time", "Time", Action::get("/day"))];
        let mut out = String::new();
        nav_html(&places, None, &Emit::default(), &mut out);
        assert!(!out.contains("aria-current"), "{out}");

        // And a key no place carries is the same: nothing marked, no error. The
        // nav is the app's and so is the key, and a renderer is the wrong place
        // to discover an app disagreeing with itself.
        let mut other = String::new();
        nav_html(&places, Some("nowhere"), &Emit::default(), &mut other);
        assert!(!other.contains("aria-current"), "{other}");
    }

    #[test]
    fn the_nav_comes_before_the_content_it_navigates() {
        use quasi_http::Serves as _;
        use quasi_router::{Action, Node, Place, Screen, Slot};

        // Document order, which is the one placement decision this renderer
        // makes. A navigation after the content is a landmark reached last and
        // a block the stylesheet has to lift with `position: fixed` and then
        // pay for in padding.
        let webview =
            crate::Webview::new().with_shell(crate::Shell::default().with_chrome(
                Chrome::new().offering(Place::new("time", "Time", Action::get("/day"))),
            ));
        let screen = Screen::list_detail("Day", false)
            .at_place("time")
            .with(Slot::new("body", quasi_router::RegionKind::Pane).with(Node::text("the day")));

        let out = webview.screen(&screen);
        let nav = out.find("data-chrome=\"nav\"").expect("drawn");
        let main = out.find("<main").expect("drawn");
        assert!(nav < main, "{out}");
        assert!(out.contains("aria-current=\"page\""), "{out}");
    }

    #[test]
    fn a_nav_alone_still_gets_the_overlay_container() {
        use quasi_router::{Action, Place};

        // Same rule the panel case fixed: a route can answer `Over` with no
        // binding involved, so any app declaring chrome gets a container.
        let chrome = Chrome::new().offering(Place::new("time", "Time", Action::get("/day")));
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);
        assert!(out.contains(OVERLAY_ID), "{out}");
    }

    #[test]
    fn a_binding_carries_the_transport_and_the_overlay_lands_in_the_container() {
        use quasi_router::Action;

        let chrome = Chrome::new().bind("ctrl+k", "Search", Action::get("/palette"));
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);
        assert!(out.contains("hx-get=\"/palette\""), "{out}");
        assert!(out.contains("hx-target=\"#quasi-overlay\""), "{out}");
        assert!(out.contains("from:body"), "{out}");
        assert!(out.contains("aria-label=\"Search\""), "{out}");
        assert!(
            out.contains("<div id=\"quasi-overlay\" data-chrome=\"overlay\"></div>"),
            "{out}"
        );
    }

    #[test]
    fn a_binding_this_renderer_cannot_read_leaves_the_rest_working() {
        use quasi_router::Action;

        let chrome = Chrome::new()
            .bind("dpad-left", "Nope", Action::get("/nope"))
            .bind("ctrl+k", "Search", Action::get("/palette"));
        let mut out = String::new();
        chrome_html(&chrome, &Emit::default(), &Doc::bare(), &mut out);
        assert!(!out.contains("/nope"), "{out}");
        assert!(out.contains("/palette"), "{out}");
    }
}