paperboy 0.5.4

//! GUI node-configure **wizards** — the friendly, form-based editors behind a
//! double-click on a report block, the direct analogue of the terminal UI's
//! `Overlay::ReportNode*` forms in [`crate::tui::report_nodes`]. Rather than
//! hand-editing a `REPORT REQUEST … SHOW(…) HIDE(…)` line or a
//! `FOR … IN ENVS BASELINE(…), COMPARISON(…)` clause, the user picks the request
//! name, ticks which fields to show, chooses baseline/comparison environments
//! from the loaded ones, and so on. Each wizard rebuilds the one node it edits
//! and commits it through [`ReportEditor::wizard_apply`], keeping the AST the
//! single source of truth exactly like every other block edit.
//!
//! egui gives us native checkboxes, combo boxes and radio buttons, so the same
//! forms the TUI drives with row-cycling key handlers are a fraction of the code
//! here.

use eframe::egui::{self, RichText};

use crate::report::context;
use crate::report::edit::node_at;
use crate::report::flow::{
    EnvClause, FlowNode, ParallelSpec, Pattern, Producer, ReportStmt, ResponseFmt, RoleRef,
    ShowField, UsingItem, WithItem,
};
use crate::report::model::StatKind;

use super::app::GuiApp;
use super::report_editor::ReportEditor;

/// An open node-configure wizard, one variant per form-backed node kind.
pub enum Wizard {
    Request(RequestForm),
    Envs(EnvsForm),
    Files(FilesForm),
    Assign(AssignForm),
    List(ListForm),
    Folders(FoldersForm),
    /// `REPORT <var>` / `REPORT <var> AS <name>`: which in-scope variables become
    /// columns.
    Vars(VarsForm),
    /// `REPORT "<template>" AS <name>`: a computed column.
    Computed(ComputedForm),
    /// Fallback for kinds without a dedicated form (tuple-pattern loops, tuple
    /// list literals, exotic producers): edit the raw statement text.
    Raw(RawForm),
    /// One `name: query` field of a report request's `WITH … END` block.
    WithField(WithFieldForm),
}

/// The `REPORT <var>` form. The checklist covers the variables the static scan
/// can see; `other` is the escape hatch for names bound only at run time (by
/// `ZIP`/`TUPLES FROM`, or supplied by an environment file).
pub struct VarsForm {
    path: Vec<usize>,
    /// `(name, ticked)` over every variable in scope, in flow order.
    vars: Vec<(String, bool)>,
    other: String,
    /// The `AS` name. Only meaningful for a single variable — `REPORT (A, B)`
    /// emits two columns and so has no one name to give.
    alias: String,
    stats: Vec<(StatKind, bool)>,
    /// The `TRUTH`/`IMAGE`/`DETAIL` clause block, as edited.
    clauses: crate::report::edit::ClauseForm,
}

impl VarsForm {
    /// Every variable the form would report, ticked ones first then `other`.
    fn chosen(&self) -> Vec<String> {
        let mut v: Vec<String> = self
            .vars
            .iter()
            .filter(|(_, on)| *on)
            .map(|(n, _)| n.clone())
            .collect();
        let other = self.other.trim();
        if !other.is_empty() && !v.iter().any(|n| n == other) {
            v.push(other.to_string());
        }
        v
    }

    /// The node this form describes, or `None` when nothing is picked.
    fn node(&self) -> Option<FlowNode> {
        let chosen = self.chosen();
        let (first, rest) = chosen.split_first()?;
        let alias = self.alias.trim();
        let image = self.clauses.image();
        let truth = self.clauses.truth();
        // An alias applies to exactly one column, so a multi-variable pick
        // ignores it rather than silently dropping the extra variables. A
        // clause is enough on its own to need the `AS` form, so an unnamed
        // column falls back to the variable's own name rather than losing it.
        if rest.is_empty()
            && (!alias.is_empty() || image.is_some() || truth.is_some() || self.clauses.detail)
        {
            return Some(FlowNode::Report(ReportStmt::VarAs {
                var: first.clone(),
                name: if alias.is_empty() {
                    first.clone()
                } else {
                    alias.to_string()
                },
                stats: self
                    .stats
                    .iter()
                    .filter(|(_, on)| *on)
                    .map(|(k, _)| *k)
                    .collect(),
                image,
                truth,
                detail: self.clauses.detail,
            }));
        }
        Some(FlowNode::Report(ReportStmt::Vars(chosen)))
    }
}

/// The `REPORT "<template>" AS <name>` form. Both halves are mandatory: the
/// statement will not re-parse without them.
pub struct ComputedForm {
    path: Vec<usize>,
    template: String,
    alias: String,
    stats: Vec<(StatKind, bool)>,
    /// The `TRUTH`/`IMAGE`/`DETAIL` clause block, as edited.
    clauses: crate::report::edit::ClauseForm,
}

/// The `VARIABLE = VALUE` (`Assign`) form: two plain text fields.
pub struct AssignForm {
    path: Vec<usize>,
    key: String,
    value: String,
}

/// The `LIST NAME = [ … ]` form: a name and one list-literal scalar per line.
/// Only a list-literal producer is edited here; any other producer falls back to
/// the [`RawForm`].
pub struct ListForm {
    path: Vec<usize>,
    name: String,
    /// The list elements, one per line (scalars; tuples are written `a, b`).
    values: String,
}

/// The `FOR … IN FOLDERS "dir"` form: loop variable, source folder and the
/// `PARALLEL` toggle. Any `WITH role="glob"` clauses are preserved verbatim.
pub struct FoldersForm {
    path: Vec<usize>,
    var: String,
    dir: String,
    parallel: bool,
    /// `PARALLEL`'s optional max-concurrency, kept as text so the box can be
    /// left blank (meaning "use the prelude's MAX_PARALLEL") and so half-typed
    /// input isn't clamped under the user's cursor.
    degree: String,
}

/// The generic fallback form: the node's single statement line, edited as text
/// and re-parsed on apply (the old inline line editor, now a modal).
pub struct RawForm {
    path: Vec<usize>,
    text: String,
    is_loop: bool,
}

/// The `WITH` *field* form: one `name: query` column of a report request's
/// `WITH … END` block. `index` is `Some` when editing an existing field and
/// `None` when adding a new one (appended on apply). The request node itself is
/// left in place — only the one field is added/rewritten.
pub struct WithFieldForm {
    path: Vec<usize>,
    index: Option<usize>,
    name: String,
    query: String,
    /// The `STATISTICS(…)` checklist: `(stat, on)` over every choosable stat, in
    /// [`StatKind::CHOOSABLE`] order. None ticked ⇒ no clause.
    stats: Vec<(StatKind, bool)>,
    /// The `TRUTH`/`IMAGE`/`DETAIL` clause block, as edited.
    clauses: crate::report::edit::ClauseForm,
}

impl WithFieldForm {
    fn stats(&self) -> Vec<StatKind> {
        self.stats
            .iter()
            .filter(|(_, on)| *on)
            .map(|(k, _)| *k)
            .collect()
    }
}

/// The request form: pick the name, toggle whether it is *reported*, and — when
/// reported — its response format, `AS` alias and which fields it emits (`SHOW`).
pub struct RequestForm {
    path: Vec<usize>,
    name: String,
    /// Request titles from the bound collection (the name picker's choices).
    titles: Vec<String>,
    report: bool,
    response: Option<ResponseFmt>,
    alias: String,
    /// The `SHOW(…)` checklist: `(field, included)`. All ticked ⇒ no clause.
    fields: Vec<(String, bool)>,
    /// Any `STATISTICS(…)` the `SHOW(…)` fields carried. The checklist has no
    /// row for them; they are kept so applying the form can't delete a clause
    /// the user wrote in the source.
    show_stats: std::collections::HashMap<String, Vec<StatKind>>,
    /// The `HIDE(…)` checklist over the same field list: `(field, hidden)`.
    /// None ticked ⇒ no clause. `HIDE` subtracts from whatever `SHOW` selected,
    /// so both lists cover the same names.
    hide_fields: Vec<(String, bool)>,
    /// Preserved verbatim across the edit (the form doesn't expose them).
    with: Vec<WithItem>,
    /// The `USING(…)` clause as the node was opened with. Only its
    /// requirements and overrides are editable here, both below; the field is
    /// kept so anything a later clause item might carry survives the round trip.
    using: Vec<UsingItem>,
    /// The per-call overrides (`multipart.document = "…"`), as editable text.
    /// See [`crate::report::edit::OverrideRow`].
    overrides: Vec<crate::report::edit::OverrideRow>,
    /// The `USING(…)` requirement checklist for the currently named request.
    params: Vec<crate::report::edit::ParamRow>,
    /// The parameters every request in the bound collection declares, so
    /// picking a different name in the combo can re-derive the checklist
    /// without a trip back to the session (the form is drawn without one).
    params_by_request: std::collections::HashMap<String, Vec<(String, String)>>,
}

impl RequestForm {
    /// The `SHOW(…)` list for the ticked rows; empty when the ticked set is
    /// exactly what the request emits without a clause — every field except the
    /// opt-in timing intrinsics (⇒ no clause).
    fn show(&self) -> Vec<ShowField> {
        if self
            .fields
            .iter()
            .all(|(n, on)| *on != crate::report::run::OPT_IN_INTRINSIC_FIELDS.contains(&n.as_str()))
        {
            return Vec::new();
        }
        self.fields
            .iter()
            .filter(|(_, on)| *on)
            .map(|(n, _)| ShowField {
                field: n.clone(),
                // Carried through, never edited: the checklist has no row for a
                // `STATISTICS(…)` clause, and editing must not delete one.
                stats: self.show_stats.get(n).cloned().unwrap_or_default(),
            })
            .collect()
    }

    /// The `HIDE(…)` list for the ticked rows; empty ⇒ no clause.
    fn hide(&self) -> Vec<String> {
        self.hide_fields
            .iter()
            .filter(|(_, on)| *on)
            .map(|(n, _)| n.clone())
            .collect()
    }

