lernie 0.1.104

//! **The decision queue**: everything waiting on the operator, across every
//! workspace this box can reach (bl-f0ef; yog's `docs/REMOTE.md` §6, §9.11).
//!
//! # The fourth covering pane, and the first that is about no focus
//!
//! `crate::ui::tuning` is about the aimed wall and `crate::ui::records` about
//! the selected conversation, so both open on a subject and close when it
//! moves. This one has no subject to move: `attention` names no workspace, so
//! the read fans over every channel and the pane is the union. That is why its
//! control hangs off the **roster** — the one pane that is already the union
//! across channels — and why it is offered with nothing aimed at and nothing
//! selected, which is the seat most likely to be asking the question.
//!
//! # The flag is why this exists
//!
//! A flag is a second party asking the operator to look at one conversation, in
//! their own words (REMOTE §9.11). Until this pane the seat carried the field
//! and painted it nowhere, so the one place the ask could go was the one place
//! it went to die. It leads the row's detail for that reason, above the failure
//! and the parked invocation: it is the only line on a row that somebody
//! *wrote* rather than something the engine observed.
//!
//! # One control answers a row and one leaves the pane for it
//!
//! [`SEEN`] crosses the boundary and carries its `act:` token; so does each
//! verdict on a row that is holding a call; [`GO`] aims and selects, which is
//! a view and out of the parity contract (PARITY §2). Both stand down on a row
//! this seat cannot address, and the row says why in the roster's own words —
//! `crate::ui::model::queue::Model::wall` is the one place that resolution is
//! asked, so this pane holds no opinion about how a wall is addressed. **The
//! acts are `crate::ui::ask::choices`, read and spent here as there** (bl-da16):
//! one list, so the reaches a held row permits are decided once.
//!
//! # What is painted is words, computed beside the paint
//!
//! Every line comes off a pure function of the row, so the suite reads the
//! sentence rather than the layout — `crate::ui::records`' own rule. The
//! signals ride verbatim (`crate::reply` rung 3): a word this build has never
//! seen paints as itself. The state is the switcher's glyph (bl-6e59), which
//! on this pane is always the asking `?`.

use crate::reply::queue::QueueRow;
use crate::ui::{Channel, Model, theme};

/// **The word typed after the slash** that opens it (`crate::ui::slash`).
pub const WORD: &str = "attention";
/// The pane's own heading.
pub const HEADING: &str = "waiting on you";
/// What it says before any channel has answered.
pub const NOT_ANSWERED: &str = "waiting to hear what is asking for you";
/// What it says once they have, and nothing is. A fact about the world, and
/// the one empty state here that is not a wait.
pub const NOTHING: &str = "nothing is waiting on you — a conversation that asks will appear here";
/// The word on the control that answers a row's place in the queue.
pub const SEEN: &str = "seen";
/// The word on the control that leaves the pane for the conversation.
pub const GO: &str = "go to it";

/// **The line the two wider rows stand under** — what makes them wider is that
/// they settle the held call's whole CLASS, the same tool at the same reach,
/// rather than the one invocation. It reads as a continuation of the row above
/// it, which is what the leading ellipsis is for.
pub const WIDER: &str = "…and every call like it:";

/// **One wider seat's whole label**, which carries its own reach — the
/// receipt's own sentence (`crate::ui::model::Notice::answered`), so what an
/// operator pressed and what comes back read the same.
pub fn wider(verdict: &str, scope: &str) -> String {
    format!("{verdict} for this {scope}")
}

