//! The Options window and the shared config editor used by both the
//! window and the Manage Index tab. Edits happen on a draft; Apply
//! validates, saves, and hands the new config to the app.

use crate::keychain;
use crate::tips::{self, tip_row, Tipped};
use quicksearch_core::config::Config;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Section {
    Indexing,
    Processing,
    Search,
}

/// A click in the Security block. Unlike the rest of the Options window
/// these are not draft edits: passwords are not config fields, and every
/// action here runs its own explicit flow (with a rebuild warning where
/// one is required) in the app.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SecurityAction {
    Enable,
    Disable,
    ChangePassword,
    SetKeychain(bool),
}

/// What one frame of the Options window produced.
#[derive(Default)]
pub struct OptionsOutput {
    /// "Apply & Save" was clicked with this draft.
    pub applied: Option<Config>,
    /// A Security block action was clicked.
    pub security: Option<SecurityAction>,
    /// The title-bar close was clicked while the draft holds unapplied
    /// edits. The window is held open; the app raises the unsaved-changes
    /// guard.
    pub close_requested: bool,
}

pub struct OptionsWindow {
    pub open: bool,
    draft: Option<Config>,
    /// Cached answer from [`OptionsWindow::keychain_active`], with the
    /// `use_keychain` preference it was probed under.
    keychain_probed_for: Option<bool>,
    keychain_active: bool,
    /// The search-shortcut button is waiting for a key press to bind.
    capturing_hotkey: bool,
}

impl OptionsWindow {
    pub fn new() -> OptionsWindow {
        OptionsWindow {
            open: false,
            draft: None,
            keychain_probed_for: None,
            keychain_active: false,
            capturing_hotkey: false,
        }
    }

    /// Whether the shortcut button is reading a key press right now, so the
    /// app can hold the shortcut it is about to replace. See
    /// [`crate::unlock::Gate::handle_hotkey`].
    pub fn capturing_hotkey(&self) -> bool {
        self.open && self.capturing_hotkey
    }

    pub fn open_with(&mut self, current: &Config) {
        self.open = true;
        self.draft = Some(current.clone());
        self.keychain_probed_for = None;
    }

    /// Whether the draft differs from the live config. The fields the app
    /// pins on apply (`security`, `indexing.auto_index`) are neutralized
    /// first — the Security block acts on the live config directly and must
    /// not make the window read as dirty.
    pub fn is_dirty(&self, current: &Config) -> bool {
        let Some(draft) = &self.draft else {
            return false;
        };
        let mut d = draft.clone();
        crate::app::pin_live_fields(&mut d, current);
        d != *current
    }

    /// The draft as it stands, for the app's unsaved-changes guard.
    pub fn draft_config(&self) -> Option<Config> {
        self.draft.clone()
    }

    /// Close and drop the draft (Discard, or a clean close).
    pub fn close_discard(&mut self) {
        self.open = false;
        self.draft = None;
        self.capturing_hotkey = false;
    }

    /// Adopt the window's open flag for this frame. A dirty close is
    /// intercepted: the window is held open and the caller is told to raise
    /// the unsaved-changes guard instead.
    fn intercept_close(&mut self, still_open: bool, current: &Config) -> bool {
        self.open = still_open;
        if self.open {
            return false;
        }
        if self.is_dirty(current) {
            self.open = true;
            true
        } else {
            self.draft = None;
            false
        }
    }

    /// True when this index's key really is in the OS keychain: the
    /// preference is on *and* the keychain answers with an entry (a dead
    /// daemon, a locked keyring or a denied prompt all read as "no", which
    /// is exactly when the startup prompt still appears). Probed when the
    /// window opens and whenever the preference changes — a keychain read
    /// is an IPC round trip, far too costly to repeat every frame.
    fn keychain_active(&mut self, current: &Config) -> bool {
        if self.keychain_probed_for != Some(current.security.use_keychain) {
            let db_path = current.resolved_database_path();
            self.keychain_active = current.security.use_keychain
                && matches!(keychain::load_key(&db_path.to_string_lossy()), Ok(Some(_)));
            self.keychain_probed_for = Some(current.security.use_keychain);
        }
        self.keychain_active
    }