    fn alias_opt(&self) -> Option<String> {
        let a = self.alias.trim();
        (!a.is_empty()).then(|| a.to_string())
    }

    /// Re-derive the `USING(…)` checklist for the currently named request,
    /// carrying the current ticks over.
    /// The clause this form describes: the ticked requirements, then the
    /// override rows that name a real part of the request.
    fn using_clause(&self) -> Vec<UsingItem> {
        crate::report::edit::using_items(
            &self.params,
            &crate::report::edit::override_items(&self.overrides),
        )
    }

    fn refresh_params(&mut self) {
        let using = crate::report::edit::using_items(&self.params, &self.using);
        let declared = self
            .params_by_request
            .get(self.name.trim())
            .map(Vec::as_slice)
            .unwrap_or(&[]);
        self.params = crate::report::edit::param_rows(declared, &using);
    }

    /// The node this form describes.
    fn to_node(&self) -> FlowNode {
        if self.report {
            FlowNode::Report(ReportStmt::Request {
                name: self.name.trim().to_string(),
                alias: self.alias_opt(),
                using: self.using_clause(),
                response_fmt: self.response,
                show: self.show(),
                hide: self.hide(),
                with: self.with.clone(),
            })
        } else {
            // `USING` describes the send, so it survives dropping REPORT.
            FlowNode::Request {
                name: self.name.trim().to_string(),
                using: self.using_clause(),
            }
        }
    }
}

/// One chosen environment in an [`EnvsForm`]. `baseline` matters only in compare
/// mode (at most one is the baseline); `file` marks a `FILE("…")` snapshot.
pub struct EnvEntry {
    name: String,
    baseline: bool,
    file: bool,
}

/// The `FOR … IN ENVS` form: loop variable, iterate-vs-compare mode, `PARALLEL`,
/// and the baseline/comparison environments picked from the loaded ones.
pub struct EnvsForm {
    path: Vec<usize>,
    var: String,
    compare: bool,
    parallel: bool,
    /// `PARALLEL`'s optional max-concurrency, kept as text so the box can be
    /// left blank (meaning "use the prelude's MAX_PARALLEL") and so half-typed
    /// input isn't clamped under the user's cursor.
    degree: String,
    entries: Vec<EnvEntry>,
    /// Loaded environment names an entry cycles through.
    choices: Vec<String>,
    /// Discovered `.baseline` snapshot paths a `FILE(…)` entry cycles through.
    snapshots: Vec<String>,
    /// `BASELINE(…) SHOW(…)` as a checklist: every field the loop body's
    /// requests can emit, ticked when it is in `baseline_show`. Empty
    /// `baseline_show` means "no SHOW clause", which is NOT the same as "show
    /// everything" — so nothing is ticked by default.
    baseline_show_fields: Vec<(String, bool)>,
    /// Any `STATISTICS(…)` on the `BASELINE(…) SHOW(…)` fields, carried through
    /// untouched for the same reason as [`RequestForm::show_stats`].
    show_stats: std::collections::HashMap<String, Vec<StatKind>>,
}

impl EnvsForm {
    fn var_or_default(&self) -> String {
        let v = self.var.trim();
        if v.is_empty() {
            "TARGET".to_string()
        } else {
            v.to_string()
        }
    }

    /// The ticked `BASELINE(…) SHOW(…)` fields, in the checklist's canonical
    /// order.
    ///
    /// Ticking nothing writes no `SHOW` clause at all — for a baseline that
    /// means "copy nothing across", which is the language's default, so there
    /// is no ambiguity with the request-level `SHOW` where empty means "show
    /// everything".
    fn selected_baseline_show(&self) -> Vec<ShowField> {
        self.baseline_show_fields
            .iter()
            .filter(|(_, on)| *on)
            .map(|(n, _)| ShowField {
                field: n.clone(),
                stats: self.show_stats.get(n).cloned().unwrap_or_default(),
            })
            .collect()
    }

    /// The [`EnvClause`] the current rows describe, or `None` when nothing is
    /// named (so the caller leaves the node unchanged rather than writing an
    /// unparseable empty clause).
    fn clause(&self) -> Option<EnvClause> {
        if self.compare {
            let refs = |want_baseline: bool| -> Vec<RoleRef> {
                self.entries
                    .iter()
                    .filter(|e| e.baseline == want_baseline && !e.name.trim().is_empty())
                    .map(|e| {
                        let name = e.name.trim().to_string();
                        if e.file {
                            RoleRef::File(name)
                        } else {
                            RoleRef::Env(name)
                        }
                    })
                    .collect()
            };
            let baseline = refs(true);
            let comparisons = refs(false);
            if baseline.is_empty() && comparisons.is_empty() {
                return None;
            }
            Some(EnvClause::Roles {
                baseline,
                comparisons,
                baseline_show: self.selected_baseline_show(),
            })
        } else {
            let names: Vec<String> = self
                .entries
                .iter()
                .map(|e| e.name.trim().to_string())
                .filter(|n| !n.is_empty())
                .collect();
            (!names.is_empty()).then_some(EnvClause::Plain(names))
        }
    }
}

/// The `FOR … IN FILES` form: loop variable, source folder, optional `MATCH`
/// glob and the `PARALLEL` toggle.
pub struct FilesForm {
    path: Vec<usize>,
    var: String,
    dir: String,
    glob: String,
    parallel: bool,
    /// `PARALLEL`'s optional max-concurrency, kept as text so the box can be
    /// left blank (meaning "use the prelude's MAX_PARALLEL") and so half-typed
    /// input isn't clamped under the user's cursor.
    degree: String,
}

impl FilesForm {
    fn var_or_default(&self) -> String {
        let v = self.var.trim();
        if v.is_empty() {
            "FILE".to_string()
        } else {
            v.to_string()
        }
    }

    fn glob_opt(&self) -> Option<String> {
        let g = self.glob.trim();
        (!g.is_empty()).then(|| g.to_string())
    }
}

// ---------------------------------------------------------------------------
// Opening a wizard for a node
// ---------------------------------------------------------------------------

/// Build the [`VarsForm`] for a reported-variable node. The candidate list needs
/// the bound collection so that the `[Captures]` of requests earlier in the flow
/// are offered alongside the flow's own assignments and loop binders.
fn build_vars(
    app: &GuiApp,
    flow: &crate::report::flow::ReportFlow,
    report_path: Option<&std::path::Path>,
    path: &[usize],
    node: &FlowNode,
) -> VarsForm {
    let (chosen, alias, stats, image, truth, detail) = match node {
        FlowNode::Report(ReportStmt::Vars(vars)) => {
            (vars.clone(), String::new(), Vec::new(), None, None, false)
        }
        FlowNode::Report(ReportStmt::VarAs {
            var,
            name,
            stats,
            image,
            truth,
            detail,
        }) => (
            vec![var.clone()],
            name.clone(),
            stats.clone(),
            *image,
            truth.clone(),
            *detail,
        ),
        _ => (Vec::new(), String::new(), Vec::new(), None, None, false),
    };
    let entries =
        context::bound_entries(&app.session.collections, flow, report_path).unwrap_or_default();
    let in_scope = crate::report::edit::vars_in_scope(flow, path, &entries);
    let mut vars: Vec<(String, bool)> = in_scope
        .iter()
        .map(|n| (n.clone(), chosen.contains(n)))
        .collect();
    // A variable already reported but no longer in scope still has to be
    // visible, or opening the form would quietly drop it.
    for c in &chosen {
        if !vars.iter().any(|(n, _)| n == c) {
            vars.push((c.clone(), true));
        }
    }
    VarsForm {
        path: path.to_vec(),
        vars,
        other: String::new(),
        alias,
        stats: StatKind::CHOOSABLE
            .iter()
            .map(|k| (*k, stats.contains(k)))
            .collect(),
        clauses: crate::report::edit::ClauseForm::of(image, truth.as_deref(), detail),
    }
}

/// Open the appropriate configure wizard for the node at `path`. Requests, ENVS
/// loops, single-variable FILES loops, assignments, list literals and FOLDERS
/// loops, reported variables and computed columns each get a purpose-built form;
/// the handful of kinds with no palette entry (tuple-pattern loops, tuple list
/// literals, `ZIP`/`CONCAT`/`TUPLES FROM` producers) fall back to a raw
/// single-line editor, so no node is ever left without a way to edit it.
pub fn open(ed: &mut ReportEditor, app: &GuiApp, path: &[usize]) {
    let Some(flow) = ed.flow.clone() else {
        return;
    };
    let Some(node) = node_at(&flow, path).cloned() else {
        return;
    };
    let report_path = ed.report.path.clone();
    let wiz = match &node {
        FlowNode::Request { .. } | FlowNode::Report(ReportStmt::Request { .. }) => Wizard::Request(
            build_request(app, &flow, report_path.as_deref(), path.to_vec(), &node),
        ),
        FlowNode::ForEnvs { .. } => Wizard::Envs(build_envs(
            app,
            &flow,
            report_path.as_deref(),
            path.to_vec(),
            &node,
        )),
        FlowNode::ForEach {
            pattern,
            producer: Producer::Files { .. },
            ..
        } if single_named_binder(pattern).is_some() => {
            Wizard::Files(build_files(path.to_vec(), &node))
        }
        FlowNode::ForEach {
            pattern,
            producer: Producer::Folders { .. },
            ..
        } if single_named_binder(pattern).is_some() => {
            Wizard::Folders(build_folders(path.to_vec(), &node))
        }
        FlowNode::Assign { key, value } => Wizard::Assign(AssignForm {
            path: path.to_vec(),
            key: key.clone(),
            value: value.clone(),
        }),
        FlowNode::ListDecl {
            name,
            producer: Producer::List(elems),
        } if elems
            .iter()
            .all(|e| matches!(e, crate::report::flow::Element::Scalar(_))) =>
        {
            Wizard::List(ListForm {
                path: path.to_vec(),
                name: name.clone(),
                values: list_values_text(elems),
            })
        }
        FlowNode::Report(ReportStmt::Vars(_)) | FlowNode::Report(ReportStmt::VarAs { .. }) => {
            Wizard::Vars(build_vars(app, &flow, report_path.as_deref(), path, &node))
        }
        FlowNode::Report(ReportStmt::Computed {
            template,
            name,
            stats,
            image,
            truth,
            detail,
        }) => Wizard::Computed(ComputedForm {
            path: path.to_vec(),
            template: template.clone(),
            alias: name.clone(),
            clauses: crate::report::edit::ClauseForm::of(*image, truth.as_deref(), *detail),
            stats: StatKind::CHOOSABLE
                .iter()
                .map(|k| (*k, stats.contains(k)))
                .collect(),
        }),
        _ => Wizard::Raw(RawForm {
            path: path.to_vec(),
            text: node.header_line(),
            is_loop: node.is_loop(),
        }),
    };
    ed.wizard = Some(wiz);
}

