mindfork 0.21.0

//! Status bar: server status, a generation indicator, key hints — and the
//! token counter where the feed has no border to carry it (spec §11.1.1,
//! §11.3). See spec §11.1.

use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::Paragraph;

use crate::shared::i18n::Locale;
use crate::shared::server::{ServerStatus, ServerStatuses};
use crate::shared::theme::Palette;
use crate::shared::ui;
use crate::shared::wrap;
use crate::widgets::token_counter::TokenCounter;

/// The one hotkey whose description is not fixed: `Esc` means "go back", and
/// where back goes depends on how the chat was reached (see [`EscTarget`]) —
/// except while a turn is running, when it cancels first (see
/// [`esc_hint_key`]). Named so the substitution in [`lines`] isn't a bare
/// string match.
const ESC_KEY: &str = "Esc";

/// The help hotkey — the one hint the corner block sheds last (see
/// [`keep_order`]) and the last-resort row when nothing fits beside the pill
/// ([`lines`]). Named like [`ESC_KEY`] so the lookup isn't a bare string match.
const HELP_KEY: &str = "F1";

/// Keys of the status bar's fixed hotkeys (after the mouse toggle `Ctrl+W`, whose
/// description depends on the mode). "Key" + a description key (localized in [`lines`]).
/// The `Esc` entry carries its **default** description; the live one comes from
/// [`StatusModel::esc_target`].
const HOTKEYS: [(&str, &str); 5] = [
    ("F1", "ui.status.hotkey.help"),
    (ESC_KEY, "ui.status.hotkey.chats"),
    ("Ctrl+N", "ui.status.hotkey.new"),
    ("Ctrl+P", "ui.status.hotkey.settings"),
    ("Ctrl+Q", "ui.status.hotkey.quit"),
];

/// Where `Esc` takes the user from the chat. The status bar is the only place
/// that answers this on screen, so the hint has to move with the key: a chat
/// opened from the message-search results goes **back to them** first, and a bar
/// still saying "chats" would be the old answer in exactly the flow where it
/// surprised someone.
///
/// The chat screen is told which one applies and renders the label; it learns
/// nothing about searching, and the back-stack itself lives in `app/runtime`
/// (FSD: `screens` may not depend on `app`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum EscTarget {
    /// The chat list — the ordinary case.
    #[default]
    ChatList,
    /// The results the chat was opened from.
    SearchResults,
    /// The conversation a `chat://` reference was followed from (spec §11.3).
    PreviousChat,
    /// The tasks screen the transcript or chat was opened from (spec §11.10).
    Tasks,
}

impl EscTarget {
    /// The bundle key of the `Esc` description. `ChatList` deliberately returns
    /// the same key [`HOTKEYS`] carries, so the const stays honest as the default.
    fn hint_key(self) -> &'static str {
        match self {
            EscTarget::ChatList => "ui.status.hotkey.chats",
            EscTarget::SearchResults => "ui.status.hotkey.results",
            EscTarget::PreviousChat => "ui.status.hotkey.back_chat",
            EscTarget::Tasks => "ui.status.hotkey.tasks",
        }
    }
}

/// The `Esc` hint's bundle key, in the key's own order of precedence: while a
/// turn runs `Esc` **cancels it** and goes nowhere
/// (`ChatScreen::handle_plain_key`), and only otherwise does it go back to
/// where [`EscTarget`] points. The bar was the last surface still telling the
/// pre-cancel story mid-turn — the input box's title says "Esc cancel", the
/// `F1` row says both, and `/stop` exists precisely because the key is
/// overloaded — so the two on-screen hints contradicted each other for the
/// length of every turn.
///
/// Generation is **not** a fourth [`EscTarget`]: that enum is derived from the
/// navigation back-stack in `app/runtime`, which knows nothing about turns, and
/// a variant its only producer could never build would be a trap. Both halves
/// are read here instead, off one per-frame [`StatusModel`] — the same snapshot
/// the generation chip and the input box's title are drawn from, so the three
/// cannot disagree. See spec §11.1.
fn esc_hint_key(model: &StatusModel) -> &'static str {
    // A background run's transcript streams under no turn: `Esc` leaves it
    // and the run stays out (`F6` is the stop), so the hint is the navigation
    // one even while the feed says *generating*.
    if model.generating && !model.background_run {
        "ui.status.hotkey.cancel"
    } else {
        model.esc_target.hint_key()
    }
}

/// A state snapshot for the status line — the screen assembles it in one place
/// ([`ChatScreen::status_model`](crate::screens::chat::ChatScreen)), so a new
/// indicator adds a field rather than extending the `render`/`height` signatures.
/// `mouse_scroll` — whether mouse capture for wheel scrolling is on (otherwise
/// native text selection). `background` — a quiet indicator of
/// the running background tasks, already composed into one label by the caller
/// (auto-reflection, note/self-model consolidation, history compaction; `None` —
/// nothing running). See spec §11.1, §11.3.
pub struct StatusModel<'a> {
    pub statuses: &'a ServerStatuses,
    pub generating: bool,
    /// The token counter, when the pill is where it goes: only in a window too
    /// short for the feed's border, whose corner carries it otherwise (spec
    /// §11.1.1, §11.3). `None` — it is not the bar's to draw. A counter with
    /// nothing to count yet is not drawn either.
    pub counter: Option<TokenCounter>,
    pub mouse_scroll: bool,
    pub background: Option<&'a str>,
    /// Speech synthesis is running (`/tts`) — a quiet "speaking" chip. See spec §11.9.
    pub speaking: bool,
    /// Files attached to the chat (`/file attach`) — a quiet chip with their
    /// count and standing token cost; `None` — nothing attached. See
    /// docs/file-attachments.md.
    pub attachments: Option<&'a str>,
    /// Images staged for the **next message** (`/image attach`) — a quiet chip
    /// with their count and token cost; `None` — nothing staged. A second chip
    /// rather than a line in the first: the two costs behave differently
    /// (an attachment is paid every turn, a staged image once, on the next
    /// send), and merging them would claim otherwise. See spec §9.10.
    pub staged_images: Option<&'a str>,
    /// Where `Esc` goes from here — it decides the `Esc` hint's wording
    /// outside a turn; while `generating`, the key cancels instead and the
    /// hint says so ([`esc_hint_key`]).
    pub esc_target: EscTarget,
    /// The open "chat" is a sub-agent transcript, read-only (spec §11.2): a
    /// quiet chip says so, next to the input box's title that says the same.
    pub read_only: bool,
    /// The open transcript is a run out in the **background**, still
    /// streaming (spec §9.3.2): `generating` is true, but there is no turn
    /// for `Esc` to cancel — it goes back, and the bar says so — and `F6`
    /// stops the run, a hint shown only while the key works (spec §11.2).
    pub background_run: bool,
}

/// The speaking-indicator glyph (WGL4, width 1 column — the hotkey grid doesn't "shift").
const SPEAKING_GLYPH: char = '♪';

/// The attached-files glyph. Like `♪` it is WGL4 and one column wide, so it needs
/// no compat-mode replacement (an emoji paperclip would be two columns and would
/// shift the hotkey grid on legacy terminals).
const ATTACH_GLYPH: char = '§';

/// The staged-images glyph. Same constraint as [`ATTACH_GLYPH`]: WGL4 and
/// exactly one column, so it needs no compat-mode replacement and cannot shift
/// the hotkey grid (an emoji camera/picture would be two columns wide). ASCII
/// `#` reads as "a picture" next to `§` "a document" without borrowing either
/// glyph's meaning.
const IMAGE_GLYPH: char = '#';

/// The read-only-transcript glyph. WGL4, one column, like the three above;
/// `≡` reads as "a document" without borrowing a neighbour's meaning.
const TRANSCRIPT_GLYPH: char = '≡';