    /// Render; reports an applied draft config and/or a security action.
    pub fn ui(&mut self, ctx: &egui::Context, current: &Config) -> OptionsOutput {
        if !self.open {
            self.draft = None;
            return OptionsOutput::default();
        }
        if self.draft.is_none() {
            self.draft = Some(current.clone());
        }
        let mut out = OptionsOutput::default();
        let mut open = self.open;
        let keychain_active = self.keychain_active(current);
        let dirty = self.is_dirty(current);
        let capturing = &mut self.capturing_hotkey;
        let draft = self.draft.as_mut().unwrap();

        egui::Window::new("Options")
            .open(&mut open)
            .resizable(false)
            .default_width(420.0)
            .show(ctx, |ui| {
                let scroll = egui::ScrollArea::vertical()
                    .max_height(480.0)
                    .show(ui, |ui| {
                        ui.heading(egui::RichText::new("Paths").strong());
                        egui::Grid::new("opt-paths").num_columns(2).show(ui, |ui| {
                            tip_row(ui, "Database file", &tips::DATABASE_PATH, |ui| {
                                ui.add(
                                    egui::TextEdit::singleline(&mut draft.paths.database_path)
                                        .desired_width(260.0),
                                )
                            });
                        });
                        ui.label(
                            egui::RichText::new(
                                "Indexed folders are managed on the Manage Index tab.",
                            )
                            .small()
                            .weak(),
                        );
                        ui.separator();

                        ui.heading(egui::RichText::new("Indexing").strong());
                        config_editor_ui(ui, draft, Section::Indexing);
                        ui.label(
                            egui::RichText::new(
                                "Automatic and manual indexing are switched on the \
                             Manage Index tab.",
                            )
                            .small()
                            .weak(),
                        );
                        ui.separator();

                        ui.heading(egui::RichText::new("Processing").strong());
                        config_editor_ui(ui, draft, Section::Processing);
                        ui.separator();

                        ui.heading(egui::RichText::new("Search").strong());
                        config_editor_ui(ui, draft, Section::Search);
                        ui.separator();

                        ui.heading(egui::RichText::new("Interface").strong());
                        egui::Grid::new("opt-ui").num_columns(2).show(ui, |ui| {
                            tip_row(ui, "UI scale", &tips::UI_SCALE, |ui| {
                                ui.add(
                                    egui::Slider::new(&mut draft.ui.scale, 0.5..=2.5)
                                        .step_by(0.05)
                                        .fixed_decimals(2),
                                )
                            });
                            tip_row(ui, "Search shortcut", &tips::SEARCH_HOTKEY, |ui| {
                                hotkey_edit(ui, &mut draft.ui.search_hotkey, capturing)
                            });
                            tip_row(ui, "Color scheme", &tips::COLOR_SCHEME, |ui| {
                                color_scheme_edit(ui, &mut draft.ui.color_scheme)
                            });
                        });
                        hotkey_note(ui, &draft.ui.search_hotkey, &current.ui.search_hotkey);
                        ui.separator();

                        // Security acts on the live config, not the draft: each
                        // action opens its own confirmation flow immediately.
                        // The KDF salt is deliberately never shown here (or
                        // anywhere else in the GUI).
                        ui.heading(egui::RichText::new("Security").strong());
                        out.security = security_ui(ui, current, keychain_active);
                    });
                crate::ui_util::more_below_hint(ui, &scroll);

                ui.separator();
                let p = crate::color::palette(ui.visuals().dark_mode);
                ui.horizontal(|ui| {
                    let apply = ui
                        .add(crate::ui_util::bordered_button(
                            "Apply & Save",
                            if dirty { p.orange } else { p.blue },
                        ))
                        .tip(&tips::APPLY_SAVE);
                    if apply.clicked() {
                        out.applied = Some(draft.clone());
                    }
                    // Comes and goes with the dirty state; keep it off the
                    // ids of the hint that follows.
                    crate::ui_util::stable_section(ui, |ui| {
                        if dirty {
                            ui.label(
                                egui::RichText::new("Unsaved changes")
                                    .small()
                                    .color(p.orange),
                            );
                        }
                    });
                });
                ui.label(
                    egui::RichText::new(
                        "Narrowing a filter removes the entries it excludes; widening \
                         one reindexes to find what it now allows. Only the tokenizer \
                         and hash length require a full rebuild.",
                    )
                    .small()
                    .weak(),
                );
            });

        out.close_requested = self.intercept_close(open, current);
        out
    }
}

/// The color schemes, as stored and as shown. Stored lowercase so a
/// hand-edited config reads like the rest of the file.
const COLOR_SCHEMES: [(&str, &str); 2] = [("dark", "Dark"), ("light", "Light")];

/// What the dropdown shows for a stored value.
///
/// Resolved through [`crate::app::theme_for`] rather than by looking the string
/// up, so the box says what the app will actually do with whatever is in the
/// config file — including a value it does not recognise, which is dark and
/// should read that way.
fn scheme_label(value: &str) -> &'static str {
    match crate::app::theme_for(value) {
        egui::Theme::Dark => "Dark",
        egui::Theme::Light => "Light",
    }
}