/// Open the `WITH`-field wizard for the report request at `path`. `index` is
/// `Some` to edit an existing `name: query` field (seeding the form from it) and
/// `None` to add a new one. Only a report request has a `WITH` block, so any
/// other node (or an out-of-range / non-`Field` index) opens an empty new-field
/// form defensively rather than doing nothing.
pub fn open_with_field(ed: &mut ReportEditor, path: &[usize], index: Option<usize>) {
    let existing = index.and_then(|i| {
        ed.flow
            .as_ref()
            .and_then(|f| node_at(f, path))
            .and_then(|n| match n {
                FlowNode::Report(ReportStmt::Request { with, .. }) => with.get(i).cloned(),
                _ => None,
            })
    });
    let (index, name, query, stats, clauses) = match existing {
        Some(WithItem::Field {
            name,
            query,
            stats,
            image,
            truth,
            detail,
        }) => (
            index,
            name,
            query,
            stats,
            crate::report::edit::ClauseForm::of(image, truth.as_deref(), detail),
        ),
        // Editing a non-field (bare `WITH RESPONSE`) or a stale index falls
        // through to a fresh append rather than silently doing nothing.
        _ => (
            None,
            String::new(),
            String::new(),
            Vec::new(),
            crate::report::edit::ClauseForm::default(),
        ),
    };
    ed.wizard = Some(Wizard::WithField(WithFieldForm {
        path: path.to_vec(),
        index,
        name,
        query,
        clauses,
        stats: StatKind::CHOOSABLE
            .iter()
            .map(|k| (*k, stats.contains(k)))
            .collect(),
    }));
}

/// The single *named* binder of a `FOR X IN …` pattern, if the pattern is
/// exactly one named binder. `FOR _ IN …` (a discard) and multi-binder patterns
/// return `None`, so they route to the raw editor rather than a form that would
/// silently rename or flatten them.
fn single_named_binder(pattern: &Pattern) -> Option<&str> {
    if pattern.is_single() {
        pattern.named().next()
    } else {
        None
    }
}

/// Render list-literal *scalar* elements as one line each. Only called for
/// all-scalar lists (tuples route to the raw editor), so this round-trips
/// losslessly with [`parse_list_values`].
fn list_values_text(elems: &[crate::report::flow::Element]) -> String {
    use crate::report::flow::Element;
    elems
        .iter()
        .map(|e| match e {
            Element::Scalar(s) => s.clone(),
            // Unreachable for the List form (guarded to all-scalar), but keep a
            // sensible rendering rather than panicking.
            Element::Tuple(parts) => parts.join(", "),
        })
        .collect::<Vec<_>>()
        .join("\n")
}

/// Parse the multiline values box back into scalar list elements: one element
/// per non-empty line, taken verbatim (no comma splitting), so a scalar is never
/// silently turned into a tuple.
fn parse_list_values(text: &str) -> Vec<crate::report::flow::Element> {
    use crate::report::flow::Element;
    text.lines()
        .map(str::trim)
        .filter(|l| !l.is_empty())
        .map(|l| Element::Scalar(l.to_string()))
        .collect()
}

/// Render `PARALLEL`'s max-concurrency box beside its checkbox. Disabled (but
/// still visible) while the loop is serial, so the setting is discoverable
/// without the checkbox row jumping in size as it is toggled.
fn parallel_row(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    parallel: &mut bool,
    degree: &mut String,
) {
    ui.horizontal(|ui| {
        ui.checkbox(
            &mut *parallel,
            RichText::new(s.report_node_parallel_label).color(th.text),
        );
        ui.add_enabled_ui(*parallel, |ui| {
            ui.add(
                egui::TextEdit::singleline(degree)
                    .hint_text(s.node_form_parallel_degree)
                    .desired_width(48.0),
            );
            ui.label(RichText::new(s.node_form_parallel_degree_label).color(th.dim));
        });
    });
}

/// The text shown in the max-concurrency box for an existing `PARALLEL` spec —
/// blank for a plain `PARALLEL` (no explicit limit) or a serial loop.
fn degree_text(parallel: &Option<ParallelSpec>) -> String {
    parallel
        .as_ref()
        .and_then(|p| p.degree)
        .map(|n| n.to_string())
        .unwrap_or_default()
}

/// Turn the typed max-concurrency into a `ParallelSpec`, preserving `existing`
/// when the loop stays serial is not the case. Anything that isn't a positive
/// integer (including a blank box) becomes "no explicit limit", which is the
/// plain `PARALLEL` form — the parser rejects `PARALLEL(0)`, so a 0 must never
/// reach the flow.
fn parallel_spec(on: bool, degree: &str) -> Option<ParallelSpec> {
    on.then(|| ParallelSpec {
        degree: degree.trim().parse::<u32>().ok().filter(|n| *n > 0),
    })
}

fn build_folders(path: Vec<usize>, node: &FlowNode) -> FoldersForm {
    let (var, dir, parallel) = match node {
        FlowNode::ForEach {
            pattern,
            producer: Producer::Folders { dir, .. },
            parallel,
            ..
        } => (
            pattern.named().next().unwrap_or("FOLDER").to_string(),
            dir.clone(),
            *parallel,
        ),
        _ => unreachable!("build_folders called on a non-FOLDERS node"),
    };
    FoldersForm {
        path,
        var,
        dir,
        parallel: parallel.is_some(),
        degree: degree_text(&parallel),
    }
}

fn build_request(
    app: &GuiApp,
    flow: &crate::report::flow::ReportFlow,
    report_path: Option<&std::path::Path>,
    path: Vec<usize>,
    node: &FlowNode,
) -> RequestForm {
    let (name, report, alias, response, show, hide, with, using) = match node {
        FlowNode::Request { name, using } => (
            name.clone(),
            false,
            None,
            None,
            Vec::new(),
            Vec::new(),
            Vec::new(),
            using.clone(),
        ),
        FlowNode::Report(ReportStmt::Request {
            name,
            alias,
            using,
            response_fmt,
            show,
            hide,
            with,
        }) => (
            name.clone(),
            true,
            alias.clone(),
            *response_fmt,
            show.clone(),
            hide.clone(),
            with.clone(),
            using.clone(),
        ),
        _ => unreachable!("build_request called on a non-request node"),
    };

    let bound = context::bound_entries(&app.session.collections, flow, report_path);
    let titles: Vec<String> = bound
        .as_deref()
        .map(|es| es.iter().map(|e| e.title.clone()).collect())
        .unwrap_or_default();

    // Every request's declared parameters, not just this one's: the name combo
    // can change which request the node calls, and the checklist has to follow
    // it without the form being able to ask the session again.
    let params_by_request: std::collections::HashMap<String, Vec<(String, String)>> = bound
        .as_deref()
        .map(|es| {
            es.iter()
                .map(|e| (e.title.clone(), e.variable_defaults()))
                .filter(|(_, p)| !p.is_empty())
                .collect()
        })
        .unwrap_or_default();
    let params = crate::report::edit::param_rows(
        params_by_request
            .get(&name)
            .map(Vec::as_slice)
            .unwrap_or(&[]),
        &using,
    );

    // The fields the request can emit, in canonical order: intrinsics, the
    // request's own `[Reports]` fields, then this node's `WITH` fields, then any
    // unknown `SHOW` entry (so applying can't silently drop it), de-duplicated.
    let report_fields = bound
        .as_deref()
        .and_then(|es| {
            crate::report::run::resolve_title(es, &name)
                .map(|e| e.reports.iter().map(|(f, _)| f.clone()).collect::<Vec<_>>())
        })
        .unwrap_or_default();
    let mut names: Vec<String> = Vec::new();
    let push = |n: &str, names: &mut Vec<String>| {
        if !names.iter().any(|x| x == n) {
            names.push(n.to_string());
        }
    };
    for f in crate::report::run::INTRINSIC_FIELDS {
        push(f, &mut names);
    }
    for f in &report_fields {
        push(f, &mut names);
    }
    for w in &with {
        if let WithItem::Field { name, .. } = w {
            push(name, &mut names);
        }
    }
    for f in &show {
        push(f.name(), &mut names);
    }
    // A HIDE entry naming a field nothing else knows about still has to appear
    // in the checklist, or applying the form would silently drop it.
    for f in &hide {
        push(f, &mut names);
    }
    // No SHOW clause means "everything this request already emits" — which
    // excludes the opt-in timing intrinsics, so they must start un-ticked or
    // simply opening and applying the form would switch them on.
    let all = show.is_empty();
    let fields = names
        .iter()
        .map(|n| {
            let on = (all && !crate::report::run::OPT_IN_INTRINSIC_FIELDS.contains(&n.as_str()))
                || show.iter().any(|s| s.name() == n);
            (n.clone(), on)
        })
        .collect();
    let hide_fields = names
        .iter()
        .map(|n| (n.clone(), hide.iter().any(|h| h == n)))
        .collect();

    RequestForm {
        path,
        name,
        titles,
        report,
        response,
        alias: alias.unwrap_or_default(),
        fields,
        show_stats: show
            .iter()
            .filter(|f| !f.stats.is_empty())
            .map(|f| (f.field.clone(), f.stats.clone()))
            .collect(),
        hide_fields,
        with,
        overrides: crate::report::edit::override_rows(&using),
        using,
        params,
        params_by_request,
    }
}