/// Paint the pane and take the clicks on it. Answers whether there was one to
/// paint, so the shell knows whether the conversation still stands.
pub fn render(ui: &mut egui::Ui, model: &mut Model) -> bool {
    if !model.showing(crate::ui::Listing::Queue) {
        return false;
    }
    // **The heading, then one line carrying the way out** (`docs/STYLE.md` §5,
    // *a covering pane*). This pane is the one that has no subject — the union
    // over every channel is what it is about — so the line under the heading
    // carries the close alone, at the end where the other panes' is.
    crate::ui::overlay::name(ui, HEADING);
    ui.add_space(theme::space::S);
    if model.waiting.is_empty() {
        theme::paint::empty(ui, NOT_ANSWERED);
        return true;
    }
    // **One section an ENGINE, each row once** (bl-52d2): two channels that
    // dial one address each answer its whole queue, and painted a section a
    // channel the same conversation stood twice (`Model::sections`).
    let sections = model.sections();
    if sections.iter().all(|section| section.rows.is_empty()) {
        theme::paint::empty(ui, NOTHING);
        return true;
    }
    // One scroll for every section, and the heading above it fixed — the shape
    // every pane here keeps, for the reason the tuning pane states: a pane cut
    // off mid-row says nothing about having been cut.
    egui::ScrollArea::vertical()
        .id_salt(HEADING)
        .auto_shrink(false)
        .show(ui, |ui| {
            for section in &sections {
                // **A section that answered nothing is silent, not a sentence.**
                // The union is the subject here; an engine holding nothing
                // waiting is a fact the roster already carries per wall, and a
                // header over a blank for every quiet channel would bury the
                // rows this pane exists for.
                if section.rows.is_empty() {
                    continue;
                }
                ui.add_space(theme::space::S);
                ui.colored_label(theme::INK_WEAK, section.header.clone());
                for (channel, row) in &section.rows {
                    waiting_row(ui, model, channel, row);
                }
            }
        });
    true
}

/// One row: the headline, why it is asking, and what can be done about it.
fn waiting_row(ui: &mut egui::Ui, model: &mut Model, channel: &Channel, row: &QueueRow) {
    // **Every row here wears the attention rule**, and it is the one pane
    // where that is a tautology rather than a reading: a row is on this pane
    // because it is asking for the operator (`docs/STYLE.md` §2, *the eye
    // lands on green*). Never chosen — this pane selects nothing, and the
    // brand would say the operator is standing on a row they are not.
    //
    // **And it leads with the switcher's glyph** (bl-6e59): one idiom for a
    // conversation's row wherever it stands — `?` in the attention accent,
    // since every row here is asking — rather than a bracketed state word.
    let (mark, ink) = mark(row);
    theme::paint::marked(
        ui,
        (&mark, ink),
        &headline(row),
        theme::INK,
        Some(theme::accent(theme::State::Attention)),
        false,
        0.0,
    );
    // The flag first — it is the only line somebody wrote. The failure is the
    // one line that will not mend itself, so it alone is said in the error
    // accent; the flag and the parked call are notes.
    if let Some(said) = flagged(row) {
        ui.colored_label(theme::accent(theme::State::Annotation), said);
    }
    if let Some(said) = row.failure.clone() {
        ui.colored_label(theme::accent(theme::State::Error), said);
    }
    if let Some(said) = parked(row) {
        ui.colored_label(theme::accent(theme::State::Annotation), said);
    }
    if let Some(said) = signalled(row) {
        ui.colored_label(theme::INK_WEAK, said);
    }
    if !row.preview.is_empty() {
        ui.colored_label(theme::INK_WEAK, row.preview.clone());
    }
    acts(ui, model, channel, row);
}