/// Draws the status line in `area`. The hotkeys sit beside the status pill as
/// a right-aligned corner grid at most [`HINT_ROWS_MAX`] rows deep — a crowded
/// pill sheds hints rather than growing the bar (see [`lines`]); the caller
/// reserves height via [`height`], and `area` is that many rows: the bar is
/// laid out within them, so a one-row area gets a one-row bar, not the top
/// row of a two-row one. See spec §11.1, §11.3.
pub fn render(
    frame: &mut Frame,
    area: Rect,
    model: &StatusModel,
    palette: &Palette,
    loc: &'static Locale,
) {
    let lines = lines_within(
        area.width as usize,
        model,
        palette,
        loc,
        area.height as usize,
    );
    frame.render_widget(Paragraph::new(lines), area);
}

/// How many lines the status bar takes at width `width` within `max_rows` —
/// the caller reserves exactly this height. One at least while a row is
/// allowed at all (the pill's), and never more than allowed: the corner grid
/// is capped at the rows, and the degenerate `F1` row below the pill needs a
/// second one (spec §11.1.1 — the chat gives the bar two rows, then one, then
/// none). Both bounds are [`lines_within`]'s own, so there is no clamp here
/// to keep them a second time.
pub fn height(
    width: usize,
    model: &StatusModel,
    palette: &Palette,
    loc: &'static Locale,
    max_rows: u16,
) -> u16 {
    // At most `max_rows` lines, so the narrowing cast cannot truncate.
    lines_within(width, model, palette, loc, usize::from(max_rows)).len() as u16
}

/// Builds the status bar's lines. On the left of the **top** row — "state"
/// (the status pill: server chips, generation indicator, the quiet chips —
/// and the token counter in a window with no feed border), left-aligned. On the right — hotkeys (starting with the mouse
/// toggle `Ctrl+W`, whose description = the current mode), laid out as a neat
/// right-aligned grid **beside the pill**, at most [`HINT_ROWS_MAX`] rows
/// deep, columns lined up vertically and an incomplete bottom row landing
/// exactly under the columns above.
///
/// The grid never moves below the pill and never grows past that depth: when
/// the pill leaves it too little width, the block **sheds hints** instead
/// ([`trim_to_fit`], lowest [`keep_order`] rank first) — a busy pill costs
/// hints, not rows, so the hints always read as one corner block and the bar
/// never exceeds [`HINT_ROWS_MAX`] rows. Before this rule the bar had a second
/// arrangement — the grid on a full-width line below the pill — and the pill
/// growing every turn (generation chip, token counter) teleported the hints
/// between the two, planting a wall of keycaps right under the indicators
/// (user's decision, 2026-08-30). Every hidden hint is still on the `F1` help
/// list, which is why `F1` sheds last; in the degenerate case where not even
/// it fits beside the pill, it alone takes a row below — the sole remnant of
/// the old layout. See spec §11.1, §11.3.
///
/// `max_rows` is the ceiling the window sets (spec §11.1.1): two in a window
/// with rows to spare, one where the chat has shed its chrome, none below
/// that. Within one row the corner block is one row deep and the `F1` row
/// below the pill does not exist; the pill itself is fitted first, whatever
/// the rows ([`fit_pill`]).
fn lines_within(
    width: usize,
    model: &StatusModel,
    palette: &Palette,
    loc: &'static Locale,
    max_rows: usize,
) -> Vec<Line<'static>> {
    if max_rows == 0 {
        return Vec::new();
    }
    let state = fit_pill(state_chips(model, palette, loc), width);
    let state_w = spans_width(&state);

    let hotkeys = hotkey_list(model, loc);
    // In "scroll" mode, highlight the mouse toggle's description (index 0) with the
    // `accent` color — the same one that highlights markdown headings in the feed.
    let accent_idx = model.mouse_scroll.then_some(0usize);

    let cell_w = ui::hint_cell_widths(&hotkeys);

    let avail = width.saturating_sub(state_w + ui::HINT_GAP);
    let kept = trim_to_fit(&cell_w, avail, model.mouse_scroll, max_rows);
    if !kept.is_empty() {
        let sub: Vec<(&str, &str, bool)> = kept.iter().map(|&i| hotkeys[i]).collect();
        let sub_w: Vec<usize> = kept.iter().map(|&i| cell_w[i]).collect();
        // The accent follows the mouse toggle into the kept sub-list — or is
        // dropped with it (it never is while anything is kept: scroll mode
        // pins the toggle at the top of `keep_order`).
        let accent = accent_idx.and_then(|a| kept.iter().position(|&i| i == a));
        let cols = ui::capped_hint_grid(&sub_w, avail, max_rows).unwrap_or(1);
        return ui::render_hint_grid(
            &ui::HintGrid {
                items: &sub,
                cell_w: &sub_w,
                cols,
                width,
                lead: Some(state),
                accent,
            },
            palette,
        );
    }

    // Degenerate: the pill leaves no corner that could anchor on `F1`. The
    // help entry stays reachable — alone on a row of its own, right-aligned
    // (the sole remnant of the old grid-below-the-pill layout) — where the
    // bar has a second row to put it on.
    debug_assert_eq!(hotkeys[HELP_IDX].0, HELP_KEY);
    let mut out = vec![Line::from(state)];
    if max_rows >= 2 && cell_w[HELP_IDX] <= width {
        out.extend(ui::hotkey_grid(
            palette,
            &hotkeys[HELP_IDX..=HELP_IDX],
            width,
            1,
        ));
    }
    out
}

/// The most rows the chat bar's hint block may take. Two is the tallest block
/// that still reads as a corner legend — the reference look is the 3×2 grid
/// beside a quiet pill; deeper, and it becomes the one-hint-per-line column
/// the bar used to stack beside a busy pill. Past this depth the block sheds
/// hints ([`trim_to_fit`]) rather than growing. The chat gives the bar this
/// many rows while its window has rows to spare (spec §11.1.1).
pub const HINT_ROWS_MAX: u16 = 2;

/// [`HELP_KEY`]'s index in [`hotkey_list`]'s order (right after the prepended
/// mouse toggle). `keep_order_matches_the_hotkey_list` pins the mapping.
const HELP_IDX: usize = 1;

/// The stop key of a background run's open transcript (spec §9.3.2) — the
/// one hint that comes and goes with the state ([`StatusModel::background_run`]).
const STOP_KEY: &str = "F6";

/// [`STOP_KEY`]'s index in [`hotkey_list`]'s order when it is present: after
/// the five fixed hotkeys. `keep_order_matches_the_hotkey_list` pins it.
const STOP_IDX: usize = 6;

/// The order the corner block **keeps** hints when the pill leaves it too
/// little width — later entries shed first. `F1` outlives everything: it opens
/// the full per-screen hotkey list every hidden hint is still on (spec §11.7).
/// `Esc` next — its label is the live one ([`esc_hint_key`]: the running
/// turn's cancel, else where back goes). Then
/// quit, the mouse toggle, settings, new chat. In scroll mode the mouse toggle
/// instead jumps to the front: accent-highlighted, it is the one thing on
/// screen saying why native selection is off — a mode light, not a hint.
/// The stop key of a background run's transcript (`with_stop`) goes right
/// behind `F1`: on that screen it is the one hint that says what the screen
/// is for, and `Esc` there only navigates.
/// Values index [`hotkey_list`]'s order; `keep_order_matches_the_hotkey_list`
/// pins the mapping.
fn keep_order(mouse_pinned: bool, with_stop: bool) -> Vec<usize> {
    let mut order: Vec<usize> = if mouse_pinned {
        vec![0, HELP_IDX, 2, 5, 4, 3]
    } else {
        vec![HELP_IDX, 2, 5, 0, 4, 3]
    };
    if with_stop {
        let after_help = order.iter().position(|&i| i == HELP_IDX).unwrap_or(0) + 1;
        order.insert(after_help, STOP_IDX);
    }
    order
}