fn build_envs(
    app: &GuiApp,
    flow: &crate::report::flow::ReportFlow,
    report_path: Option<&std::path::Path>,
    path: Vec<usize>,
    node: &FlowNode,
) -> EnvsForm {
    let (var, clause, parallel, body) = match node {
        FlowNode::ForEnvs {
            var,
            clause,
            parallel,
            body,
        } => (var.clone(), clause.clone(), *parallel, body.as_slice()),
        _ => unreachable!("build_envs called on a non-ENVS node"),
    };

    let (compare, mut entries, baseline_show) = match &clause {
        EnvClause::Plain(names) => (
            false,
            names
                .iter()
                .map(|n| EnvEntry {
                    name: n.clone(),
                    baseline: false,
                    file: false,
                })
                .collect::<Vec<_>>(),
            Vec::new(),
        ),
        EnvClause::Roles {
            baseline,
            comparisons,
            baseline_show,
        } => {
            let entry = |r: &RoleRef, is_baseline: bool| EnvEntry {
                name: r.target().to_string(),
                baseline: is_baseline,
                file: matches!(r, RoleRef::File(_)),
            };
            let mut es: Vec<EnvEntry> = baseline.iter().map(|r| entry(r, true)).collect();
            es.extend(comparisons.iter().map(|r| entry(r, false)));
            (true, es, baseline_show.clone())
        }
    };

    let choices: Vec<String> = app
        .session
        .global_envs
        .iter()
        .map(|e| e.name.clone())
        .collect();
    let mut snapshots = discover_snapshots(flow, report_path);
    for e in &entries {
        if e.file && !e.name.trim().is_empty() && !snapshots.iter().any(|s| s == &e.name) {
            snapshots.push(e.name.clone());
        }
    }
    if entries.is_empty() {
        entries.push(EnvEntry {
            name: choices.first().cloned().unwrap_or_default(),
            baseline: compare,
            file: false,
        });
    }

    let bound =
        context::bound_entries(&app.session.collections, flow, report_path).unwrap_or_default();
    let baseline_show_fields =
        crate::report::edit::baseline_show_choices(&bound, body, &baseline_show);

    EnvsForm {
        path,
        var,
        show_stats: baseline_show
            .iter()
            .filter(|f| !f.stats.is_empty())
            .map(|f| (f.field.clone(), f.stats.clone()))
            .collect(),
        compare,
        parallel: parallel.is_some(),
        degree: degree_text(&parallel),
        entries,
        choices,
        snapshots,
        baseline_show_fields,
    }
}

fn build_files(path: Vec<usize>, node: &FlowNode) -> FilesForm {
    let (var, dir, glob, parallel) = match node {
        FlowNode::ForEach {
            pattern,
            producer: Producer::Files { dir, glob },
            parallel,
            ..
        } => (
            pattern.named().next().unwrap_or("FILE").to_string(),
            dir.clone(),
            glob.clone().unwrap_or_default(),
            *parallel,
        ),
        _ => unreachable!("build_files called on a non-FILES node"),
    };
    FilesForm {
        path,
        var,
        dir,
        glob,
        parallel: parallel.is_some(),
        degree: degree_text(&parallel),
    }
}

/// The `.baseline` snapshot file names in the report's root directory, relative
/// to it — the candidates a `FILE(…)` role entry picks from. Empty on any I/O
/// error (the form then simply offers no snapshots).
fn discover_snapshots(
    flow: &crate::report::flow::ReportFlow,
    report_path: Option<&std::path::Path>,
) -> Vec<String> {
    let (root, _) = context::report_base_dir(flow, report_path);
    let mut out: Vec<String> = Vec::new();
    if let Ok(entries) = std::fs::read_dir(&root) {
        for entry in entries.flatten() {
            let p = entry.path();
            if p.extension().is_some_and(|e| e == "baseline")
                && let Some(name) = p.file_name().and_then(|n| n.to_str())
            {
                out.push(name.to_string());
            }
        }
    }
    out.sort();
    out
}

// ---------------------------------------------------------------------------
// Rendering the modal
// ---------------------------------------------------------------------------

/// What the modal's buttons (or a click-away / Escape) decided this frame.
enum Outcome {
    None,
    Apply,
    Cancel,
}

/// Draw the open wizard (if any) as a modal over the editor, applying or
/// cancelling it. A no-op when no wizard is open.
pub fn show(ed: &mut ReportEditor, app: &mut GuiApp, ctx: &egui::Context) {
    if ed.wizard.is_none() {
        return;
    }
    let th = app.theme;
    // Where a folder picker opens when the form's own field is still blank.
    let fallback = app
        .session
        .picker_dir(crate::session::PickerKind::Other)
        .map(|p| p.to_path_buf());
    let s = &app.strings;
    let mut outcome = Outcome::None;
    // A folder picker can't be opened from inside the form: it needs `app`,
    // which the modal closure has already borrowed. The click is recorded here
    // and acted on once the closure has let go.
    let mut browse = false;

    let modal = egui::Modal::new(egui::Id::new("pt_node_wizard")).show(ctx, |ui| {
        ui.set_min_width(360.0);
        // A modal has no title bar to hang a close button off, so it gets its
        // own: every dialog in the app can be left by the corner as well as by
        // Escape.
        ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
            if ui
                .button(RichText::new(super::icons::CLOSE).color(th.dim))
                .clicked()
            {
                outcome = Outcome::Cancel;
            }
        });
        let wiz = ed.wizard.as_mut().expect("wizard is Some");
        match wiz {
            Wizard::Request(f) => request_ui(ui, &th, s, f),
            Wizard::Envs(f) => envs_ui(ui, &th, s, f),
            Wizard::Files(f) => files_ui(ui, &th, s, f, &mut browse),
            Wizard::Assign(f) => assign_ui(ui, &th, s, f),
            Wizard::List(f) => list_ui(ui, &th, s, f),
            Wizard::Folders(f) => folders_ui(ui, &th, s, f, &mut browse),
            Wizard::Vars(f) => vars_ui(ui, &th, s, f),
            Wizard::Computed(f) => computed_ui(ui, &th, s, f),
            Wizard::Raw(f) => raw_ui(ui, &th, s, f),
            Wizard::WithField(f) => with_field_ui(ui, &th, s, f),
        }
        ui.add_space(8.0);
        ui.separator();
        ui.horizontal(|ui| {
            if ui.button(RichText::new(s.gui_ok).color(th.text)).clicked() {
                outcome = Outcome::Apply;
            }
            if ui
                .button(RichText::new(s.gui_cancel).color(th.text))
                .clicked()
            {
                outcome = Outcome::Cancel;
            }
        });
    });
    if modal.should_close() {
        outcome = Outcome::Cancel;
    }

    // Now that the closure has released `app`, a Browse click can open its
    // dialog -- off the frame loop, so the modal keeps painting behind it.
    if browse {
        let current = match ed.wizard.as_ref() {
            Some(Wizard::Files(f)) => f.dir.clone(),
            Some(Wizard::Folders(f)) => f.dir.clone(),
            _ => String::new(),
        };
        app.request_pick(
            super::filepick::PickKind::Folder,
            app.strings.report_node_files_folder_label,
            super::filepick::seed_dir(&current)
                .as_deref()
                .or(fallback.as_deref()),
            super::menu::PickAction::ReportWizardDir,
        );
    }

    match outcome {
        Outcome::None => {}
        Outcome::Cancel => ed.wizard = None,
        Outcome::Apply => {
            apply(ed, app);
            ed.wizard = None;
        }
    }
}