/// The color scheme dropdown. Returns the box, which is what the row's
/// tooltip hangs off.
fn color_scheme_edit(ui: &mut egui::Ui, setting: &mut String) -> egui::Response {
    egui::ComboBox::from_id_salt("cfg-color-scheme")
        .selected_text(scheme_label(setting))
        .show_ui(ui, |ui| {
            for (stored, label) in COLOR_SCHEMES {
                ui.selectable_value(setting, stored.to_string(), label);
            }
        })
        .response
}

/// The search shortcut's control: a button showing the current binding that
/// turns into a key-press reader when clicked, and a Clear beside it.
///
/// A reader rather than a text field because the shortcut is a thing you
/// press, not a thing you spell, and because it keeps the only way to name a
/// key inside [`crate::hotkey`] where the two backends agree on it.
///
/// Returns the button, which is what the row's tooltip hangs off.
fn hotkey_edit(ui: &mut egui::Ui, setting: &mut String, capturing: &mut bool) -> egui::Response {
    let p = crate::color::palette(ui.visuals().dark_mode);
    ui.horizontal(|ui| {
        let label = if *capturing {
            "Press a key combination...".to_string()
        } else if setting.trim().is_empty() {
            "None".to_string()
        } else {
            setting.clone()
        };
        let button = ui.add(crate::ui_util::bordered_button(
            label,
            if *capturing { p.orange } else { p.blue },
        ));
        // A second click backs out, so the button is never a one-way door.
        if button.clicked() {
            *capturing = !*capturing;
        } else if *capturing {
            match read_capture(ui) {
                Some(Some(binding)) => {
                    *setting = binding.to_string();
                    *capturing = false;
                }
                Some(None) => *capturing = false,
                None => {}
            }
        }
        if ui
            .add_enabled(
                !setting.trim().is_empty(),
                egui::Button::new("Clear").small(),
            )
            .clicked()
        {
            setting.clear();
            *capturing = false;
        }
        button
    })
    .inner
}

/// One frame of shortcut capture: `Some(Some(binding))` for a press worth
/// binding, `Some(None)` for a cancel, `None` while nothing usable has
/// arrived.
///
/// Reads raw events rather than `egui::Ui::input_mut`'s shortcut matching,
/// which answers "was *this* combination pressed" and cannot report an
/// arbitrary one. Presses that are not a valid shortcut, such as a bare
/// letter, are ignored rather than treated as a cancel: they are almost
/// always someone reaching for the modifier a moment too late.
fn read_capture(ui: &egui::Ui) -> Option<Option<crate::hotkey::Binding>> {
    ui.input(|i| {
        for event in &i.events {
            let egui::Event::Key {
                key,
                pressed: true,
                modifiers,
                ..
            } = event
            else {
                continue;
            };
            if *key == egui::Key::Escape {
                return Some(None);
            }
            if let Some(binding) = crate::hotkey::Binding::from_egui(*key, modifiers) {
                return Some(Some(binding));
            }
        }
        None
    })
}

/// What the shortcut is really doing, under the Interface grid.
///
/// Silent while it is registered and working: the button already says what
/// the key is, and a line confirming it would be noise on every other
/// setting's behalf. The cases worth a line are the ones where what is on
/// the button is not what is in force.
fn hotkey_note(ui: &mut egui::Ui, draft: &str, live: &str) {
    use crate::hotkey::Status;
    let (text, color) = if draft.trim() != live.trim() {
        ("Not registered until Apply and Save.".to_string(), None)
    } else {
        match crate::hotkey::status() {
            Status::Disabled | Status::Active => (String::new(), None),
            Status::Pending => (
                "Waiting for your desktop to accept the shortcut.".to_string(),
                None,
            ),
            Status::PortalBound(trigger) => (
                format!(
                    "Your desktop registered this as {}. It has the final say; \
                     change it in its own keyboard settings. On Wayland it also \
                     decides whether the window comes forward, so a minimised \
                     window may stay minimised.",
                    trigger
                ),
                None,
            ),
            Status::Error(why) => (
                format!("The shortcut is not active: {}.", why),
                Some(crate::color::palette(ui.visuals().dark_mode).orange),
            ),
        }
    };
    // Comes and goes with the state; keep it off the ids of what follows.
    crate::ui_util::stable_section(ui, |ui| {
        if text.is_empty() {
            return;
        }
        let rich = egui::RichText::new(text).small();
        ui.label(match color {
            Some(color) => rich.color(color),
            None => rich.weak(),
        });
    });
}