/// The hints the corner block shows at `avail` columns: walk [`keep_order`]
/// and keep every hint whose addition still fits a grid of at most `max_rows`
/// rows (one that does not is passed over, so the narrower ones after it
/// still get their chance). Returned in display order; empty when nothing
/// fits. A block that lost `F1` is refused outright — a legend hiding its own
/// door to the full list while lesser hints stay would be an artifact of cell
/// widths, not a priority — and the caller falls back to the `F1`-below row.
/// Within a turn the pill only grows (the generation chip; the token counter,
/// where the pill carries it), so hints shed monotonically — no flicker — and
/// return when the turn's chips leave.
fn trim_to_fit(cell_w: &[usize], avail: usize, mouse_pinned: bool, max_rows: usize) -> Vec<usize> {
    let order = keep_order(mouse_pinned, cell_w.len() > STOP_IDX);
    let kept = ui::keep_hints(cell_w, avail, max_rows, order);
    if !kept.contains(&HELP_IDX) {
        return Vec::new();
    }
    kept
}

/// The "state" cluster on the left of the top row, chip by chip: the server
/// chips, generation, the token counter (where the pill carries it) and the
/// quiet background, speaking and attachment chips. Each chip carries the join drawn before it — the
/// server chips stand two spaces apart, the rest behind a `│` separator — so
/// that [`fit_pill`] can take a prefix of them and get a pill that ends
/// where a chip ends.
///
/// The chat server is always shown (with the disconnect reason — it blocks
/// generation); embeddings and impersonation — separate chips, only when configured
/// (`NotConfigured`, including impersonation in `shared`, → the chip is hidden).
fn state_chips(
    model: &StatusModel,
    palette: &Palette,
    loc: &'static Locale,
) -> Vec<Vec<Span<'static>>> {
    let statuses = model.statuses;
    let sep = || Span::styled("  │  ", Style::new().fg(palette.border));
    let muted = palette.muted_style();

    let mut chips = vec![chat_chip(&statuses.chat, palette, loc)];
    for chip in [
        secondary_chip(loc.t("ui.status.chip.embed"), &statuses.embed, palette),
        secondary_chip(
            loc.t("ui.status.chip.imp"),
            &statuses.impersonation,
            palette,
        ),
    ]
    .into_iter()
    .flatten()
    {
        let mut spaced = vec![Span::raw("  ")]; // gap between chips
        spaced.extend(chip);
        chips.push(spaced);
    }
    let mut behind_sep = |span: Span<'static>| chips.push(vec![sep(), span]);

    if model.generating {
        behind_sep(Span::styled(
            format!(
                "{} {}",
                palette.glyphs().busy,
                loc.t("ui.status.generating")
            ),
            palette.accent_style(),
        ));
    }
    if let Some(counter) = model.counter.and_then(|c| c.span(palette, loc)) {
        behind_sep(counter);
    }
    // A quiet indicator of the running background tasks (composed by the caller) — muted,
    // the `✻` glyph (compat — `*`) width 1 column (the grid layout doesn't "shift").
    if let Some(hint) = model.background {
        behind_sep(Span::styled(
            format!("{} {hint}", palette.glyphs().background),
            muted,
        ));
    }
    // A quiet speaking indicator — in the same muted style. The `♪` note (U+266A)
    // is in WGL4 and width 1 column, so it isn't replaced in compat mode
    // (like the feed's `▌` rails and the `█` scrollbar). See spec §11.9.
    if model.speaking {
        behind_sep(Span::styled(
            format!("{SPEAKING_GLYPH} {}", loc.t("ui.status.speaking")),
            muted,
        ));
    }
    // Attached files (`/file attach`): a quiet chip — they are re-sent on every
    // turn, so their standing cost must be visible without opening anything.
    if let Some(files) = model.attachments {
        behind_sep(Span::styled(format!("{ATTACH_GLYPH} {files}"), muted));
    }
    // Images staged for the next message (`/image attach`): the same quiet
    // style, its own chip — this cost is about to be paid once, by the send the
    // user is composing, and it disappears with it.
    if let Some(images) = model.staged_images {
        behind_sep(Span::styled(format!("{IMAGE_GLYPH} {images}"), muted));
    }
    // A sub-agent transcript is read-only: the chip is the standing reminder,
    // the refusals say it again when a key is pressed.
    if model.read_only {
        behind_sep(Span::styled(
            format!("{TRANSCRIPT_GLYPH} {}", loc.t("ui.status.read_only")),
            muted,
        ));
    }
    chips
}