fn request_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut RequestForm,
) {
    ui.heading(RichText::new(s.node_request_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_req_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.node_form_name).color(th.dim));
            let before = f.name.clone();
            // `horizontal_top`, and a text margin matched to the button
            // padding, so the field and its picker are the same height and
            // share a top edge. Left to themselves they are not: a ComboBox
            // sizes itself from `button_padding` and a TextEdit from its own
            // margin, and the `Align::Center` of a plain `horizontal` inside a
            // Grid cell doesn't reconcile the two — the dropdown sat a couple
            // of pixels low and hung below the field it belongs to.
            ui.horizontal_top(|ui| {
                let pad = ui.spacing().button_padding.y as i8;
                ui.add(
                    egui::TextEdit::singleline(&mut f.name)
                        .desired_width(180.0)
                        .margin(egui::Margin::symmetric(4, pad)),
                );
                if !f.titles.is_empty() {
                    egui::ComboBox::from_id_salt("pt_req_name_pick")
                        .selected_text(RichText::new("…").color(th.dim))
                        .show_ui(ui, |ui| {
                            for t in f.titles.clone() {
                                if ui.selectable_label(f.name == t, &t).clicked() {
                                    f.name = t;
                                }
                            }
                        });
                }
            });
            // Parameters belong to the request, so changing which request this
            // node calls has to re-derive the checklist. Ticks survive: a name
            // the new request doesn't declare stays on as an undeclared row,
            // which is the error to see rather than a row that quietly went.
            if f.name != before {
                f.refresh_params();
            }
            ui.end_row();

            ui.label(RichText::new(s.node_form_report).color(th.dim));
            ui.checkbox(
                &mut f.report,
                RichText::new(s.node_form_report_hint).color(th.text),
            );
            ui.end_row();

            if f.report {
                ui.label(RichText::new(s.node_form_response).color(th.dim));
                ui.horizontal(|ui| {
                    ui.selectable_value(&mut f.response, None, s.node_form_response_default);
                    ui.selectable_value(&mut f.response, Some(ResponseFmt::Raw), "RAW");
                    ui.selectable_value(&mut f.response, Some(ResponseFmt::Pretty), "PRETTY");
                });
                ui.end_row();

                ui.label(RichText::new(s.node_form_alias).color(th.dim));
                ui.add(egui::TextEdit::singleline(&mut f.alias).desired_width(180.0));
                ui.end_row();
            }
        });

    // The `USING(…)` section is drawn unconditionally. It used to appear only
    // when the named request declared parameters, which meant that for a
    // collection where nothing does — the usual state of an existing
    // collection — the dialog showed no sign the clause existed at all, and
    // there was no way to reach it except by hand in the source view.
    ui.add_space(6.0);
    ui.label(RichText::new(s.node_form_using).color(th.dim));
    ui.label(RichText::new(s.node_form_using_hint).color(th.dim));
    if f.params.is_empty() {
        // Say so, and say where the fix is: declaring a parameter happens in
        // the *request* editor, which is not where the reader is looking.
        ui.label(RichText::new(s.node_form_using_none).color(th.dim));
    }
    for p in &mut f.params {
        ui.horizontal(|ui| {
            ui.checkbox(
                &mut p.required,
                RichText::new(p.name.as_str()).color(th.text),
            );
            // The declared default is what the request does when nothing
            // steers it — the thing an author needs to see to know whether
            // ticking the row matters. No default means the clause requires
            // a name the request doesn't declare, which is an error.
            match &p.default {
                Some(v) => {
                    ui.label(RichText::new(format!("= {v}")).color(th.dim));
                }
                None => {
                    ui.label(RichText::new(s.report_node_param_undeclared).color(th.err));
                }
            }
        });
    }

    ui.add_space(4.0);
    ui.label(RichText::new(s.node_form_override_hint).color(th.dim));
    let mut drop_override: Option<usize> = None;
    for (i, row) in f.overrides.iter_mut().enumerate() {
        ui.horizontal(|ui| {
            // A target that can never work is shown wrong as it is typed
            // rather than silently dropped on OK — the box is the only place
            // the mistake is visible.
            let ok = crate::report::edit::override_target_valid(&row.target);
            let target = egui::TextEdit::singleline(&mut row.target)
                .desired_width(150.0)
                .hint_text(s.node_form_override_target_hint)
                .text_color(if ok { th.text } else { th.err });
            ui.add(target);
            ui.label(RichText::new("=").color(th.dim));
            ui.add(
                egui::TextEdit::singleline(&mut row.value)
                    .desired_width(180.0)
                    .hint_text(s.node_form_override_value_hint),
            );
            if ui
                .button(RichText::new(super::icons::CLOSE).color(th.err))
                .clicked()
            {
                drop_override = Some(i);
            }
        });
        if !crate::report::edit::override_target_valid(&row.target) {
            ui.label(RichText::new(s.node_form_override_bad_target).color(th.err));
        }
    }
    if let Some(i) = drop_override {
        f.overrides.remove(i);
    }
    if ui.button(s.node_form_override_add).clicked() {
        f.overrides
            .push(crate::report::edit::OverrideRow::default());
    }

    if f.report && !f.fields.is_empty() {
        ui.add_space(6.0);
        ui.label(RichText::new(s.node_form_show).color(th.dim));
        ui.label(RichText::new(s.node_form_show_hint).color(th.dim));
        egui::ScrollArea::vertical()
            .id_salt("pt_req_fields")
            .max_height(160.0)
            .auto_shrink([false, true])
            .show(ui, |ui| {
                for (name, on) in &mut f.fields {
                    ui.checkbox(on, RichText::new(name.as_str()).color(th.text));
                }
            });

        ui.add_space(6.0);
        ui.label(RichText::new(s.node_form_hide).color(th.dim));
        ui.label(RichText::new(s.node_form_hide_hint).color(th.dim));
        egui::ScrollArea::vertical()
            .id_salt("pt_req_hide_fields")
            .max_height(120.0)
            .auto_shrink([false, true])
            .show(ui, |ui| {
                for (name, on) in &mut f.hide_fields {
                    ui.checkbox(on, RichText::new(name.as_str()).color(th.text));
                }
            });
    }
}

fn envs_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut EnvsForm,
) {
    ui.heading(RichText::new(s.report_node_envs_title).color(th.text));
    ui.add_space(4.0);
    ui.horizontal(|ui| {
        ui.label(RichText::new(s.report_node_envs_var_label).color(th.dim));
        ui.add(egui::TextEdit::singleline(&mut f.var).desired_width(160.0));
    });
    ui.horizontal(|ui| {
        ui.label(RichText::new(s.report_node_envs_mode_label).color(th.dim));
        let mut compare = f.compare;
        ui.selectable_value(&mut compare, false, s.report_node_envs_mode_plain);
        ui.selectable_value(&mut compare, true, s.report_node_envs_mode_roles);
        if compare != f.compare {
            f.compare = compare;
            // Entering compare with no baseline promotes the first entry so a
            // comparison always has a reference.
            if f.compare
                && !f.entries.iter().any(|e| e.baseline)
                && let Some(first) = f.entries.first_mut()
            {
                first.baseline = true;
            }
        }
    });
    parallel_row(ui, th, s, &mut f.parallel, &mut f.degree);

    ui.add_space(6.0);
    ui.label(RichText::new(s.node_envs_environments).color(th.dim));
    let mut remove: Option<usize> = None;
    let mut make_baseline: Option<usize> = None;
    let mut toggled_file: Option<usize> = None;
    // Iterate by index over cloned pick-lists so the row closures can mutate the
    // matching entry without also borrowing the rest of `f`.
    let compare = f.compare;
    let count = f.entries.len();
    let choices = f.choices.clone();
    let snapshots = f.snapshots.clone();
    for i in 0..count {
        ui.horizontal(|ui| {
            let list = if f.entries[i].file {
                &snapshots
            } else {
                &choices
            };
            let selected = f.entries[i].name.clone();
            egui::ComboBox::from_id_salt(("pt_env_pick", i))
                .selected_text(if selected.is_empty() {
                    RichText::new("—").color(th.dim)
                } else {
                    RichText::new(selected.as_str()).color(th.text)
                })
                .show_ui(ui, |ui| {
                    for c in list.clone() {
                        if ui.selectable_label(f.entries[i].name == c, &c).clicked() {
                            f.entries[i].name = c;
                        }
                    }
                });
            if compare {
                if ui
                    .radio(f.entries[i].baseline, s.report_node_envs_baseline)
                    .clicked()
                {
                    make_baseline = Some(i);
                }
                if ui
                    .checkbox(&mut f.entries[i].file, s.report_node_envs_file)
                    .changed()
                {
                    toggled_file = Some(i);
                }
            }
            if count > 1 && ui.button(RichText::new("×").color(th.err)).clicked() {
                remove = Some(i);
            }
        });
        // The `SHOW` belongs to the BASELINE role, not to the loop, so it is
        // drawn as an indented, boxed continuation of the baseline's own row —
        // close enough to read as part of it, and impossible to mistake for
        // something governing the comparisons listed below.
        if compare && f.entries[i].baseline {
            baseline_show_ui(ui, th, s, &mut f.baseline_show_fields);
        }
    }
    if let Some(i) = make_baseline {
        for (j, e) in f.entries.iter_mut().enumerate() {
            e.baseline = j == i;
        }
    }
    if let Some(i) = toggled_file {
        // Switching a role between a live env and a snapshot resets its value to
        // the first item of the newly relevant list so it starts valid.
        let list = if f.entries[i].file {
            &f.snapshots
        } else {
            &f.choices
        };
        if !list.iter().any(|c| c == &f.entries[i].name)
            && let Some(first) = list.first().cloned()
        {
            f.entries[i].name = first;
        }
    }
    if let Some(i) = remove {
        f.entries.remove(i);
    }
    if ui
        .button(RichText::new(format!("{} {}", super::icons::PLUS, s.node_envs_add)).color(th.text))
        .clicked()
    {
        f.entries.push(EnvEntry {
            name: f.choices.first().cloned().unwrap_or_default(),
            baseline: false,
            file: false,
        });
    }
}

fn files_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut FilesForm,
    browse: &mut bool,
) {
    ui.heading(RichText::new(s.report_node_files_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_files_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.report_node_files_var_label).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.var).desired_width(220.0));
            ui.end_row();
            ui.label(RichText::new(s.report_node_files_folder_label).color(th.dim));
            ui.horizontal(|ui| {
                ui.add(egui::TextEdit::singleline(&mut f.dir).desired_width(220.0));
                if ui.button(s.gui_browse).clicked() {
                    *browse = true;
                }
            });
            ui.end_row();
            ui.label(RichText::new(s.report_node_files_match_label).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.glob).desired_width(220.0));
            ui.end_row();
        });
    parallel_row(ui, th, s, &mut f.parallel, &mut f.degree);
}

fn assign_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut AssignForm,
) {
    ui.heading(RichText::new(s.node_assign_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_assign_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.node_form_var).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.key).desired_width(220.0));
            ui.end_row();
            ui.label(RichText::new(s.node_form_value).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.value).desired_width(220.0));
            ui.end_row();
        });
}

fn list_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut ListForm,
) {
    ui.heading(RichText::new(s.node_list_title).color(th.text));
    ui.add_space(4.0);
    ui.horizontal(|ui| {
        ui.label(RichText::new(s.node_form_list_name).color(th.dim));
        ui.add(egui::TextEdit::singleline(&mut f.name).desired_width(200.0));
    });
    ui.add_space(6.0);
    ui.label(RichText::new(s.node_form_list_values).color(th.dim));
    ui.add(
        egui::TextEdit::multiline(&mut f.values)
            .desired_width(f32::INFINITY)
            .desired_rows(5)
            .font(egui::TextStyle::Monospace),
    );
}

fn folders_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut FoldersForm,
    browse: &mut bool,
) {
    ui.heading(RichText::new(s.node_folders_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_folders_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.report_node_files_var_label).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.var).desired_width(220.0));
            ui.end_row();
            ui.label(RichText::new(s.report_node_files_folder_label).color(th.dim));
            ui.horizontal(|ui| {
                ui.add(egui::TextEdit::singleline(&mut f.dir).desired_width(220.0));
                if ui.button(s.gui_browse).clicked() {
                    *browse = true;
                }
            });
            ui.end_row();
        });
    parallel_row(ui, th, s, &mut f.parallel, &mut f.degree);
}

