lernie 0.1.111

//! **The login pane**: the sign-in catalog — what this workspace can sign in
//! to, signed in or not (`catalog`, REMOTE §9.27) — and the act that signs it
//! in (yog's `docs/REMOTE.md` §8.3; PROTOCOL 13). It lists the catalog and
//! never the routing table (`providers`): brazen bl-6feb severed the two, and
//! the table omits exactly the unsigned presets a sign-in exists for.
//!
//! # The act is the SERVER'S and this pane only asks for it
//!
//! `bz --login` runs on the server, inside the named workspace's directory, so the
//! credential lands where the agents that read it run and **nothing
//! credential-shaped crosses this wire** (REMOTE §8.3). This crate spawns no
//! sign-in, holds no run and has no `exec` at all. What it does is post one
//! gesture and paint the lines that come back — which is the whole of why the
//! surface is portable.
//!
//! **Closing the pane terminates nothing.** The run is server RAM, one per
//! workspace × provider, replaced by the operator's own next sign-in and swept
//! at an hour. This side gets that for free and must not re-implement it.
//!
//! # Which sphere the sign-in is for, said in the surface
//!
//! The workspace's name and the channel it came down, and — for a workspace held
//! elsewhere — that it is held elsewhere, off the roster's own client-side
//! channel stamp (`crate::ui::Channel`). **Never a host address**: two entries
//! naming one listener are still two trust relationships, and an address in
//! this sentence would be this end telling the operator where a credential is
//! going to land.
//!
//! # The loopback remedy is stated, never built
//!
//! A row whose flow needs a browser at the SERVER's own loopback can only be
//! completed from a browser on that box, or through a port-forward the operator
//! sets up — *an operator act on boxes the operator administers*, and REMOTE
//! §8.3 rules it is stated as a remedy and never made a channel feature.
//!
//! **It is said for every row on a workspace held elsewhere, not for the browser-only
//! ones**, and that is a limit rather than a choice: the `device` column is on
//! yog's own provider row and not on the view that crosses the wire
//! (`crate::reply::providers`), so this seat cannot tell the two apart. A
//! stated remedy that is sometimes unnecessary beats a silence that is
//! sometimes wrong.
//!
//! # One control fires two ops, because following the run is part of starting it
//!
//! `sign in to this row` carries `act:login act:login-tail`. The act starts the
//! run and the pane's `following` is what stands the held lane up, so a seat
//! that tagged only the act would be claiming `login-tail` is reachable
//! nowhere. It is the start control's shape exactly (§4.16).
//!
//! # The run-by-hand fallback is the server's sentence, with one of ours
//!
//! `fallback` is composed by the end that knows the workspace and arrives only on a
//! non-zero exit. The original surface spelled a local workspace's fallback as an
//! `exec` on this box and an entry's as something else; both are the same case
//! now — **an act the operator runs on the box that HOLDS the workspace** — so what
//! this pane adds is one sentence saying so, naming the channel and no address.

use crate::reply::providers::ProviderRow;
use crate::ui::{Model, theme};

/// The followed run's own half of the pane — its lines, its exit and the
/// command to run by hand.
pub mod run;

/// **The word typed after the slash** that opens it (`crate::ui::slash`).
pub const WORD: &str = "login";
/// The pane's own heading.
pub const HEADING: &str = "sign in";
/// What it says for a workspace nobody has been answered about yet.
pub const NOT_ANSWERED: &str = "waiting to hear what this workspace can sign in to";
/// What it says for a workspace that answered and can sign in to nothing. A
/// fact about the workspace, and the one empty state here that is not a wait:
/// the catalog is every row carrying a sign-in flow, so an empty one means no
/// such row is declared — never that a credential is missing.
pub const NO_PROVIDERS: &str =
    "no provider here can sign in — /config brazen declares an oauth row";
/// The word on the control that starts a sign-in on a row.
pub const SIGN_IN: &str = "sign in to this provider";
/// What the sign-in does.
pub const SIGN_IN_HELP: &str =
    "starts this provider's sign-in on the server; its progress stands below";
/// The word on the control that asks a row what it offers.
pub const OFFERS: &str = "what it offers…";
/// What `what it offers…` does.
pub const OFFERS_HELP: &str = "asks this provider which models it offers, listed below";
/// What it says under a row that was asked and has not answered.
pub const NOT_OFFERED: &str = "waiting to hear what this provider offers";
/// What it says for a row that answered and offers nothing.
pub const OFFERS_NOTHING: &str = "this provider offers no model";
/// The sentence that says where the sign-in is actually happening.
pub const ELSEWHERE: &str = "this workspace lives on another box, and the sign-in \
                             runs there — the credential is kept there, not \
                             on this one";