/// The Security block: status plus action buttons. Never renders the salt.
fn security_ui(
    ui: &mut egui::Ui,
    current: &Config,
    keychain_active: bool,
) -> Option<SecurityAction> {
    let mut action = None;
    if current.security.password_protected {
        if keychain_active {
            ui.label(
                "The index is encrypted; its password is securely stored by \
                 your Operating System.",
            );
        } else {
            ui.label("The index is encrypted; a password is required at startup.");
        }
        ui.horizontal(|ui| {
            if ui
                .button("Change password…")
                .tip(&tips::CHANGE_PASSWORD)
                .clicked()
            {
                action = Some(SecurityAction::ChangePassword);
            }
            if ui
                .button("Disable protection…")
                .tip(&tips::DISABLE_PASSWORD)
                .clicked()
            {
                action = Some(SecurityAction::Disable);
            }
        });
        let mut remember = current.security.use_keychain;
        if ui
            .checkbox(&mut remember, "Remember on this device")
            .tip(&tips::REMEMBER_KEYCHAIN)
            .changed()
        {
            action = Some(SecurityAction::SetKeychain(remember));
        }
    } else {
        ui.label("The index is not encrypted.");
        if ui
            .button("Enable password protection…")
            .tip(&tips::ENABLE_PASSWORD)
            .clicked()
        {
            action = Some(SecurityAction::Enable);
        }
        ui.label(
            egui::RichText::new(
                "The index stores the names and text of your files. A password \
                 encrypts it on disk; enabling one rebuilds the index.",
            )
            .small()
            .weak(),
        );
    }
    action
}