/// The pill at `width` columns: the longest run of its chips, from the first,
/// that ends inside the row. A chip that would cross the edge is left out with
/// every chip behind it — the bar used to be clipped at the edge with no mark,
/// and the chip that fell off was the token counter, cut mid-number
/// (docs/research/small-terminal.md §2.3). A prefix, not the chips that
/// happen to fit: within a turn the pill only grows, so chips leave one by
/// one and none jumps left. The first chip, the chat server's, is the one
/// exception — cut to the width with the mark a cut carries, so that a row of
/// any width says what the server is doing.
fn fit_pill(chips: Vec<Vec<Span<'static>>>, width: usize) -> Vec<Span<'static>> {
    let mut pill: Vec<Span<'static>> = Vec::new();
    let mut used = 0usize;
    for (i, chip) in chips.into_iter().enumerate() {
        let w = spans_width(&chip);
        if used + w <= width {
            used += w;
            pill.extend(chip);
        } else {
            if i == 0 {
                pill.extend(cut_chip(chip, width));
            }
            break;
        }
    }
    pill
}

/// `chip` cut to `width` columns — its glyph kept, its label truncated with
/// the mark [`wrap::truncate_to_width`] puts on a cut. Also the settings
/// screen's, for its server chip: one way to cut a chip.
pub fn cut_chip(chip: Vec<Span<'static>>, width: usize) -> Vec<Span<'static>> {
    let mut left = width;
    chip.into_iter()
        .filter_map(|span| {
            let (text, w) = wrap::truncate_to_width(&span.content, left);
            left -= w;
            (!text.is_empty()).then(|| Span::styled(text, span.style))
        })
        .collect()
}

/// Hotkeys: the mouse toggle `Ctrl+W` (description = the current mode) + the fixed ones.
/// The third field is the shared grid's "dangerous key" flag — the chat bar has
/// no destructive hint, so it is always `false` here.
fn hotkey_list(
    model: &StatusModel,
    loc: &'static Locale,
) -> Vec<(&'static str, &'static str, bool)> {
    let mouse_desc = if model.mouse_scroll {
        loc.t("ui.status.mouse.scroll")
    } else {
        loc.t("ui.status.mouse.select")
    };
    let mut hotkeys: Vec<(&'static str, &'static str, bool)> = vec![("Ctrl+W", mouse_desc, false)];
    hotkeys.extend(HOTKEYS.iter().map(|(key, default)| {
        // `Esc` is the one hint whose meaning moves with the state; the rest are
        // fixed. Keeping it in the const preserves one ordered list.
        let desc_key = if *key == ESC_KEY {
            esc_hint_key(model)
        } else {
            *default
        };
        (*key, loc.t(desc_key), false)
    }));
    // The one conditional hint: the stop key of the background run whose
    // transcript is open, appended after the fixed list ([`STOP_IDX`]) and
    // only while pressing it does something (spec §11.2).
    if model.background_run {
        hotkeys.push((STOP_KEY, loc.t("ui.status.hotkey.stop_run"), false));
    }
    hotkeys
}

/// The glyph and color of a server's status for the status line's chip. Glyphs are width 1
/// column (no emoji) — the line's layout doesn't "shift" because of them. Ready — `●` in both
/// sets (WGL4-safe); "connecting"/"no connection" in compat mode — `○`/`×`.
fn status_glyph(status: &ServerStatus, palette: &Palette) -> (&'static str, Color) {
    let glyphs = palette.glyphs();
    match status {
        ServerStatus::Ready => ("●", palette.success),
        ServerStatus::Connecting => (glyphs.status_connecting, palette.warning),
        ServerStatus::NotConfigured => (glyphs.status_off, palette.warning),
        ServerStatus::Disconnected(_) => (glyphs.status_off, palette.error),
    }
}

/// Builds a chip: a bold glyph + a label (with a leading space), both in the status color.
fn chip(glyph: &'static str, label: String, color: Color) -> Vec<Span<'static>> {
    vec![
        Span::styled(glyph, Style::new().fg(color).add_modifier(Modifier::BOLD)),
        Span::styled(format!(" {label}"), Style::new().fg(color)),
    ]
}

/// The chat-server chip — always shown. Besides the glyph and label it carries the reason
/// text when the server is unavailable/not configured: it blocks generation, and the
/// user needs to know why (secondary servers omit the reason for compactness).
fn chat_chip(status: &ServerStatus, palette: &Palette, loc: &'static Locale) -> Vec<Span<'static>> {
    let (glyph, color) = status_glyph(status, palette);
    let label = match status {
        ServerStatus::Ready | ServerStatus::Connecting => loc.t("ui.status.chip.chat").to_string(),
        ServerStatus::NotConfigured => loc.t("ui.status.chip.chat_off").to_string(),
        ServerStatus::Disconnected(why) => loc.tf("ui.status.chip.chat_down", &[("why", why)]),
    };
    chip(glyph, label, color)
}

/// A secondary server's chip (embeddings/impersonation): glyph + label, color by status,
/// no reason text (compact). `None` when the server isn't configured
/// (`NotConfigured`) — the chip is hidden, doesn't clutter the line (impersonation in
/// `shared` mode is also `NotConfigured`).
fn secondary_chip(
    label: &str,
    status: &ServerStatus,
    palette: &Palette,
) -> Option<Vec<Span<'static>>> {
    if matches!(status, ServerStatus::NotConfigured) {
        return None;
    }
    let (glyph, color) = status_glyph(status, palette);
    Some(chip(glyph, label.to_string(), color))
}

/// The visible width of a string in terminal columns.
fn str_w(s: &str) -> usize {
    wrap::display_width(&s.chars().collect::<Vec<_>>())
}

/// Total visible width of a set of spans.
fn spans_width(spans: &[Span<'_>]) -> usize {
    spans.iter().map(|s| str_w(&s.content)).sum()
}

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

    /// The bar as the chat lays it out with rows to spare: within
    /// [`HINT_ROWS_MAX`] rows.
    fn lines(
        width: usize,
        model: &StatusModel,
        palette: &Palette,
        loc: &'static Locale,
    ) -> Vec<Line<'static>> {
        lines_within(width, model, palette, loc, usize::from(HINT_ROWS_MAX))
    }

    fn ru() -> &'static Locale {
        crate::shared::i18n::locale(crate::shared::i18n::Lang::Ru)
    }

    /// A status snapshot: chat `chat`, embeddings/impersonation not configured (chips hidden).
    fn only_chat(chat: ServerStatus) -> ServerStatuses {
        ServerStatuses {
            chat,
            embed: ServerStatus::NotConfigured,
            impersonation: ServerStatus::NotConfigured,
        }
    }

    /// A snapshot with a ready chat server (secondaries not configured).
    fn ready() -> ServerStatuses {
        only_chat(ServerStatus::Ready)
    }

    /// A status snapshot for tests (background = `None`).
    fn model<'a>(
        statuses: &'a ServerStatuses,
        generating: bool,
        tokens: u64,
        context: Option<u64>,
        context_exact: bool,
        mouse_scroll: bool,
    ) -> StatusModel<'a> {
        StatusModel {
            statuses,
            generating,
            counter: Some(TokenCounter {
                generating,
                tokens,
                context,
                context_exact,
                ..TokenCounter::default()
            }),
            mouse_scroll,
            background: None,
            speaking: false,
            attachments: None,
            staged_images: None,
            esc_target: EscTarget::default(),
            read_only: false,
            background_run: false,
        }
    }

    /// The whole status-bar text as one string (wide width → one line).
    fn flat(
        statuses: &ServerStatuses,
        generating: bool,
        tokens: u64,
        context: Option<u64>,
        context_exact: bool,
        mouse_scroll: bool,
    ) -> String {
        let m = model(
            statuses,
            generating,
            tokens,
            context,
            context_exact,
            mouse_scroll,
        );
        lines(200, &m, &Palette::default(), ru())
            .iter()
            .flat_map(|l| l.spans.iter())
            .map(|s| s.content.as_ref())
            .collect()
    }

    fn text(statuses: &ServerStatuses, generating: bool) -> String {
        flat(statuses, generating, 0, None, false, false)
    }

    #[test]
    fn shows_chat_state() {
        assert!(text(&ready(), false).contains("чат"));
        assert!(text(&only_chat(ServerStatus::NotConfigured), false).contains("не настроен"));
        assert!(
            text(&only_chat(ServerStatus::Disconnected("boom".into())), false).contains("boom")
        );
    }

    #[test]
    fn localized_for_all_langs() {
        // The status bar (axis B) under every language: the chat chip and the quit hotkey — from
        // that language's bundle; en — Latin script. Also checks there's no panic on different
        // widths of the translated text.
        let statuses = ready();
        let m = model(&statuses, false, 0, None, false, false);
        for &lang in crate::shared::i18n::Lang::ALL {
            let loc = crate::shared::i18n::locale(lang);
            let flat: String = lines(200, &m, &Palette::default(), loc)
                .iter()
                .flat_map(|l| l.spans.iter())
                .map(|s| s.content.as_ref())
                .collect();
            assert!(
                flat.contains(loc.t("ui.status.chip.chat")),
                "{lang:?}: {flat}"
            );
            assert!(
                flat.contains(loc.t("ui.status.hotkey.quit")),
                "{lang:?}: {flat}"
            );
        }
        let en = crate::shared::i18n::locale(crate::shared::i18n::Lang::En);
        assert_eq!(en.t("ui.status.chip.chat"), "chat");
    }

    #[test]
    fn secondary_chips_shown_only_when_configured() {
        // Embeddings and impersonation configured — both chips are visible.
        let all = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::Connecting,
        };
        let t = text(&all, false);
        assert!(
            t.contains("чат") && t.contains("эмб") && t.contains("имп"),
            "{t}"
        );
        // Impersonation in `shared` / embeddings off (NotConfigured) — chips hidden.
        let t = text(&ready(), false);
        assert!(
            t.contains("чат") && !t.contains("эмб") && !t.contains("имп"),
            "{t}"
        );
    }

    #[test]
    fn compat_palette_swaps_chip_and_activity_glyphs() {
        // In compatibility mode: "connecting" — `○`, a disconnect — `×`, generation — `»`,
        // a background task — `*`; readiness stays `●` (WGL4-safe).
        let compat = Palette::default().with_compat(true);
        let flat_compat = |statuses: &ServerStatuses, generating: bool| -> String {
            let m = StatusModel {
                statuses,
                generating,
                counter: None,
                mouse_scroll: false,
                background: Some("рефлексия"),
                speaking: false,
                attachments: None,
                staged_images: None,
                esc_target: EscTarget::default(),
                read_only: false,
                background_run: false,
            };
            lines(200, &m, &compat, ru())
                .iter()
                .flat_map(|l| l.spans.iter())
                .map(|s| s.content.as_ref())
                .collect()
        };
        let t = flat_compat(&only_chat(ServerStatus::Connecting), true);
        assert!(t.contains("○ чат"), "connecting compat glyph: {t}");
        assert!(t.contains("» генерация"), "generation compat glyph: {t}");
        assert!(
            t.contains("* рефлексия"),
            "background-task compat glyph: {t}"
        );
        for banned in ['◐', '⟳', '✻'] {
            assert!(!t.contains(banned), "{banned} left behind: {t}");
        }
        let t = flat_compat(&only_chat(ServerStatus::Disconnected("boom".into())), false);
        assert!(t.contains("× чат"), "disconnect compat glyph: {t}");
        let t = flat_compat(&ready(), false);
        assert!(t.contains("● чат"), "readiness stays ●: {t}");
    }

    #[test]
    fn chip_color_reflects_status() {
        let palette = Palette::default();
        // The glyph's color (first span) by status: ready — success, disconnect — error.
        let glyph_fg = |status: ServerStatus| {
            chat_chip(&status, &palette, ru())
                .first()
                .and_then(|s| s.style.fg)
                .unwrap()
        };
        assert_eq!(glyph_fg(ServerStatus::Ready), palette.success);
        assert_eq!(
            glyph_fg(ServerStatus::Disconnected("x".into())),
            palette.error
        );
        assert_eq!(glyph_fg(ServerStatus::Connecting), palette.warning);
    }

    #[test]
    fn generating_indicator_toggles() {
        assert!(text(&ready(), true).contains("генерация"));
        assert!(!text(&ready(), false).contains("генерация"));
    }

    #[test]
    fn shows_mouse_mode() {
        let mode = |scroll| flat(&ready(), false, 0, None, false, scroll);
        assert!(mode(true).contains("мышь: прокрутка"));
        assert!(mode(false).contains("мышь: выделение"));
    }

    #[test]
    fn scroll_mode_highlights_only_value() {
        let palette = Palette::default();
        let span_fg = |scroll, needle: &str| {
            let statuses = ready();
            let m = model(&statuses, false, 0, None, false, scroll);
            lines(200, &m, &palette, ru())
                .iter()
                .flat_map(|l| l.spans.clone())
                .find(|s| s.content.contains(needle))
                .and_then(|s| s.style.fg)
        };
        // In scroll mode, only the mode value is highlighted (with the `accent` color, as
        // markdown headings are), while the "mouse:" label stays muted — separate spans.
        assert_eq!(span_fg(true, "прокрутка"), Some(palette.accent));
        assert_eq!(span_fg(true, "мышь:"), Some(palette.muted));
        // In selection mode — the whole description is muted.
        assert_eq!(span_fg(false, "мышь: выделение"), Some(palette.muted));
    }

    /// The pill carries the counter it is handed — in a window with no feed
    /// border (spec §11.1.1) — in its own place behind the generation chip,
    /// and nothing of it when the screen hands it none: the feed's corner
    /// carries it then (spec §11.3). How it reads is
    /// `widgets::token_counter`'s.
    #[test]
    fn the_pill_carries_the_counter_only_when_handed_one() {
        let line = |tokens, context, exact| flat(&ready(), true, tokens, context, exact, false);
        // Nothing to count — nothing drawn, though a counter was handed.
        assert!(!line(0, None, false).contains("токены"));
        let t = line(42, Some(1000), false);
        assert!(t.contains("генерация…  │  токены: ~1042"), "{t}");
        assert!(line(42, Some(1000), true).contains("токены: 1042"));
        // Not handed one: the pill has no counter, whatever the turn counted.
        let statuses = ready();
        let mut m = model(&statuses, true, 42, Some(1000), true, false);
        m.counter = None;
        let text: String = lines(200, &m, &Palette::default(), ru())
            .iter()
            .flat_map(|l| l.spans.iter())
            .map(|s| s.content.as_ref())
            .collect();
        assert!(
            !text.contains("токены") && text.contains("генерация"),
            "{text}"
        );
    }

    #[test]
    fn hotkeys_fit_on_one_line_when_wide() {
        let statuses = ready();
        let m = model(&statuses, false, 0, None, false, false);
        let n = lines(200, &m, &Palette::default(), ru()).len();
        assert_eq!(n, 1);
    }

    #[test]
    fn a_narrow_bar_wraps_to_two_rows_and_sheds_the_rest() {
        // At 40 columns the corner beside the chat chip holds four hints as a
        // 2×2 block; the wide mouse toggle and settings shed (both are on the
        // F1 help list) instead of stacking extra rows.
        let statuses = ready();
        let m = model(&statuses, false, 0, None, false, false);
        assert_eq!(height(40, &m, &Palette::default(), ru(), HINT_ROWS_MAX), 2);
        let text = rows_of(40, &m).join("\n");
        for kept in ["F1", "справка", "чаты", "новый", "выход"] {
            assert!(text.contains(kept), "{kept} kept: {text}");
        }
        for shed in ["мышь", "настройки"] {
            assert!(!text.contains(shed), "{shed} shed: {text}");
        }
        // Every hint is back where the line has room (the `flat` width, 200).
        let flat = flat(&ready(), false, 0, None, false, false);
        assert!(flat.contains("Ctrl+W") && flat.contains("мышь: выделение"));
        for (_, desc) in HOTKEYS {
            assert!(flat.contains(ru().t(desc)));
        }
    }

    /// The status line of a busy chat — the state that used to stack the hints
    /// into one tall column: two servers, generation, a token counter with
    /// thoughts, attached files (the screenshot behind this rule).
    fn busy(statuses: &ServerStatuses) -> StatusModel<'_> {
        StatusModel {
            generating: true,
            counter: Some(TokenCounter {
                generating: true,
                tokens: 1218,
                context: Some(36490),
                context_exact: true,
                reasoning: 1218,
                ..TokenCounter::default()
            }),
            attachments: Some("файлы: 2 (~532)"),
            ..model(statuses, false, 0, None, false, false)
        }
    }

    /// Renders the status bar at width `w` and returns the buffer's rows as text.
    fn rows(w: u16) -> Vec<String> {
        let statuses = ready();
        let m = model(&statuses, false, 0, None, false, false);
        rows_of(w, &m)
    }

    /// Renders `m` at width `w` (at its own height) and returns the buffer's rows.
    fn rows_of(w: u16, m: &StatusModel) -> Vec<String> {
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;
        let p = Palette::default();
        let h = height(w as usize, m, &p, ru(), HINT_ROWS_MAX);
        let mut term = Terminal::new(TestBackend::new(w, h)).unwrap();
        term.draw(|f| render(f, f.area(), m, &p, ru())).unwrap();
        let buf = term.backend().buffer().clone();
        (0..buf.area.height)
            .map(|y| {
                (0..buf.area.width)
                    .map(|x| buf[(x, y)].symbol())
                    .collect::<String>()
            })
            .collect()
    }

    #[test]
    fn chips_left_hotkeys_right_on_one_line() {
        // Wide — one line: the status chip is left-aligned, hotkeys — right.
        let r = rows(160);
        assert_eq!(r.len(), 1);
        let line = &r[0];
        assert!(
            line.trim_start().starts_with("●"),
            "chip on the left: {line:?}"
        );
        assert!(
            line.trim_end().ends_with("выход"),
            "the last hotkey is right-aligned: {line:?}"
        );
        // Between the chip and hotkeys — a visible gap (they aren't stuck together).
        assert!(
            line.contains("чат   "),
            "there's a gap after the chip: {line:?}"
        );
    }

    #[test]
    fn wrapped_grid_is_right_aligned_with_pill_on_top_line() {
        // Narrow — hotkeys wrap into a neat grid, right-aligned; the status chip
        // shares the TOP row with the grid, the wrap lands exactly under the column above.
        let r = rows(100);
        assert_eq!(r.len(), 2, "expected a wrap to 2 lines: {r:?}");
        // The status chip — on the top row, on the left.
        assert!(
            r[0].trim_start().starts_with("●"),
            "chip on top, on the left: {:?}",
            r[0]
        );
        // The wrapped hotkey — on the bottom row, right-aligned (the left part is empty).
        assert!(
            r[1].trim_start().starts_with("Ctrl+Q") && r[1].starts_with(" "),
            "the wrap is right-aligned, the left part is empty: {:?}",
            r[1]
        );
        // Columns line up vertically: `Ctrl+Q` (bottom) exactly under `Ctrl+P` (top).
        // Compare position in CHARACTERS (Cyrillic is multibyte → the byte offset isn't
        // the column; here every character is width 1, so character == column).
        let char_col = |line: &str, pat: &str| line.find(pat).map(|b| line[..b].chars().count());
        assert_eq!(
            char_col(&r[1], "Ctrl+Q"),
            char_col(&r[0], "Ctrl+P"),
            "the wrap lands exactly under the column above:\n{:?}\n{:?}",
            r[0],
            r[1]
        );
    }

    #[test]
    fn trim_keeps_the_highest_ranked_hints_that_fit() {
        // The cell widths of the chat's six hotkeys in the ru bundle: one wide
        // cell (the mouse toggle) and five short ones. Synthetic on purpose —
        // the rule is about widths, and shouldn't be re-measured against wording.
        let cells = [24, 12, 10, 14, 18, 14];
        // Room for one row — everything stays, as one row of six.
        assert_eq!(trim_to_fit(&cells, 107, false, 2), vec![0, 1, 2, 3, 4, 5]);
        assert_eq!(ui::capped_hint_grid(&cells, 107, 2), Some(6));
        // The quiet pill's remainder at 120 columns — everything stays, as the
        // reference 3×2 grid.
        assert_eq!(trim_to_fit(&cells, 71, false, 2), vec![0, 1, 2, 3, 4, 5]);
        assert_eq!(ui::capped_hint_grid(&cells, 71, 2), Some(3));
        // The generating pill's remainder — settings and new-chat shed.
        assert_eq!(trim_to_fit(&cells, 54, false, 2), vec![0, 1, 2, 5]);
        // Tighter still — the wide mouse toggle sheds too, and new-chat comes
        // back in its place: a too-wide cell is passed over, not a lock-out.
        assert_eq!(trim_to_fit(&cells, 32, false, 2), vec![1, 2, 3, 5]);
        // Barely a corner: F1 anchors a one-column block, then nothing — a
        // block that cannot hold F1 is refused even when Esc alone would fit.
        assert_eq!(trim_to_fit(&cells, 12, false, 2), vec![1, 2]);
        assert!(trim_to_fit(&cells, 11, false, 2).is_empty());
        // Scroll mode pins the mouse toggle ahead of everything: it stays at a
        // width where it shed above (a one-column block with F1)…
        assert_eq!(trim_to_fit(&cells, 25, true, 2), vec![0, 1]);
        // …and where even it cannot fit, it is passed over like any other.
        assert_eq!(trim_to_fit(&cells, 23, true, 2), vec![1, 2]);
    }

    /// `keep_order` addresses hints by index into `hotkey_list`'s order — this
    /// pins the mapping so a reordering of the list cannot silently reshuffle
    /// the shedding priority (or detach `HELP_IDX` from `F1`).
    #[test]
    fn keep_order_matches_the_hotkey_list() {
        let statuses = ready();
        let m = model(&statuses, false, 0, None, false, false);
        let keys: Vec<&str> = hotkey_list(&m, ru()).iter().map(|(k, _, _)| *k).collect();
        assert_eq!(keys[HELP_IDX], HELP_KEY);
        assert_eq!(
            keys.len(),
            STOP_IDX,
            "the stop key is absent off a background run"
        );
        let named = |order: Vec<usize>| order.into_iter().map(|i| keys[i]).collect::<Vec<_>>();
        assert_eq!(
            named(keep_order(false, false)),
            ["F1", "Esc", "Ctrl+Q", "Ctrl+W", "Ctrl+P", "Ctrl+N"]
        );
        assert_eq!(
            named(keep_order(true, false)),
            ["Ctrl+W", "F1", "Esc", "Ctrl+Q", "Ctrl+P", "Ctrl+N"]
        );
        // On a background run's transcript the stop key joins, right behind
        // `F1` in the shedding order, at the fixed list's tail on screen.
        let mut bg = model(&statuses, true, 0, None, false, false);
        bg.background_run = true;
        let keys: Vec<&str> = hotkey_list(&bg, ru()).iter().map(|(k, _, _)| *k).collect();
        assert_eq!(keys[STOP_IDX], STOP_KEY);
        let named = |order: Vec<usize>| order.into_iter().map(|i| keys[i]).collect::<Vec<_>>();
        assert_eq!(
            named(keep_order(false, true)),
            ["F1", "F6", "Esc", "Ctrl+Q", "Ctrl+W", "Ctrl+P", "Ctrl+N"]
        );
        assert_eq!(
            named(keep_order(true, true)),
            ["Ctrl+W", "F1", "F6", "Esc", "Ctrl+Q", "Ctrl+P", "Ctrl+N"]
        );
    }

    /// On a background run's open transcript the bar tells the truth about
    /// both keys (spec §9.3.2, §11.2): `F6` stops the run and is advertised
    /// only there; `Esc` goes back — never "cancel", though the feed is
    /// streaming — and the hint returns to the plain set when the run ends.
    #[test]
    fn a_background_transcript_advertises_the_stop_key_and_esc_goes_back() {
        let statuses = ready();
        let stop = ru().t("ui.status.hotkey.stop_run");
        let cancel = ru().t("ui.status.hotkey.cancel");
        let chats = ru().t("ui.status.hotkey.chats");

        let mut m = model(&statuses, true, 0, None, false, false);
        m.background_run = true;
        m.read_only = true;
        let text = rows_of(140, &m).join(" ");
        assert!(text.contains("F6") && text.contains(stop), "{text}");
        assert!(!text.contains(cancel), "{text}");
        assert!(text.contains(chats), "{text}");

        // A turn's own chat mid-generation: no stop key, `Esc` cancels.
        let turn = model(&statuses, true, 0, None, false, false);
        let text = rows_of(140, &turn).join(" ");
        assert!(!text.contains("F6"), "{text}");
        assert!(text.contains(cancel), "{text}");

        // The run ended: the transcript is a plain read-only one again.
        let mut ended = model(&statuses, false, 0, None, false, false);
        ended.read_only = true;
        let text = rows_of(140, &ended).join(" ");
        assert!(!text.contains("F6"), "{text}");
    }

    #[test]
    fn a_busy_pill_sheds_hints_but_keeps_the_corner_block() {
        // The state that once stacked six hint rows, then sent the hints onto
        // a full-width row below the pill: at 120 columns the busy pill leaves
        // the corner 32. Now the wide hints shed (mouse toggle, settings) and
        // the rest stay a 2×2 block beside the pill — two rows, and no keycap
        // ever sits under the indicators.
        let statuses = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::NotConfigured,
        };
        let r = rows_of(120, &busy(&statuses));
        assert_eq!(r.len(), 2, "pill plus a two-row corner block: {r:?}");
        assert!(
            r[0].trim_start().starts_with('●') && r[0].contains("токены"),
            "the pill keeps the top row: {:?}",
            r[0]
        );
        // The pill is a **running turn's**, so the `Esc` cell that ends the
        // top row reads "cancel" rather than a navigation target
        // ([`esc_hint_key`]) — the label moves, the corner block does not.
        assert!(
            r[0].contains("F1") && r[0].trim_end().ends_with(ru().t("ui.status.hotkey.cancel")),
            "kept hints share the pill's row: {:?}",
            r[0]
        );
        assert!(
            r[1].starts_with(' ') && r[1].trim_end().ends_with("выход"),
            "the wrapped row is right-aligned: {:?}",
            r[1]
        );
        // Columns line up: the wrap lands exactly under the column above.
        // Compare position in CHARACTERS (Cyrillic is multibyte).
        let char_col = |line: &str, pat: &str| line.find(pat).map(|b| line[..b].chars().count());
        assert_eq!(
            char_col(&r[1], "Ctrl+N"),
            char_col(&r[0], "F1"),
            "\n{:?}\n{:?}",
            r[0],
            r[1]
        );
        let text = r.join("\n");
        assert!(
            !text.contains("мышь") && !text.contains("настройки"),
            "shed hints are hidden, not wrapped: {text}"
        );
    }

    /// The screenshot behind the corner rule: a generating pill of 63 columns
    /// at a 120-column window used to send all six hints onto a full-width row
    /// below — a wall of keycaps starting under the server chips. Now the two
    /// widest hints shed and the block stays beside the pill.
    #[test]
    fn the_generating_pill_keeps_the_hints_in_the_corner() {
        let statuses = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::NotConfigured,
        };
        let m = StatusModel {
            generating: true,
            counter: Some(TokenCounter {
                generating: true,
                tokens: 4732,
                context: Some(22597),
                context_exact: true,
                reasoning: 4732,
                ..TokenCounter::default()
            }),
            ..model(&statuses, false, 0, None, false, false)
        };
        let r = rows_of(120, &m);
        assert_eq!(r.len(), 2, "{r:?}");
        assert!(r[0].contains("токены: 27329 (рассужд. 4732)"), "{:?}", r[0]);
        assert!(
            r[0].trim_end().ends_with("справка"),
            "the mouse toggle and F1 share the pill's row: {:?}",
            r[0]
        );
        let char_col = |line: &str, pat: &str| line.find(pat).map(|b| line[..b].chars().count());
        assert_eq!(
            char_col(&r[1], "Esc"),
            char_col(&r[0], "Ctrl+W"),
            "a right-aligned 2×2 block, nothing under the pill:\n{:?}\n{:?}",
            r[0],
            r[1]
        );
        let text = r.join("\n");
        assert!(
            !text.contains("новый") && !text.contains("настройки"),
            "{text}"
        );
    }

    /// Scroll mode survives shedding: the accent-highlighted mouse toggle is a
    /// mode light, pinned ahead of everything, and keeps its accent inside the
    /// trimmed block.
    #[test]
    fn scroll_mode_pins_the_mouse_toggle_through_trimming() {
        let statuses = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::NotConfigured,
        };
        let mut m = busy(&statuses);
        m.mouse_scroll = true;
        let p = Palette::default();
        let ls = lines(120, &m, &p, ru());
        assert_eq!(ls.len(), 2);
        let accent_span = ls
            .iter()
            .flat_map(|l| l.spans.iter())
            .find(|s| s.content.contains("прокрутка"))
            .expect("the pinned mouse toggle is shown");
        assert_eq!(accent_span.style.fg, Some(p.accent));
        let flat: String = ls
            .iter()
            .flat_map(|l| l.spans.iter())
            .map(|s| s.content.as_ref())
            .collect();
        assert!(flat.contains("F1"), "F1 rides along: {flat}");
        assert!(!flat.contains("настройки"), "sheds still happen: {flat}");
    }

    /// A pill that fills the window leaves no corner that could anchor on
    /// `F1` — the bar falls back to the help entry alone on a row below, the
    /// one hint that must survive every layout.
    #[test]
    fn a_wall_of_pill_leaves_f1_alone_below() {
        let statuses = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::NotConfigured,
        };
        let r = rows_of(96, &busy(&statuses));
        assert_eq!(r.len(), 2, "{r:?}");
        assert!(r[0].contains("файлы"), "the pill keeps its row: {:?}", r[0]);
        let below = r[1].trim();
        assert!(
            below.starts_with("F1") && below.ends_with("справка"),
            "F1 alone: {:?}",
            r[1]
        );
        assert!(r[1].starts_with(' '), "right-aligned: {:?}", r[1]);
    }

    #[test]
    fn the_bar_never_exceeds_two_rows_and_keeps_f1() {
        // The invariant the corner rule buys, stated across widths, languages
        // and states: the bar is never taller than HINT_ROWS_MAX rows however
        // full the pill (before, a busy pill cost up to five extra rows, then
        // a full-width hint row), and the help entry survives at every width
        // that can hold its cell.
        let p = Palette::default();
        let quiet_statuses = ready();
        let quiet = model(&quiet_statuses, false, 0, None, false, false);
        let scroll = model(&quiet_statuses, false, 0, None, false, true);
        let busy_statuses = ServerStatuses {
            chat: ServerStatus::Disconnected("connection refused".into()),
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::Connecting,
        };
        let busy = busy(&busy_statuses);
        for &lang in crate::shared::i18n::Lang::ALL {
            let loc = crate::shared::i18n::locale(lang);
            let f1_cell = 2 + 2 + 1 + str_w(loc.t("ui.status.hotkey.help"));
            for w in 12..=240usize {
                for m in [&quiet, &scroll, &busy] {
                    let ls = lines(w, m, &p, loc);
                    assert!(
                        ls.len() <= usize::from(HINT_ROWS_MAX),
                        "{lang:?} w={w}: {} rows",
                        ls.len()
                    );
                    let flat: String = ls
                        .iter()
                        .flat_map(|l| l.spans.iter())
                        .map(|s| s.content.as_ref())
                        .collect();
                    assert!(
                        w < f1_cell || flat.contains("F1"),
                        "{lang:?} w={w}: F1 missing: {flat}"
                    );
                }
            }
        }
    }

    #[test]
    fn render_does_not_panic() {
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;
        let mut term = Terminal::new(TestBackend::new(60, 1)).unwrap();
        let all = ServerStatuses {
            chat: ServerStatus::Ready,
            embed: ServerStatus::Ready,
            impersonation: ServerStatus::Connecting,
        };
        let m = StatusModel {
            statuses: &all,
            generating: true,
            counter: Some(TokenCounter {
                generating: true,
                tokens: 123,
                context: Some(456),
                context_exact: true,
                ..TokenCounter::default()
            }),
            mouse_scroll: true,
            background: Some("рефлексия"),
            speaking: true,
            attachments: Some("файлы: 2 (~3.1k)"),
            staged_images: Some("изображения: 1 (~1.2k)"),
            esc_target: EscTarget::SearchResults,
            read_only: false,
            background_run: false,
        };
        term.draw(|f| render(f, f.area(), &m, &Palette::default(), ru()))
            .unwrap();
    }

    /// The staged-images chip is a second, independent one — a file attachment
    /// and an image staged for the next message are different costs and must not
    /// share a slot. Its glyph stays **one column** wide, or the right-aligned
    /// hotkey grid shifts on the terminals that measure it differently
    /// (docs/lessons.md §5).
    #[test]
    fn staged_images_chip_is_separate_and_one_column() {
        let statuses = ready();
        let text = |files, images| {
            let mut m = model(&statuses, false, 0, None, false, false);
            m.attachments = files;
            m.staged_images = images;
            lines(200, &m, &Palette::default(), ru())
                .iter()
                .flat_map(|l| l.spans.iter())
                .map(|s| s.content.as_ref())
                .collect::<String>()
        };
        // Nothing staged — no image chip at all.
        let empty = text(None, None);
        assert!(!empty.contains(IMAGE_GLYPH), "{empty}");
        // Staged images get their own chip and do not displace the files one.
        let both = text(Some("файлы: 2 (~3.1k)"), Some("изображения: 1 (~1.2k)"));
        assert!(both.contains("§ файлы: 2"), "{both}");
        assert!(both.contains("# изображения: 1"), "{both}");
        // And images alone show without any files attached.
        let alone = text(None, Some("изображения: 1 (~1.2k)"));
        assert!(alone.contains("# изображения: 1"), "{alone}");
        assert!(!alone.contains(ATTACH_GLYPH), "{alone}");
        assert_eq!(str_w(&IMAGE_GLYPH.to_string()), 1, "one column");
    }

    /// `Esc` means "go back", and the bar is the only place on screen that says
    /// where — so the hint has to follow the key rather than always claiming the
    /// chat list.
    #[test]
    fn esc_hint_follows_where_back_goes() {
        let statuses = ready();
        let chats = ru().t("ui.status.hotkey.chats");
        let results = ru().t("ui.status.hotkey.results");
        assert_ne!(chats, results, "the two labels must be distinguishable");

        let text = |target| {
            let mut m = model(&statuses, false, 0, None, false, false);
            m.esc_target = target;
            lines(200, &m, &Palette::default(), ru())
                .iter()
                .flat_map(|l| l.spans.iter())
                .map(|s| s.content.as_ref())
                .collect::<String>()
        };

        let ordinary = text(EscTarget::ChatList);
        assert!(ordinary.contains(chats), "{ordinary}");
        assert!(!ordinary.contains(results), "{ordinary}");

        let from_results = text(EscTarget::SearchResults);
        assert!(from_results.contains(results), "{from_results}");
        assert!(!from_results.contains(chats), "{from_results}");
    }

    /// Mid-turn `Esc` goes nowhere: it cancels the generation first
    /// (`ChatScreen::handle_plain_key`), which is why `/stop` and `/chats`
    /// exist as its two explicit halves. The bar was the last surface still
    /// telling the pre-cancel story — for the length of every turn it claimed
    /// "chats" a row under an input box titled "Esc cancel" — so the running
    /// turn now outranks the navigation target, and hands it straight back
    /// when the turn ends.
    #[test]
    fn esc_hint_says_cancel_while_a_turn_runs() {
        let statuses = ready();
        let cancel = ru().t("ui.status.hotkey.cancel");
        let text = |generating, target| {
            let mut m = model(&statuses, generating, 0, None, false, false);
            m.esc_target = target;
            rows_of(120, &m).join(" ")
        };

        for target in [
            EscTarget::ChatList,
            EscTarget::SearchResults,
            EscTarget::PreviousChat,
        ] {
            let goes_to = ru().t(target.hint_key());
            // The turn's meaning wins over every navigation target...
            let mid_turn = text(true, target);
            assert!(mid_turn.contains(cancel), "{target:?}: {mid_turn}");
            assert!(
                !mid_turn.contains(goes_to),
                "{target:?}: the navigation label outlived the turn: {mid_turn}"
            );
            // ...and is not sticky: the target is back the moment it ends.
            let idle = text(false, target);
            assert!(idle.contains(goes_to), "{target:?}: {idle}");
            assert!(!idle.contains(cancel), "{target:?}: {idle}");
        }

        // One word for one key across the two surfaces that answer for it: the
        // input box's title spells the whole hint out, the bar's cell carries
        // the label alone.
        assert!(
            ru().t("ui.chat.input.generating").contains(cancel),
            "the bar and the input box must not use two words for one key"
        );
    }

    /// The pill fitted to the row (spec §11.1): a row too narrow for every
    /// chip ends where a chip ends — the chips past the edge are left out
    /// from the tail, whole — and the first chip, the chat server's, is cut
    /// with a mark rather than left out, so a row of any width says what the
    /// server is doing. The bar used to be clipped at the edge with no mark,
    /// and the counter was cut mid-number (docs/research/small-terminal.md
    /// §2.3).
    #[test]
    fn a_pill_wider_than_the_row_sheds_whole_chips_from_its_tail() {
        let statuses = ready();
        let m = StatusModel {
            speaking: true,
            ..busy(&statuses)
        };
        let p = Palette::default();
        let text = |width: usize| -> String {
            let lines = lines_within(width, &m, &p, ru(), 1);
            assert_eq!(lines.len(), 1);
            let row: String = lines[0].spans.iter().map(|s| s.content.as_ref()).collect();
            assert!(str_w(&row) <= width, "{width}: {row:?} runs past the edge");
            row
        };
        let whole = text(200);
        let chips = ["● чат", "генерация", "токены", "озвучка", "файлы"];
        assert!(
            chips.iter().all(|c| whole.contains(c)),
            "the premise: {whole}"
        );
        // Wide enough for the pill and the hints; then for the pill alone.
        assert!(whole.contains("F1"));
        let pill_w = spans_width(&fit_pill(state_chips(&m, &p, ru()), 200));
        let alone = text(pill_w);
        assert!(
            chips.iter().all(|c| alone.contains(c)) && !alone.contains("F1"),
            "{alone}"
        );
        // One column short: the last chip goes, whole — and the room it
        // leaves is a corner again, which `F1` takes.
        let short = text(pill_w - 1);
        assert!(
            !short.contains("файлы") && short.contains("озвучка"),
            "{short}"
        );
        assert!(short.contains("F1"), "{short}");
        // Narrower still: chips leave from the tail one by one, never from
        // the middle, and the counter is whole or gone.
        let mut left = pill_w - 1;
        let mut seen = 5usize;
        while left > 0 {
            let row = text(left);
            let present = chips.iter().filter(|c| row.contains(*c)).count();
            assert!(present <= seen, "{left}: a chip came back: {row}");
            assert_eq!(
                chips
                    .iter()
                    .take(present)
                    .filter(|c| row.contains(*c))
                    .count(),
                present,
                "{left}: a chip left from the middle: {row}"
            );
            if row.contains("токены") {
                assert!(row.contains("37708"), "{left}: the counter whole: {row}");
            }
            seen = present;
            left -= 1;
        }
        // The chat chip alone, cut to the width with the mark.
        let cut = text(4);
        assert!(cut.starts_with("● ч") && cut.ends_with('…'), "{cut:?}");
        assert_eq!(str_w(&cut), 4);
        assert_eq!(text(0), "");
    }

    /// The rows the bar is given are a ceiling (spec §11.1.1): within one
    /// row the corner block is one row deep and sheds to it, the `F1` row
    /// below the pill does not exist, and `height` never exceeds the ceiling
    /// — zero rows are zero rows.
    #[test]
    fn the_bar_lays_itself_out_within_the_rows_it_is_given() {
        let statuses = ready();
        let quiet = model(&statuses, false, 0, None, false, false);
        let p = Palette::default();
        let flat = |lines: Vec<Line<'static>>| -> Vec<String> {
            lines
                .iter()
                .map(|l| l.spans.iter().map(|s| s.content.as_ref()).collect())
                .collect()
        };
        // At 40 columns the quiet pill's hints need two rows.
        assert_eq!(height(40, &quiet, &p, ru(), HINT_ROWS_MAX), 2);
        assert_eq!(height(40, &quiet, &p, ru(), 1), 1);
        assert_eq!(height(40, &quiet, &p, ru(), 0), 0);
        let one = flat(lines_within(40, &quiet, &p, ru(), 1));
        assert_eq!(one.len(), 1);
        assert!(
            one[0].contains("F1") && one[0].starts_with("● чат"),
            "{one:?}"
        );
        let two = flat(lines_within(40, &quiet, &p, ru(), 2));
        assert_eq!(two.len(), 2);
        assert!(
            two.iter().flat_map(|r| r.matches("  ")).count() >= one[0].matches("  ").count(),
            "one row holds no more than two did"
        );

        // A busy pill leaves no corner for `F1`: within two rows it takes a
        // row below the pill, within one it is not shown.
        let m = busy(&statuses);
        let tight = spans_width(&fit_pill(state_chips(&m, &p, ru()), 200)) + 2;
        let below = flat(lines_within(tight, &m, &p, ru(), 2));
        assert_eq!(below.len(), 2, "{below:?}");
        assert!(below[1].contains("F1"), "{below:?}");
        let capped = flat(lines_within(tight, &m, &p, ru(), 1));
        assert_eq!(capped.len(), 1);
        assert!(
            !capped[0].contains("F1") && capped[0].contains("файлы"),
            "{capped:?}"
        );
        assert!(lines_within(tight, &m, &p, ru(), 0).is_empty());

        // `render` lays the bar out within its area: a one-row area gets the
        // one-row bar, not the top row of a two-row one.
        use ratatui::Terminal;
        use ratatui::backend::TestBackend;
        let mut term = Terminal::new(TestBackend::new(40, 1)).unwrap();
        term.draw(|f| render(f, f.area(), &quiet, &p, ru()))
            .unwrap();
        let row = crate::shared::ui::tests::buffer_rows(term.backend().buffer()).remove(0);
        assert_eq!(row, one[0]);
    }
}