fn raw_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut RawForm,
) {
    ui.heading(RichText::new(s.node_raw_title).color(th.text));
    ui.add_space(4.0);
    ui.label(RichText::new(s.node_form_raw).color(th.dim));
    ui.add(
        egui::TextEdit::multiline(&mut f.text)
            .desired_width(f32::INFINITY)
            .desired_rows(2)
            .font(egui::TextStyle::Monospace),
    );
}

/// Draw the statistics checklist shared by the `WITH`-field, reported-variable
/// and computed-column forms. Laid out in columns because nine stacked
/// checkboxes would push the OK / Cancel row off a short window.
fn stats_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    stats: &mut [(StatKind, bool)],
) {
    ui.label(RichText::new(s.node_form_statistics).color(th.dim));
    ui.label(RichText::new(s.node_form_statistics_hint).color(th.dim));
    ui.horizontal_top(|ui| {
        for chunk in stats.chunks_mut(5) {
            ui.vertical(|ui| {
                for (kind, on) in chunk {
                    ui.checkbox(on, RichText::new(kind.label()).color(th.text));
                }
            });
        }
    });
}

/// Draw the `TRUTH`/`IMAGE`/`DETAIL` clause block shared by the `WITH`-field,
/// reported-variable and computed-column forms.
///
/// One helper rather than three copies: the clauses attach identically to all
/// three column shapes, and three near-identical blocks would be three chances
/// for one of them to drift.
fn clauses_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    c: &mut crate::report::edit::ClauseForm,
) {
    ui.horizontal(|ui| {
        ui.label(RichText::new(s.report_node_clause_truth_label).color(th.dim));
        ui.add(
            egui::TextEdit::singleline(&mut c.truth)
                .hint_text(s.report_node_clause_truth_none)
                .desired_width(220.0)
                .font(egui::TextStyle::Monospace),
        );
    });
    ui.checkbox(
        &mut c.detail,
        RichText::new(s.report_node_clause_detail_toggle).color(th.text),
    );
    // The three sizing questions only matter once a column holds a picture, so
    // they hide behind the toggle exactly as the statistics checklist does.
    let mut image_on = c.image_on;
    if ui
        .checkbox(
            &mut image_on,
            RichText::new(s.report_node_clause_image_toggle).color(th.text),
        )
        .changed()
    {
        c.toggle_image();
    }
    if !c.image_on {
        return;
    }
    ui.indent("pt_clause_image", |ui| {
        let mut fit = c.fit;
        if ui
            .checkbox(
                &mut fit,
                RichText::new(s.report_node_clause_fit).color(th.text),
            )
            .changed()
        {
            c.toggle_fit();
        }
        // FIT answers the same question as the sizes, so it replaces them
        // rather than sitting alongside a value the writers would have to
        // arbitrate between.
        if c.fit {
            return;
        }
        for (label, value) in [
            (s.report_node_clause_height, &mut c.height),
            (s.report_node_clause_width, &mut c.width),
        ] {
            ui.horizontal(|ui| {
                ui.label(RichText::new(label).color(th.dim));
                if ui
                    .add(
                        egui::TextEdit::singleline(value)
                            .hint_text(s.report_node_clause_size_auto)
                            .desired_width(80.0),
                    )
                    .changed()
                {
                    // Sizes are pixels; a stray letter would drop the whole
                    // clause when it failed to parse, so it never gets in.
                    value.retain(|ch| ch.is_ascii_digit());
                }
            });
        }
    });
}

fn vars_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut VarsForm,
) {
    ui.heading(RichText::new(s.report_node_vars_title).color(th.text));
    ui.add_space(4.0);
    if f.vars.is_empty() {
        ui.label(RichText::new(s.report_node_vars_none).color(th.dim));
    }
    for (name, on) in &mut f.vars {
        ui.checkbox(on, RichText::new(name.as_str()).color(th.text));
    }
    ui.add_space(6.0);
    ui.horizontal(|ui| {
        ui.label(RichText::new(s.report_node_vars_other_label).color(th.dim));
        ui.add(egui::TextEdit::singleline(&mut f.other).desired_width(200.0));
    });
    // A single column can be renamed and summarised; several cannot, so the
    // rows disappear rather than sit there doing nothing.
    if f.chosen().len() == 1 {
        ui.add_space(6.0);
        ui.horizontal(|ui| {
            ui.label(RichText::new(s.report_node_alias_label).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.alias).desired_width(200.0));
        });
        if !f.alias.trim().is_empty() {
            ui.add_space(6.0);
            stats_ui(ui, th, s, &mut f.stats);
        }
        ui.add_space(6.0);
        clauses_ui(ui, th, s, &mut f.clauses);
    }
}

fn computed_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut ComputedForm,
) {
    ui.heading(RichText::new(s.report_node_computed_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_computed_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.report_node_computed_template_label).color(th.dim));
            ui.add(
                egui::TextEdit::singleline(&mut f.template)
                    .hint_text(s.report_node_computed_template_hint)
                    .desired_width(240.0)
                    .font(egui::TextStyle::Monospace),
            );
            ui.end_row();
            ui.label(RichText::new(s.report_node_computed_name_label).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.alias).desired_width(240.0));
            ui.end_row();
        });
    ui.add_space(6.0);
    stats_ui(ui, th, s, &mut f.stats);
    ui.add_space(6.0);
    clauses_ui(ui, th, s, &mut f.clauses);
}

fn with_field_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    f: &mut WithFieldForm,
) {
    ui.heading(RichText::new(s.node_with_title).color(th.text));
    ui.add_space(4.0);
    egui::Grid::new("pt_with_grid")
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            ui.label(RichText::new(s.node_with_name).color(th.dim));
            ui.add(egui::TextEdit::singleline(&mut f.name).desired_width(220.0));
            ui.end_row();

            ui.label(RichText::new(s.node_with_query).color(th.dim));
            ui.add(
                egui::TextEdit::singleline(&mut f.query)
                    .hint_text(s.node_with_query_hint)
                    .desired_width(220.0)
                    .font(egui::TextStyle::Monospace),
            );
            ui.end_row();
        });

    ui.add_space(6.0);
    stats_ui(ui, th, s, &mut f.stats);
    ui.add_space(6.0);
    clauses_ui(ui, th, s, &mut f.clauses);
}