/// The per-section config controls of the Options window.
///
/// Every row goes through [`crate::tips::tip_row`], which takes the tooltip
/// that explains it: a setting cannot arrive here without one, and hovering
/// the name works as well as hovering the control.
pub fn config_editor_ui(ui: &mut egui::Ui, config: &mut Config, section: Section) {
    match section {
        Section::Indexing => {
            egui::Grid::new("cfg-indexing")
                .num_columns(2)
                .show(ui, |ui| {
                    // Automatic vs manual is deliberately absent: it is live
                    // state, switched (and saved) by the Stop / Return to
                    // Automatic buttons on the Manage Index tab. A staged copy
                    // of it here would fight those buttons.
                    tip_row(ui, "Full reindex every", &tips::REINDEX_INTERVAL, |ui| {
                        ui.horizontal(|ui| {
                            ui.add(
                                egui::DragValue::new(&mut config.indexing.reindex_interval_minutes)
                                    .range(5..=60 * 24 * 30),
                            );
                            ui.label("minutes");
                        })
                        .response
                    });

                    tip_row(ui, "Follow symlinks", &tips::FOLLOW_SYMLINKS, |ui| {
                        ui.checkbox(&mut config.indexing.follow_symlinks, "")
                    });

                    tip_row(ui, "Include hidden files", &tips::INCLUDE_HIDDEN, |ui| {
                        ui.checkbox(&mut config.indexing.include_hidden, "")
                    });
                });
        }
        Section::Processing => {
            egui::Grid::new("cfg-processing")
                .num_columns(2)
                .show(ui, |ui| {
                    tip_row(ui, "Tokenizer", &tips::TOKENIZER, |ui| {
                        egui::ComboBox::from_id_salt("cfg-tokenize")
                            .selected_text(&config.processing.tokenize)
                            .show_ui(ui, |ui| {
                                for opt in ["trigram", "unicode61", "porter"] {
                                    ui.selectable_value(
                                        &mut config.processing.tokenize,
                                        opt.to_string(),
                                        opt,
                                    );
                                }
                            })
                            .response
                    });

                    ui.label("");
                    ui.hyperlink_to(
                        "Tokenizer documentation",
                        "https://www.sqlite.org/fts5.html#tokenizers",
                    );
                    ui.end_row();

                    tip_row(ui, "Hash sample size (bytes)", &tips::HASH_LENGTH, |ui| {
                        ui.add(
                            egui::DragValue::new(&mut config.processing.hash_length)
                                .range(512..=1_048_576),
                        )
                    });

                    tip_row(
                        ui,
                        "Max stored text (bytes)",
                        &tips::MAX_STORED_TEXT,
                        |ui| {
                            ui.add(
                                egui::DragValue::new(&mut config.processing.maximum_text_size)
                                    .range(1024..=16_777_216),
                            )
                        },
                    );

                    tip_row(
                        ui,
                        "Max text file size (bytes)",
                        &tips::MAX_TEXT_FILE_SIZE,
                        |ui| {
                            ui.add(
                                egui::DragValue::new(&mut config.processing.maximum_text_file_size)
                                    .range(1024..=1_073_741_824),
                            )
                        },
                    );

                    tip_row(ui, "Batch size", &tips::BATCH_SIZE, |ui| {
                        ui.add(
                            egui::DragValue::new(&mut config.processing.batch_size)
                                .range(10..=100_000),
                        )
                    });

                    tip_row(ui, "Max WAL size (bytes)", &tips::MAX_WAL_SIZE, |ui| {
                        ui.add(
                            egui::DragValue::new(&mut config.processing.maximum_wal_size)
                                .range(0u64..=8_589_934_592u64),
                        )
                    });

                    tip_row(ui, "Store text for snippets", &tips::STORE_TEXT, |ui| {
                        ui.checkbox(&mut config.processing.store_text_for_snippets, "")
                    });
                });
        }
        Section::Search => {
            egui::Grid::new("cfg-search").num_columns(2).show(ui, |ui| {
                tip_row(
                    ui,
                    "Fuzzy search ON by default",
                    &tips::FUZZY_DEFAULT,
                    |ui| ui.checkbox(&mut config.search.fuzzy_default, ""),
                );

                tip_row(ui, "Fuzzy edit distance", &tips::FUZZY_EDITS, |ui| {
                    ui.add(egui::DragValue::new(&mut config.search.fuzzy_max_edits).range(0..=8))
                });

                tip_row(ui, "Display limit", &tips::DISPLAY_LIMIT, |ui| {
                    ui.add(
                        egui::DragValue::new(&mut config.search.display_limit).range(50..=100_000),
                    )
                });

                tip_row(ui, "Stream batch size", &tips::RESULTS_PER_PAGE, |ui| {
                    ui.add(
                        egui::DragValue::new(&mut config.search.results_per_page)
                            .range(10..=10_000),
                    )
                });

                tip_row(ui, "Debounce (ms)", &tips::DEBOUNCE, |ui| {
                    ui.add(egui::DragValue::new(&mut config.search.debounce_ms).range(0..=2000))
                });
            });
            // A warning that comes and goes as the value is edited would
            // otherwise move every widget below it in the window; see
            // `ui_util::stable_section`.
            crate::ui_util::stable_section(ui, |ui| {
                if let Some(warning) = config.search.fuzzy_edits_warning() {
                    ui.colored_label(ui.visuals().warn_fg_color, warning);
                }
            });
        }
    }
}

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

    // All headless-safe: `keychain_active` only probes the OS keychain when
    // `use_keychain` is set, and no test here sets it.

    #[test]
    fn a_fresh_draft_is_not_dirty() {
        let mut w = OptionsWindow::new();
        let cfg = Config::default();
        assert!(!w.is_dirty(&cfg), "no draft at all");
        w.open_with(&cfg);
        assert!(!w.is_dirty(&cfg));
    }

    #[test]
    fn an_edited_draft_is_dirty_until_discarded() {
        let mut w = OptionsWindow::new();
        let cfg = Config::default();
        w.open_with(&cfg);
        w.draft.as_mut().unwrap().search.debounce_ms += 100;
        assert!(w.is_dirty(&cfg));
        w.close_discard();
        assert!(!w.open);
        assert!(!w.is_dirty(&cfg), "the draft is gone");
    }

    /// The Security block and the mode buttons act on the live config while
    /// the window sits open; the stale copies in the draft are not edits.
    #[test]
    fn live_security_and_mode_changes_are_not_dirty() {
        let mut w = OptionsWindow::new();
        let mut cfg = Config::default();
        w.open_with(&cfg);
        cfg.security.use_keychain = !cfg.security.use_keychain;
        cfg.indexing.auto_index = !cfg.indexing.auto_index;
        assert!(!w.is_dirty(&cfg));
    }

    #[test]
    fn a_dirty_close_is_held_and_a_clean_one_drops_the_draft() {
        let mut w = OptionsWindow::new();
        let cfg = Config::default();
        w.open_with(&cfg);
        w.draft.as_mut().unwrap().search.debounce_ms += 100;

        assert!(
            w.intercept_close(false, &cfg),
            "dirty close raises the guard"
        );
        assert!(w.open, "the window is held open until the user decides");
        assert!(w.draft.is_some(), "the draft survives");

        assert!(!w.intercept_close(true, &cfg), "still open: nothing to do");

        w.draft = Some(cfg.clone());
        assert!(!w.intercept_close(false, &cfg), "a clean close just closes");
        assert!(!w.open);
        assert!(w.draft.is_none());
    }

    use crate::test_ui::{click_at, painted_text, painted_text_center};

    /// One frame of the shortcut control on its own, outside the window's
    /// scroll area so it is never below the fold. A free function rather
    /// than a closure because the assertions between frames need the
    /// borrows back.
    fn run_hotkey_edit(
        ctx: &egui::Context,
        setting: &mut String,
        capturing: &mut bool,
        events: Vec<egui::Event>,
    ) -> egui::FullOutput {
        let input = crate::test_ui::raw_input(egui::vec2(600.0, 200.0), events);
        ctx.run(input, |ctx| {
            egui::CentralPanel::default().show(ctx, |ui| {
                hotkey_edit(ui, setting, capturing);
            });
        })
    }

    /// One frame of the color scheme control on its own, for the same reason
    /// as [`run_hotkey_edit`].
    fn run_color_scheme_edit(
        ctx: &egui::Context,
        setting: &mut String,
        events: Vec<egui::Event>,
    ) -> egui::FullOutput {
        let input = crate::test_ui::raw_input(egui::vec2(600.0, 200.0), events);
        ctx.run(input, |ctx| {
            egui::CentralPanel::default().show(ctx, |ui| {
                color_scheme_edit(ui, setting);
            });
        })
    }

    /// The dropdown says which scheme is in force and writes the one that is
    /// picked. The stored values are lowercase, so what it shows and what it
    /// stores are deliberately not the same string.
    #[test]
    fn the_color_scheme_box_shows_and_sets_the_scheme() {
        let ctx = egui::Context::default();
        let mut setting = "dark".to_string();

        let closed = run_color_scheme_edit(&ctx, &mut setting, vec![]);
        let target =
            painted_text_center(&closed, "Dark").expect("the current scheme was not painted");

        run_color_scheme_edit(&ctx, &mut setting, click_at(target));
        let open = run_color_scheme_edit(&ctx, &mut setting, vec![]);
        let light = painted_text_center(&open, "Light").expect("the list did not open");

        run_color_scheme_edit(&ctx, &mut setting, click_at(light));
        assert_eq!(setting, "light", "picking Light stores the config value");

        let after = run_color_scheme_edit(&ctx, &mut setting, vec![]);
        assert!(
            painted_text(&after).iter().any(|t| t == "Light"),
            "the closed box still says what is in force: {:?}",
            painted_text(&after)
        );
    }

    /// A hand-edited config can hold anything. The box reports what the app
    /// will actually do with it rather than echoing it back.
    #[test]
    fn an_unknown_scheme_reads_as_dark() {
        assert_eq!(scheme_label("dark"), "Dark");
        assert_eq!(scheme_label("light"), "Light");
        // Written the way a person would, and still honoured, so the box has
        // to agree with what the theme module makes of it.
        assert_eq!(scheme_label("  LIGHT "), "Light");
        for nonsense in ["", "drak", "system", "auto"] {
            assert_eq!(scheme_label(nonsense), "Dark", "{:?}", nonsense);
        }
    }

    fn press(key: egui::Key, modifiers: egui::Modifiers) -> Vec<egui::Event> {
        vec![egui::Event::Key {
            key,
            physical_key: None,
            pressed: true,
            repeat: false,
            modifiers,
        }]
    }

    const CTRL_ALT: egui::Modifiers = egui::Modifiers {
        alt: true,
        ctrl: true,
        shift: false,
        mac_cmd: false,
        command: true,
    };

    /// The whole point of the control: click it, press the combination, and
    /// the setting is what was pressed. Never spelled out by hand.
    #[test]
    fn the_shortcut_button_binds_what_was_pressed() {
        let ctx = egui::Context::default();
        let mut setting = "Ctrl+Shift+F".to_string();
        let mut capturing = false;

        let first = run_hotkey_edit(&ctx, &mut setting, &mut capturing, vec![]);
        let button = painted_text_center(&first, "Ctrl+Shift+F")
            .expect("the current shortcut was not painted");

        run_hotkey_edit(&ctx, &mut setting, &mut capturing, click_at(button));
        assert!(capturing, "clicking the button starts a capture");
        let waiting = run_hotkey_edit(&ctx, &mut setting, &mut capturing, vec![]);
        assert!(
            painted_text(&waiting)
                .iter()
                .any(|t| t.starts_with("Press a key")),
            "a capturing button says so"
        );

        run_hotkey_edit(
            &ctx,
            &mut setting,
            &mut capturing,
            press(egui::Key::G, CTRL_ALT),
        );
        assert_eq!(setting, "Ctrl+Alt+G");
        assert!(!capturing, "a bound press ends the capture");
    }

    /// Escape backs out, and a press that could not be a shortcut is waited
    /// through rather than treated as one.
    #[test]
    fn capture_ignores_what_it_cannot_bind_and_escape_cancels() {
        let ctx = egui::Context::default();
        let mut setting = "Ctrl+Shift+F".to_string();
        let mut capturing = true;

        // A bare letter: someone reaching for the modifier a moment late.
        run_hotkey_edit(
            &ctx,
            &mut setting,
            &mut capturing,
            press(egui::Key::G, egui::Modifiers::NONE),
        );
        assert_eq!(setting, "Ctrl+Shift+F", "a bare key binds nothing");
        assert!(capturing, "and does not end the capture");

        run_hotkey_edit(
            &ctx,
            &mut setting,
            &mut capturing,
            press(egui::Key::Escape, egui::Modifiers::NONE),
        );
        assert_eq!(setting, "Ctrl+Shift+F", "Escape leaves the shortcut alone");
        assert!(!capturing);
    }

    #[test]
    fn clear_switches_the_shortcut_off() {
        let ctx = egui::Context::default();
        let mut setting = "Ctrl+Shift+F".to_string();
        let mut capturing = false;

        let first = run_hotkey_edit(&ctx, &mut setting, &mut capturing, vec![]);
        let clear = painted_text_center(&first, "Clear").expect("Clear was not painted");
        run_hotkey_edit(&ctx, &mut setting, &mut capturing, click_at(clear));
        assert_eq!(setting, "");

        // With no shortcut set there is nothing to clear, and the button
        // says what the state is rather than going blank.
        let empty = run_hotkey_edit(&ctx, &mut setting, &mut capturing, vec![]);
        assert!(painted_text(&empty).iter().any(|t| t == "None"));
    }

    /// The draft is what the button shows, but the registration is what the
    /// app is actually holding, and until Apply they can disagree.
    #[test]
    fn an_unapplied_shortcut_says_it_is_not_in_force_yet() {
        let ctx = egui::Context::default();
        let run = |draft: &str, live: &str| {
            let input = crate::test_ui::raw_input(egui::vec2(600.0, 200.0), vec![]);
            let out = ctx.run(input, |ctx| {
                egui::CentralPanel::default().show(ctx, |ui| hotkey_note(ui, draft, live));
            });
            painted_text(&out).join("\n")
        };
        assert!(run("Ctrl+Alt+K", "Ctrl+Shift+F").contains("Apply and Save"));
        // Matching, and nothing registered in a test process: nothing to say.
        assert_eq!(run("Ctrl+Shift+F", "Ctrl+Shift+F"), "");
    }

    /// Every row of every section, with the tip it must show. `tip_row`
    /// makes a row without *a* tooltip impossible; this table is what makes
    /// a row with the *wrong* one impossible.
    const ROWS: &[(Section, &str, &tips::Tip)] = &[
        (
            Section::Indexing,
            "Full reindex every",
            &tips::REINDEX_INTERVAL,
        ),
        (Section::Indexing, "Follow symlinks", &tips::FOLLOW_SYMLINKS),
        (
            Section::Indexing,
            "Include hidden files",
            &tips::INCLUDE_HIDDEN,
        ),
        (Section::Processing, "Tokenizer", &tips::TOKENIZER),
        (
            Section::Processing,
            "Hash sample size (bytes)",
            &tips::HASH_LENGTH,
        ),
        (
            Section::Processing,
            "Max stored text (bytes)",
            &tips::MAX_STORED_TEXT,
        ),
        (
            Section::Processing,
            "Max text file size (bytes)",
            &tips::MAX_TEXT_FILE_SIZE,
        ),
        (Section::Processing, "Batch size", &tips::BATCH_SIZE),
        (
            Section::Processing,
            "Max WAL size (bytes)",
            &tips::MAX_WAL_SIZE,
        ),
        (
            Section::Processing,
            "Store text for snippets",
            &tips::STORE_TEXT,
        ),
        (
            Section::Search,
            "Fuzzy search ON by default",
            &tips::FUZZY_DEFAULT,
        ),
        (Section::Search, "Fuzzy edit distance", &tips::FUZZY_EDITS),
        (Section::Search, "Display limit", &tips::DISPLAY_LIMIT),
        (
            Section::Search,
            "Stream batch size",
            &tips::RESULTS_PER_PAGE,
        ),
        (Section::Search, "Debounce (ms)", &tips::DEBOUNCE),
    ];

    /// Hovering a row's name paints that row's own explanation. Rendered
    /// without the window's scroll area so nothing sits below the fold.
    #[test]
    fn every_row_shows_its_own_tip() {
        for (section, label, tip) in ROWS {
            let ctx = egui::Context::default();
            ctx.style_mut(|s| {
                s.interaction.tooltip_delay = 0.0;
                s.interaction.show_tooltips_only_when_still = false;
            });
            let mut cfg = Config::default();
            let mut run = |events: Vec<egui::Event>| {
                let input = crate::test_ui::raw_input(egui::vec2(600.0, 800.0), events);
                ctx.run(input, |ctx| {
                    egui::CentralPanel::default()
                        .show(ctx, |ui| config_editor_ui(ui, &mut cfg, *section));
                })
            };

            let first = run(vec![]);
            let pos = painted_text_center(&first, label)
                .unwrap_or_else(|| panic!("{label} was not painted"));

            // Enough of the body to be unique, and short enough to survive
            // an edit to the sentence it starts.
            let opening: String = tip.body.chars().take(40).collect();
            let mut out = run(vec![egui::Event::PointerMoved(pos)]);
            let mut found = false;
            for _ in 0..3 {
                // The tooltip is an area of its own, so it can land a frame
                // late.
                if painted_text(&out).join("\n").contains(&opening) {
                    found = true;
                    break;
                }
                out = run(vec![]);
            }
            assert!(found, "hovering {label:?} did not show {:?}", tip.title);
        }
    }

    /// Hovering a setting's *name* explains it, not just its control: the
    /// label is the larger target and the one a reader's eye is already on.
    /// Checks the wiring, so the tooltip timing is turned off.
    #[test]
    fn hovering_a_setting_label_explains_it() {
        let ctx = egui::Context::default();
        ctx.style_mut(|s| {
            s.interaction.tooltip_delay = 0.0;
            s.interaction.show_tooltips_only_when_still = false;
        });
        let cfg = Config::default();
        let mut w = OptionsWindow::new();
        w.open_with(&cfg);

        let run = |w: &mut OptionsWindow, events: Vec<egui::Event>| {
            let input = crate::test_ui::raw_input(egui::vec2(1000.0, 900.0), events);
            ctx.run(input, |ctx| {
                w.ui(ctx, &cfg);
            })
        };

        // The window spends its first frames sizing itself and painting
        // nothing; run until the label is on screen.
        let mut target = None;
        for _ in 0..5 {
            let full = run(&mut w, vec![]);
            target = painted_text_center(&full, "Tokenizer");
            if target.is_some() {
                break;
            }
        }
        let target = target.expect("the Tokenizer label was not painted");

        // The tooltip is an area of its own, so it can land a frame late.
        let mut out = run(&mut w, vec![egui::Event::PointerMoved(target)]);
        for _ in 0..3 {
            let painted = painted_text(&out).join("\n");
            if painted.contains(crate::tips::TOKENIZER.title)
                && painted.contains("cut up so that it can be")
            {
                return;
            }
            out = run(&mut w, vec![]);
        }
        panic!("no tooltip appeared over the Tokenizer label");
    }

    /// One real frame of the window in a headless context: it renders, and
    /// the Apply & Save click comes back out as `applied`.
    #[test]
    fn the_window_renders_and_apply_reports_the_draft() {
        let ctx = egui::Context::default();
        let cfg = Config::default();
        let mut w = OptionsWindow::new();
        w.open_with(&cfg);
        w.draft.as_mut().unwrap().search.debounce_ms += 100;

        let run = |w: &mut OptionsWindow, events: Vec<egui::Event>| {
            let input = crate::test_ui::raw_input(egui::vec2(1000.0, 900.0), events);
            let mut out = OptionsOutput::default();
            let full = ctx.run(input, |ctx| out = w.ui(ctx, &cfg));
            (out, full)
        };

        // A new egui window spends its first frames in sizing passes that
        // suppress painting; run untouched frames until the settled button
        // is actually on screen.
        let mut target = None;
        for _ in 0..5 {
            let (untouched, full) = run(&mut w, vec![]);
            assert!(untouched.applied.is_none());
            assert!(!untouched.close_requested);
            target = painted_text_center(&full, "Apply & Save");
            if target.is_some() {
                break;
            }
        }
        let target = target.expect("the Apply & Save button was not painted");
        let clicks = [true, false]
            .into_iter()
            .map(|pressed| egui::Event::PointerButton {
                pos: target,
                button: egui::PointerButton::Primary,
                pressed,
                modifiers: egui::Modifiers::default(),
            })
            .collect();
        let (clicked, _) = run(&mut w, clicks);
        let applied = clicked.applied.expect("the click did not report a config");
        assert_eq!(
            applied.search.debounce_ms,
            Config::default().search.debounce_ms + 100,
            "the click reported the edited draft"
        );
    }
}