/// The §8.3 remedy for a row whose flow wants a browser at the server's own
/// loopback, said wherever the server is not this box.
pub const LOOPBACK: &str = "if the sign-in opens a web page, that page expects \
                            a browser on the server's box: finish it there, or \
                            forward the port by hand";

/// 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.login.is_none() {
        return false;
    }
    crate::ui::overlay::name(ui, HEADING);
    if let Some(aim) = model.aim.clone() {
        ui.label(format!("on {} — {}", aim.address, aim.channel));
    }
    // **Both sentences hang off one fact and are said once**, above the rows
    // rather than on each: where the server is, is a property of the workspace.
    if model.elsewhere() {
        ui.colored_label(theme::tone_ink(&crate::reply::convs::Tone::Weak), ELSEWHERE);
        ui.colored_label(theme::tone_ink(&crate::reply::convs::Tone::Weak), LOOPBACK);
    }
    match model.catalog.clone() {
        None => {
            ui.label(NOT_ANSWERED);
        }
        Some(rows) if rows.is_empty() => {
            ui.label(NO_PROVIDERS);
        }
        // The list scrolls and the heading above it does not — the shape every
        // list in this window keeps (bl-e5d2).
        Some(rows) => {
            egui::ScrollArea::vertical()
                .id_salt(HEADING)
                .auto_shrink(false)
                .show(ui, |ui| {
                    for row in &rows {
                        provider(ui, model, row);
                    }
                });
        }
    }
    true
}

/// One provider row: what it is, what the server knows about its credential,
/// and the two controls on it.
fn provider(ui: &mut egui::Ui, model: &mut Model, row: &ProviderRow) {
    ui.separator();
    ui.label(row.name.clone());
    let weak = theme::tone_ink(&crate::reply::convs::Tone::Weak);
    ui.colored_label(weak, row.fact.clone());
    if let Some(takes) = row.takes() {
        ui.colored_label(weak, takes);
    }
    // **A blocked row states the server's own reason and offers no sign-in.**
    // A control that fired an act the far end has already said it will refuse
    // is a control that only looks actionable, which is the one thing every
    // pane in this window is written not to be.
    if let Some(why) = &row.blocked {
        ui.colored_label(theme::NOTICE, why.clone());
    }
    // **Every row wraps**, because this pane stands in the central panel and
    // the central panel is what the two side panels leave (bl-dc07).
    ui.horizontal_wrapped(|ui| {
        let start = theme::paint::button(ui, SIGN_IN, row.signable(), SIGN_IN_HELP);
        // **Two ops on one control** (DESIGN §4.16): the click starts the run,
        // and following it is what opens this seat's held lane on
        // `login-tail` (`crate::offframe::signin`). It is the start control's
        // own shape — `prepare` then `prompt` — and the lane, like the tail's,
        // has no control of its own because nothing but this act can make one
        // exist.
        crate::ui::act::tag(
            &start,
            &[crate::verbs::LOGIN.word, crate::verbs::LOGIN_TAIL.word],
        );
        if start.clicked() {
            model.post_signin(&row.name);
        }
        let offers = theme::paint::button(ui, OFFERS, true, OFFERS_HELP);
        crate::ui::act::tag(&offers, &[crate::verbs::MODELS.word]);
        if offers.clicked() {
            model.post_offering(&row.name);
        }
    });
    offering(ui, model, &row.name);
    run::render(ui, model, &row.name);
}

/// What this row offers, under the row that asked — and only under it, which is
/// what the pane's `asking` is for: the reply carries no provider name, so the
/// question is the only thing that can say which row it answers.
fn offering(ui: &mut egui::Ui, model: &Model, name: &str) {
    if model.login.as_ref().and_then(|pane| pane.asking.as_deref()) != Some(name) {
        return;
    }
    match model.offered.as_deref() {
        None => {
            ui.label(NOT_OFFERED);
        }
        Some([]) => {
            ui.label(OFFERS_NOTHING);
        }
        Some(ids) => {
            ui.label(ids.join("  "));
        }
    }
}

#[cfg(test)]
mod tests;