fn apply(ed: &mut ReportEditor, app: &mut GuiApp) {
    let Some(wiz) = ed.wizard.as_ref() else {
        return;
    };
    match wiz {
        Wizard::Request(f) => {
            let path = f.path.clone();
            let node = f.to_node();
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Envs(f) => {
            let Some(clause) = f.clause() else {
                return;
            };
            let path = f.path.clone();
            // Preserve the node's body; the var/clause and the PARALLEL
            // toggle and degree are what this form edits.
            let body = match ed.flow.as_ref().and_then(|fl| node_at(fl, &path)) {
                Some(FlowNode::ForEnvs { body, .. }) => body.clone(),
                _ => return,
            };
            let parallel = parallel_spec(f.parallel, &f.degree);
            let node = FlowNode::ForEnvs {
                var: f.var_or_default(),
                clause,
                body,
                parallel,
            };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Files(f) => {
            let path = f.path.clone();
            let body = match ed.flow.as_ref().and_then(|fl| node_at(fl, &path)) {
                Some(FlowNode::ForEach { body, .. }) => body.clone(),
                _ => return,
            };
            let parallel = parallel_spec(f.parallel, &f.degree);
            let node = FlowNode::ForEach {
                pattern: Pattern::single(f.var_or_default()),
                producer: Producer::Files {
                    dir: f.dir.clone(),
                    glob: f.glob_opt(),
                },
                body,
                parallel,
            };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Assign(f) => {
            let path = f.path.clone();
            let key = f.key.trim();
            if key.is_empty() {
                return;
            }
            let node = FlowNode::Assign {
                key: key.to_string(),
                value: f.value.clone(),
            };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::List(f) => {
            let path = f.path.clone();
            let name = f.name.trim();
            if name.is_empty() {
                return;
            }
            let node = FlowNode::ListDecl {
                name: name.to_string(),
                producer: Producer::List(parse_list_values(&f.values)),
            };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Folders(f) => {
            let path = f.path.clone();
            // Preserve the loop body and any WITH role globs; var/dir and the
            // PARALLEL toggle and degree are what this form edits.
            let (body, glob, roles) = match ed.flow.as_ref().and_then(|fl| node_at(fl, &path)) {
                Some(FlowNode::ForEach {
                    body,
                    producer: Producer::Folders { glob, roles, .. },
                    ..
                }) => (body.clone(), glob.clone(), roles.clone()),
                _ => return,
            };
            let parallel = parallel_spec(f.parallel, &f.degree);
            let node = FlowNode::ForEach {
                pattern: Pattern::single(if f.var.trim().is_empty() {
                    "FOLDER".to_string()
                } else {
                    f.var.trim().to_string()
                }),
                producer: Producer::Folders {
                    dir: f.dir.clone(),
                    glob,
                    roles,
                },
                body,
                parallel,
            };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Vars(f) => {
            let path = f.path.clone();
            let Some(node) = f.node() else { return };
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Computed(f) => {
            let path = f.path.clone();
            let (template, alias) = (f.template.trim(), f.alias.trim());
            // Either half missing and the statement would not re-parse, which
            // would eject the user from the node editor.
            if template.is_empty() || alias.is_empty() {
                return;
            }
            let node = FlowNode::Report(ReportStmt::Computed {
                template: template.to_string(),
                name: alias.to_string(),
                stats: f
                    .stats
                    .iter()
                    .filter(|(_, on)| *on)
                    .map(|(k, _)| *k)
                    .collect(),
                image: f.clauses.image(),
                truth: f.clauses.truth(),
                detail: f.clauses.detail,
            });
            ed.wizard_apply(app, &path, node);
        }
        Wizard::Raw(f) => {
            let path = f.path.clone();
            if let Some(node) = crate::report::edit::parse_one_node(&f.text, f.is_loop) {
                ed.wizard_apply(app, &path, node);
            }
        }
        Wizard::WithField(f) => {
            let path = f.path.clone();
            let name = f.name.trim().to_string();
            let query = f.query.trim().to_string();
            // A field needs both a column name and a query; an incomplete form
            // is dropped rather than writing a broken `WITH` item.
            if name.is_empty() || query.is_empty() {
                return;
            }
            let index = f.index;
            let stats = f.stats();
            let clauses = f.clauses.clone();
            ed.commit_edit(app, |flow| match index {
                Some(i) => {
                    crate::report::edit::set_with_field(
                        flow, &path, i, &name, &query, stats, &clauses,
                    );
                }
                None => {
                    // Appending only takes the name/query/statistics, so the
                    // clause block is written straight afterwards onto the row
                    // the append just created -- one code path for the clauses
                    // rather than two that could drift.
                    if let Some(i) = crate::report::edit::add_with_field(
                        flow,
                        &path,
                        &name,
                        &query,
                        stats.clone(),
                    ) {
                        crate::report::edit::set_with_field(
                            flow, &path, i, &name, &query, stats, &clauses,
                        );
                    }
                }
            });
            ed.selection = path;
        }
    }
}

/// The `BASELINE(…) SHOW(…)` checklist, drawn indented and boxed beneath the
/// baseline it belongs to.
///
/// Kept a free function taking only the checklist so it can be exercised
/// without building a whole [`EnvsForm`], and so the caller can render it
/// mid-loop without holding a borrow on the rest of the form.
fn baseline_show_ui(
    ui: &mut egui::Ui,
    th: &super::theme::GuiTheme,
    s: &crate::i18n::Strings,
    fields: &mut [(String, bool)],
) {
    if fields.is_empty() {
        return;
    }
    ui.horizontal(|ui| {
        // The indent is the visual tie to the baseline row above it.
        ui.add_space(24.0);
        egui::Frame::new()
            .fill(th.panel)
            .stroke(egui::Stroke::new(1.0, th.dim))
            .corner_radius(4.0)
            .inner_margin(egui::Margin::symmetric(8, 6))
            .show(ui, |ui| {
                ui.vertical(|ui| {
                    ui.horizontal(|ui| {
                        ui.label(RichText::new(s.node_envs_baseline_show).color(th.accent));
                        ui.label(
                            RichText::new(format!("({})", s.node_envs_baseline_show_applies))
                                .italics()
                                .color(th.dim),
                        );
                    });
                    ui.label(RichText::new(s.node_envs_baseline_show_hint).color(th.dim));
                    egui::ScrollArea::vertical()
                        .id_salt("pt_envs_baseline_show")
                        .max_height(140.0)
                        .auto_shrink([false, true])
                        .show(ui, |ui| {
                            for (name, on) in fields.iter_mut() {
                                ui.checkbox(on, RichText::new(name.as_str()).color(th.text));
                            }
                        });
                });
            });
    });
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::report::flow::{EnvClause, RoleRef};

    /// An ENVS form in compare mode with the given `SHOW` checklist.
    fn compare_form(fields: Vec<(String, bool)>) -> EnvsForm {
        EnvsForm {
            path: vec![0],
            var: "TARGET".into(),
            show_stats: Default::default(),
            compare: true,
            parallel: false,
            degree: String::new(),
            entries: vec![
                EnvEntry {
                    name: "prod".into(),
                    baseline: true,
                    file: false,
                },
                EnvEntry {
                    name: "staging".into(),
                    baseline: false,
                    file: false,
                },
            ],
            choices: vec!["prod".into(), "staging".into()],
            snapshots: Vec::new(),
            baseline_show_fields: fields,
        }
    }

    /// One ticked variable plus a name is a renamed column; a second tick has to
    /// drop back to the plain multi-column form, because `AS` names one column.
    #[test]
    fn a_named_single_variable_becomes_an_alias_and_a_pair_stays_plain() {
        let mut form = VarsForm {
            path: vec![0],
            vars: vec![("TIER".into(), true), ("REGION".into(), false)],
            other: String::new(),
            alias: "Plan".into(),
            stats: StatKind::CHOOSABLE.iter().map(|k| (*k, false)).collect(),
            clauses: crate::report::edit::ClauseForm::default(),
        };
        assert!(
            matches!(
                form.node(),
                Some(FlowNode::Report(ReportStmt::VarAs { ref var, ref name, .. }))
                    if var == "TIER" && name == "Plan"
            ),
            "a single ticked variable with a name is reported AS that name"
        );
        form.vars[1].1 = true;
        assert!(
            matches!(form.node(), Some(FlowNode::Report(ReportStmt::Vars(ref v))) if v == &["TIER".to_string(), "REGION".to_string()]),
            "two ticked variables report both columns and ignore the name"
        );
    }

    /// A clause is a reason to write the `AS` form even without a name: the
    /// column has to exist for a ground truth to score, so an unnamed one takes
    /// the variable's own name rather than losing the clause.
    #[test]
    fn a_clause_alone_promotes_a_variable_to_the_named_form() {
        let mut form = VarsForm {
            path: vec![0],
            vars: vec![("FILE".into(), true)],
            other: String::new(),
            alias: String::new(),
            stats: Vec::new(),
            clauses: crate::report::edit::ClauseForm::default(),
        };
        assert!(
            matches!(form.node(), Some(FlowNode::Report(ReportStmt::Vars(_)))),
            "with no name and no clauses it is still a plain column"
        );
        form.clauses.truth = "{{ want }}".into();
        let Some(FlowNode::Report(ReportStmt::VarAs { name, truth, .. })) = form.node() else {
            panic!("a ground truth needs the named form")
        };
        assert_eq!(name, "FILE", "the column falls back to the variable name");
        assert_eq!(truth.as_deref(), Some("{{ want }}"));
    }

    /// `FIT` and a pixel size answer the same question, so the form keeps one:
    /// picking `FIT` clears the sizes rather than emitting a spec the writers
    /// would have to arbitrate.
    #[test]
    fn fit_replaces_a_typed_size_rather_than_joining_it() {
        let mut c = crate::report::edit::ClauseForm::default();
        c.toggle_image();
        c.height = "96".into();
        let spec = c.image().expect("an image clause");
        assert_eq!((spec.height, spec.width, spec.fit), (Some(96), None, false));
        c.toggle_fit();
        let spec = c.image().expect("still an image clause");
        assert_eq!((spec.height, spec.width, spec.fit), (None, None, true));
        assert!(c.height.is_empty(), "the hidden size is cleared, not kept");
        // And turning the whole clause off leaves nothing behind.
        c.toggle_image();
        assert_eq!(c.image(), None);
    }

    /// The free-text row exists for variables the static scan cannot see, so it
    /// has to reach the node even with nothing ticked.
    #[test]
    fn a_typed_variable_is_reported_even_when_nothing_is_ticked() {
        let form = VarsForm {
            path: vec![0],
            vars: vec![("TIER".into(), false)],
            other: "  RUNTIME_ONLY ".into(),
            alias: String::new(),
            stats: Vec::new(),
            clauses: crate::report::edit::ClauseForm::default(),
        };
        assert!(
            matches!(form.node(), Some(FlowNode::Report(ReportStmt::Vars(ref v))) if v == &["RUNTIME_ONLY".to_string()]),
            "the typed name is trimmed and reported"
        );
    }

    #[test]
    fn ticking_a_baseline_field_writes_a_show_clause_on_the_baseline_role() {
        let form = compare_form(vec![
            ("Time".into(), true),
            ("Status".into(), false),
            ("Response".into(), true),
        ]);
        let Some(EnvClause::Roles {
            baseline,
            comparisons,
            baseline_show,
        }) = form.clause()
        else {
            panic!("a compare form describes a Roles clause")
        };
        assert_eq!(
            baseline,
            vec![RoleRef::Env("prod".into())],
            "the baseline role is unaffected by the SHOW"
        );
        assert_eq!(
            comparisons,
            vec![RoleRef::Env("staging".into())],
            "and so are the comparisons"
        );
        assert_eq!(
            baseline_show,
            vec!["Time".to_string(), "Response".to_string()],
            "the ticked fields become the SHOW list, in the checklist's own order"
        );
    }

    /// The checklist has no widget for a `STATISTICS(...)` clause, so it must
    /// carry one through untouched -- ticking a box in a form that never showed
    /// the clause must not silently delete it from the source.
    #[test]
    fn editing_the_baseline_checklist_keeps_a_show_field_s_statistics_clause() {
        let mut form = compare_form(vec![("Time".into(), true), ("Status".into(), true)]);
        form.show_stats.insert("Time".into(), vec![StatKind::Mean]);
        let Some(EnvClause::Roles { baseline_show, .. }) = form.clause() else {
            panic!("a compare form describes a Roles clause")
        };
        let time = baseline_show
            .iter()
            .find(|f| f.field == "Time")
            .expect("Time stays in the SHOW list");
        assert_eq!(
            time.stats,
            vec![StatKind::Mean],
            "its STATISTICS clause survives the round trip: {baseline_show:?}"
        );
    }

    #[test]
    fn ticking_nothing_leaves_the_baseline_with_no_show_clause_at_all() {
        // Unlike a request's SHOW, where empty means "emit everything", an
        // empty baseline SHOW means "carry nothing across" — so an untouched
        // checklist must serialise to no clause rather than to every field.
        let form = compare_form(vec![("Time".into(), false), ("Status".into(), false)]);
        let Some(EnvClause::Roles { baseline_show, .. }) = form.clause() else {
            panic!("a compare form describes a Roles clause")
        };
        assert!(
            baseline_show.is_empty(),
            "nothing ticked writes no SHOW: {baseline_show:?}"
        );
    }

    /// The request name field and the picker that fills it are one control in
    /// two halves, so they have to line up. A ComboBox sizes itself from
    /// `button_padding` and a TextEdit from its own margin, and a plain
    /// `horizontal` in a Grid cell reconciles neither the heights nor the tops
    /// — the dropdown sat low and hung below the field it belongs to.
    ///
    /// Measured off what `request_ui` actually paints, so the test fails if the
    /// row is rebuilt without the alignment rather than only if this exact
    /// layout is changed.
    #[test]
    fn the_request_name_field_and_its_picker_are_the_same_box() {
        use eframe::egui;
        let ctx = egui::Context::default();
        let spec = crate::theme::builtin_presets()[0].clone();
        let th = super::super::theme::GuiTheme::from_spec(&spec);
        th.apply(&ctx);
        let s = crate::i18n::Strings::for_language(&crate::i18n::Language::English);
        let mut f = param_form("upload", Vec::new());
        f.titles = vec!["upload".into(), "warmup".into()];

        fn rects_filled(shape: &egui::Shape, fill: egui::Color32, out: &mut Vec<egui::Rect>) {
            match shape {
                egui::Shape::Rect(r) if r.fill == fill => out.push(r.rect),
                egui::Shape::Vec(v) => {
                    for sh in v {
                        rects_filled(sh, fill, out);
                    }
                }
                _ => {}
            }
        }

        // Grid column widths settle from the previous pass, so run a few.
        let mut out = egui::FullOutput::default();
        for _ in 0..4 {
            out = ctx.run_ui(Default::default(), |ui| {
                request_ui(ui, &th, &s, &mut f);
            });
        }

        let mut fields = Vec::new();
        let mut buttons = Vec::new();
        let button_fill = ctx
            .style_of(egui::Theme::Dark)
            .visuals
            .widgets
            .inactive
            .bg_fill;
        for cs in &out.shapes {
            rects_filled(&cs.shape, th.field(), &mut fields);
            rects_filled(&cs.shape, button_fill, &mut buttons);
        }
        // The name row is the form's first, so both halves are the topmost of
        // their kind — chosen by position rather than by size, which the alias
        // field below shares.
        let topmost = |v: &[egui::Rect]| -> egui::Rect {
            v.iter()
                .copied()
                .min_by(|a, b| a.top().total_cmp(&b.top()))
                .expect("painted")
        };
        let field = topmost(&fields);
        let picker = topmost(&buttons);

        assert_eq!(
            (field.top(), field.bottom()),
            (picker.top(), picker.bottom()),
            "field {field:?} and picker {picker:?} must occupy the same band"
        );
    }

    /// A `RequestForm` whose bound collection declares `FILE` on `upload` and
    /// nothing on `warmup`.
    fn param_form(name: &str, using: Vec<UsingItem>) -> RequestForm {
        let params_by_request: std::collections::HashMap<String, Vec<(String, String)>> = [(
            "upload".to_string(),
            vec![("FILE".to_string(), "./x".to_string())],
        )]
        .into_iter()
        .collect();
        let params = crate::report::edit::param_rows(
            params_by_request
                .get(name)
                .map(Vec::as_slice)
                .unwrap_or(&[]),
            &using,
        );
        RequestForm {
            path: vec![0],
            name: name.to_string(),
            titles: vec!["upload".into(), "warmup".into()],
            report: true,
            response: None,
            alias: String::new(),
            fields: Vec::new(),
            show_stats: Default::default(),
            hide_fields: Vec::new(),
            with: Vec::new(),
            overrides: crate::report::edit::override_rows(&using),
            using,
            params,
            params_by_request,
        }
    }

    /// Ticking a parameter writes the requirement; the overrides the checklist
    /// has no row for come through untouched.
    #[test]
    fn the_gui_request_form_writes_ticked_parameters_and_keeps_overrides() {
        let carried = vec![UsingItem::Override {
            target: crate::report::flow::OverrideTarget::parse("header.X-Run").unwrap(),
            value: "1".into(),
        }];
        let mut f = param_form("upload", carried);
        assert_eq!(f.params.len(), 1, "the declared parameter is offered");
        assert!(!f.params[0].required, "and starts un-ticked");
        f.params[0].required = true;
        let FlowNode::Report(ReportStmt::Request { using, .. }) = f.to_node() else {
            panic!("a reported request node");
        };
        assert_eq!(
            using.iter().map(UsingItem::text).collect::<Vec<_>>(),
            vec!["FILE".to_string(), "header.X-Run = \"1\"".to_string()]
        );
    }

    /// The complaint that prompted the section being drawn unconditionally: a
    /// request that declares nothing showed no sign `USING` existed, and there
    /// was no way to add one outside the source view.
    #[test]
    fn the_using_section_is_offered_even_when_the_request_declares_nothing() {
        let mut f = param_form("warmup", Vec::new());
        assert!(f.params.is_empty(), "the precondition: nothing declared");

        let ctx = egui::Context::default();
        let th = super::super::theme::GuiTheme::from_spec(&crate::theme::default_preset());
        let s = crate::i18n::Strings::for_language(&crate::i18n::Language::English);
        let mut painted = Vec::new();
        let full = ctx.run_ui(
            egui::RawInput {
                screen_rect: Some(egui::Rect::from_min_size(
                    egui::pos2(0.0, 0.0),
                    egui::vec2(700.0, 700.0),
                )),
                ..Default::default()
            },
            |ui| request_ui(ui, &th, &s, &mut f),
        );
        fn texts(shape: &egui::Shape, out: &mut Vec<String>) {
            match shape {
                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
                _ => {}
            }
        }
        for cs in &full.shapes {
            texts(&cs.shape, &mut painted);
        }
        let all = painted.join("\n");
        assert!(
            all.contains(s.node_form_using),
            "the heading is there: {all}"
        );
        assert!(
            all.contains(s.node_form_using_none),
            "and it says why the list is empty, and where to fix it: {all}"
        );
        assert!(
            all.contains(s.node_form_override_add),
            "and an override can be added without leaving the dialog: {all}"
        );
    }

    /// An override typed into the form reaches the node.
    #[test]
    fn an_override_edited_in_the_form_is_written_to_the_node() {
        let mut f = param_form("warmup", Vec::new());
        f.overrides.push(crate::report::edit::OverrideRow {
            target: "multipart.document".into(),
            value: "{{FILE}}".into(),
        });
        let FlowNode::Report(ReportStmt::Request { using, .. }) = f.to_node() else {
            panic!("a reported request node");
        };
        assert_eq!(
            using.iter().map(UsingItem::text).collect::<Vec<_>>(),
            vec!["multipart.document = \"{{FILE}}\"".to_string()]
        );
    }

    /// Pointing the node at another request re-derives the checklist: the
    /// parameters belong to the request, not to the statement. The tick
    /// survives as an undeclared row, which is the error to see rather than a
    /// requirement that quietly disappeared.
    #[test]
    fn renaming_the_request_re_derives_the_parameter_checklist() {
        let mut f = param_form("upload", vec![UsingItem::Require("FILE".into())]);
        assert!(f.params[0].required && f.params[0].default.is_some());
        f.name = "warmup".into();
        f.refresh_params();
        assert_eq!(f.params.len(), 1);
        assert_eq!(f.params[0].name, "FILE");
        assert!(
            f.params[0].default.is_none(),
            "warmup declares nothing, so the requirement now reads as undeclared"
        );
        f.params[0].required = false;
        let FlowNode::Report(ReportStmt::Request { using, .. }) = f.to_node() else {
            panic!("a reported request node");
        };
        assert!(using.is_empty(), "un-ticking clears the clause");
    }

    #[test]
    fn a_show_field_no_request_offers_is_still_listed_so_editing_cannot_drop_it() {
        // Hand-written source may name a field the bound collection knows
        // nothing about (or there may be no collection bound at all). It has to
        // survive an open-and-apply round trip.
        let flow = crate::report::parser::parse_flow(
            "# collection: api.hurl\nFOR TARGET IN ENVS BASELINE(\"p\") SHOW(Handwritten), COMPARISON(\"s\")\n    REPORT REQUEST login\nEND\n",
        )
        .expect("the fixture flow parses");
        let FlowNode::ForEnvs { clause, body, .. } = &flow.nodes[0] else {
            panic!("the fixture's first node is the ENVS loop")
        };
        let EnvClause::Roles { baseline_show, .. } = clause else {
            panic!("the fixture's clause has roles")
        };
        // No collection bound, so nothing but the intrinsics is discoverable —
        // which is exactly the case where dropping the field would be easiest.
        let fields = crate::report::edit::baseline_show_choices(&[], body, baseline_show);
        assert!(
            fields.iter().any(|(n, on)| n == "Handwritten" && *on),
            "the unrecognised field is offered, and offered already ticked: {fields:?}"
        );
        assert!(
            fields.iter().any(|(n, _)| n == "Time"),
            "alongside the intrinsics every request has: {fields:?}"
        );
    }

    #[test]
    fn a_baseline_show_checklist_is_only_offered_for_reported_requests() {
        // `REQUEST x` sends but emits nothing, so it contributes no fields for
        // a baseline to carry across; only `REPORT REQUEST x` does.
        let nodes = vec![
            FlowNode::Request {
                name: "warmup".into(),
                using: Vec::new(),
            },
            FlowNode::Report(crate::report::flow::ReportStmt::Request {
                name: "login".into(),
                alias: None,
                using: Vec::new(),
                response_fmt: None,
                show: Vec::new(),
                hide: Vec::new(),
                with: Vec::new(),
            }),
        ];
        assert_eq!(
            crate::report::edit::reported_requests(&nodes),
            vec!["login".to_string()],
            "only the reported request is a source of fields"
        );
    }
}

/// Write back the folder the wizard's Browse dialog returned, frames later.
///
/// The wizard is still open behind the dialog -- it is drawn from `ed.wizard`
/// every frame -- so this writes straight into whichever form is showing, and
/// does nothing if the user closed or switched it in the meantime.
pub(super) fn apply_picked_dir(app: &mut GuiApp, picked: Option<std::path::PathBuf>) {
    let Some(dir) = picked else {
        return; // cancelled
    };
    let dir = dir.to_string_lossy().into_owned();
    match app.report_editor.as_mut().and_then(|e| e.wizard.as_mut()) {
        Some(Wizard::Files(f)) => f.dir = dir,
        Some(Wizard::Folders(f)) => f.dir = dir,
        _ => {}
    }
}