/// The row's controls, or the sentence that stands where they would be.
fn acts(ui: &mut egui::Ui, model: &mut Model, channel: &Channel, row: &QueueRow) {
    if model.wall(channel, &row.workspace).is_none() {
        ui.colored_label(
            theme::accent(theme::State::Annotation),
            crate::ui::roster::NO_NAME_HERE,
        );
        return;
    }
    let offered = crate::ui::ask::choices(row);
    let mut taken = None;
    let mut seat = |ui: &mut egui::Ui, choice: &crate::ui::ask::Choice| {
        let seat = ui.button(choice.word());
        crate::ui::act::tag(&seat, &[choice.op()]);
        if seat.clicked() {
            taken = Some(*choice);
        }
    };
    // **The acts band stands in from the row it answers**, so a column of
    // rows reads as rows and the controls under one read as its own.
    ui.horizontal_wrapped(|ui| {
        ui.add_space(theme::space::L);
        // **The verdicts are offered only on a row that is holding one**
        // (bl-bce2): `answer` is scoped to the exact call parked at the far
        // end, so a control on a row with nothing parked would fire a gesture
        // the engine refuses by name — and this pane is the one place that
        // already says what is parked (`parked`). `choices` holds that rule.
        for choice in offered.iter().filter(|choice| !choice.wider()) {
            seat(ui, choice);
        }
        // **No `act:` token**: aiming and selecting cross no wire, so this is a
        // view (PARITY §2) and tagging it would put a widget in a ledger whose
        // unit is an op.
        if ui.button(GO).clicked() {
            model.go_to(channel, row);
        }
    });
    // **The wider reaches, each seat saying its own reach** (PROTOCOL 18,
    // yog bl-94a5) — the ones the held row permits (bl-da16). An answer with
    // no scope settles one call, so an operator holding a conversation
    // answered the same question for every call of a kind they had already
    // decided about; these are how that stops.
    //
    // **Written out per scope rather than picked from a selector**, which is
    // the whole of why there is no state here: a sticky picker makes *wider*
    // something an operator can arrive at by accident, on the next row and
    // without touching it, and the wire refuses a default for that exact
    // reason. A seat that says what it does the moment it is read cannot be
    // stale — which is also why the reach is in the LABEL and not in a heading
    // above it, since a heading is not what a screen reader reads out with the
    // button.
    if offered.iter().any(|choice| choice.wider()) {
        ui.colored_label(theme::tone_ink(&crate::reply::convs::Tone::Weak), WIDER);
        ui.horizontal_wrapped(|ui| {
            for choice in offered.iter().filter(|choice| choice.wider()) {
                seat(ui, choice);
            }
        });
    }
    if let Some(choice) = taken {
        crate::ui::ask::answer(model, channel, row, choice);
    }
}

/// **The one line a row always gets** after its glyph: what it is called,
/// where it is, and how long it has waited.
///
/// The workspace is on it because this pane is the one place in the window
/// where two rows may be on two different walls, so a label alone would not
/// say which conversation an operator is looking at.
pub fn headline(row: &QueueRow) -> String {
    let mut said = vec![format!(
        "{}  on {}  {}",
        row.display,
        row.workspace,
        crate::ui::convs::age(row.age_secs)
    )];
    if row.pending > 0 {
        said.push(format!("{} under it", row.pending));
    }
    said.join("  ")
}

/// **The row's glyph and its ink** — the switcher's own
/// (`crate::ui::convs::glyph`), asking because the row is on this pane.
pub fn mark(row: &QueueRow) -> (String, egui::Color32) {
    crate::ui::convs::glyph(&row.state, row.uncertain, true)
}

/// **The raised flag, in the raiser's own words** — the line this pane was
/// built for, or none where nobody raised one.
pub fn flagged(row: &QueueRow) -> Option<String> {
    let flag = row.flag.as_ref()?;
    Some(format!("flagged {} — {}", flag.at, flag.reason))
}

/// The invocation parked at the capability boundary, or none.
///
/// It is painted and not actionable: the control that releases or declines one
/// is `answer`, which belongs to the tool-host pane this seat does not have
/// (`parity.toml`, bl-e53c). Saying what is parked is worth more than saying
/// nothing while that pane is unbuilt.
pub fn parked(row: &QueueRow) -> Option<String> {
    let held = row.held.as_ref()?;
    Some(format!(
        "waiting for your approval: {} — {}",
        held.tool, held.reason
    ))
}

/// Why it is asking: the engine's own sentence (`says`, bl-5507), the raw
/// signal words only where it wrote none, or none where it named nothing —
/// [`QueueRow::why`] makes the choice.
pub fn signalled(row: &QueueRow) -> Option<String> {
    row.why("  ")
}

#[cfg(test)]
mod tests;