zippa-db 0.1.1

//! The welcome screen: a launcher for saved connections.
//!
//! The form that used to sit beside the list is now a dialog
//! ([`ConnectionEditor`]), opened from here. The screen itself is launcher-first:
//! saved connections are cards the user clicks to connect, searchable and
//! ordered most-recently-connected first, with an editor behind "New
//! connection" (and each card's `…` menu).

use std::cmp::Ordering;
use std::sync::Arc;

use chrono::Utc;
use gpui_kit::component::button::{Button, ButtonVariant, ButtonVariants};
use gpui_kit::component::dialog::DialogButtonProps;
use gpui_kit::component::input::{Input, InputEvent, InputState};
use gpui_kit::component::scroll::ScrollableElement;
use gpui_kit::component::{ActiveTheme, WindowExt, h_flex, v_flex};
use gpui_kit::prelude::*;
use gpui_kit::{App, Context, Entity, EventEmitter, FocusHandle, Global, Window, div, px};
use uuid::Uuid;

use crate::app::NewConnection;
use crate::db::store::SecretEdits;
use crate::db::{Connection, ConnectionConfig, Credentials, Engine, runtime, store};
use crate::ui::{notify_error, sql_file};

mod card;
mod editor;

use card::render_card;
use editor::{ConnectionEditor, EditorEvent};
pub(crate) use editor::{EditorClose, EditorConnect};

/// Width of the editor dialog: enough for the form, not a full window.
const EDITOR_WIDTH: f32 = 560.;

pub enum WelcomeEvent {
    /// A connection was opened and the session can start.
    Connected(Arc<Connection>),
}

/// The saved connections, one copy for the whole app.
///
/// Every launcher tab reads and changes this one list rather than a copy of
/// its own: each change writes the whole list, so a launcher holding a list
/// read before another tab added or edited a connection would put the old
/// list back on disk and lose that change.
pub(crate) struct SavedConnections {
    list: Vec<ConnectionConfig>,
    /// Why the file could not be read at startup, for the first launcher.
    load_error: Option<String>,
}

impl Global for SavedConnections {}

impl SavedConnections {
    /// The list, read from disk the first time anything asks.
    pub(crate) fn get(cx: &mut App) -> &[ConnectionConfig] {
        if !cx.has_global::<Self>() {
            let (list, load_error) = match store::load() {
                Ok(list) => (list, None),
                Err(error) => (Vec::new(), Some(format!("{error:#}"))),
            };
            cx.set_global(Self { list, load_error });
        }
        &cx.global::<Self>().list
    }

    /// The list without loading it: empty before anything has.
    fn read(cx: &App) -> &[ConnectionConfig] {
        cx.try_global::<Self>()
            .map(|saved| saved.list.as_slice())
            .unwrap_or_default()
    }
}

pub struct Welcome {
    /// Search text over the saved list.
    query: Entity<InputState>,
    /// The connection being connected to, if any.
    connecting: Option<Uuid>,
    /// An error to show in the banner at the top of the screen.
    error: Option<String>,
    /// The editor dialog open over the screen, if any.
    editor: Option<Entity<ConnectionEditor>>,
    /// Held by the launcher itself, so its own key context answers even when
    /// the screen has no search box to focus.
    focus: FocusHandle,
}

impl EventEmitter<WelcomeEvent> for Welcome {}

impl Welcome {
    pub fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
        SavedConnections::get(cx);
        // Shown once, by the first launcher: the file has been moved aside, so
        // the next one has nothing more to say about it.
        let error = cx.global_mut::<SavedConnections>().load_error.take();
        // Another tab's change to the list is this one's to show.
        cx.observe_global::<SavedConnections>(|_, cx| cx.notify())
            .detach();

        let query = cx.new(|cx| InputState::new(window, cx).placeholder("Search connections"));
        cx.subscribe_in(&query, window, Self::on_search_event)
            .detach();

        Self {
            query,
            connecting: None,
            error,
            editor: None,
            focus: cx.focus_handle(),
        }
    }

    fn on_search_event(
        &mut self,
        _query: &Entity<InputState>,
        event: &InputEvent,
        _window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        if matches!(event, InputEvent::Change) {
            cx.notify();
        }
    }

    /// Put the caret in the search box when there is something to search, or
    /// on the launcher itself so its shortcuts keep working on an empty screen.
    pub fn focus(&self, window: &mut Window, cx: &mut Context<Self>) {
        if !SavedConnections::read(cx).is_empty() {
            self.query.update(cx, |input, cx| input.focus(window, cx));
        } else {
            self.focus.focus(window, cx);
        }
    }

    fn is_connecting(&self, id: &Uuid) -> bool {
        self.connecting == Some(*id)
    }

    /// Open the editor for a new connection, or pre-filled from `config`.
    fn open_editor(
        &mut self,
        config: Option<ConnectionConfig>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        // One editor at a time: a second New while one is open must not stack
        // another, or the first dialog's close would clear `editor` from under
        // the second.
        if self.editor.is_some() {
            return;
        }

        let title = if config.is_some() {
            "Edit connection"
        } else {
            "New connection"
        };

        let editor = cx.new(|cx| ConnectionEditor::new(config, window, cx));
        cx.subscribe_in(&editor, window, Self::on_editor_event)
            .detach();
        self.editor = Some(editor.clone());

        let welcome = cx.entity().downgrade();
        let body = editor.clone();
        window.open_dialog(cx, move |dialog, _window, _cx| {
            let welcome = welcome.clone();
            dialog
                .w(px(EDITOR_WIDTH))
                .h(px(600.))
                .title(title)
                .keyboard(false)
                .on_close(move |_, _window, cx| {
                    welcome
                        .update(cx, |this, cx| {
                            this.editor = None;
                            cx.notify();
                        })
                        .ok();
                })
                .child(body.clone())
        });

        editor.update(cx, |editor, cx| editor.focus(window, cx));
    }

    /// Take the editor away and hand focus back to the launcher.
    fn close_editor(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.editor = None;
        window.close_dialog(cx);
        cx.notify();
    }

    fn on_editor_event(
        &mut self,
        _editor: &Entity<ConnectionEditor>,
        event: &EditorEvent,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        match event {
            EditorEvent::Saved { config, secrets } => {
                self.save(config.clone(), secrets.clone(), window, cx);
                self.close_editor(window, cx);
            }
            EditorEvent::Connect {
                config,
                secrets,
                save,
            } => {
                // Whether the keychain can hold a secret for it is decided
                // before this save, which would make a new connection look
                // saved without having stored one.
                let saved = SavedConnections::read(cx)
                    .iter()
                    .any(|saved| saved.id == config.id);
                if *save {
                    self.save(config.clone(), secrets.clone(), window, cx);
                }
                self.close_editor(window, cx);
                // An untouched box reports no secret; a saved connection then
                // connects with whatever the keychain holds, the way a card
                // click does (`store::credentials` decides). A box the user
                // emptied is no secret at all.
                self.connect_resolving(config.clone(), secrets.clone(), saved, cx);
            }
            EditorEvent::Dismissed => self.close_editor(window, cx),
        }
    }

    fn on_new_connection(
        &mut self,
        _: &NewConnection,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.open_editor(None, window, cx);
    }

    /// Save the editor's config into the list and the store.
    ///
    /// Each of `secrets` is `None` when the user never touched its box, which
    /// leaves whatever the keychain already holds alone; an empty string means
    /// they emptied the box on purpose, which forgets it.
    fn save(
        &mut self,
        config: ConnectionConfig,
        secrets: SecretEdits,
        _window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let (connections, ticket) = change_saved(cx, |list| {
            match list.iter_mut().find(|saved| saved.id == config.id) {
                Some(saved) => {
                    // Editing a connection is not connecting to it, so its
                    // "last connected" stamp survives the edit: the card keeps
                    // its place in most-recent-first order and its "Connected
                    // … ago" line.
                    let last_connected = saved.last_connected;
                    *saved = config.clone();
                    saved.last_connected = last_connected;
                }
                None => list.push(config.clone()),
            }
        });

        // The list is small, but writing it is still disk I/O; the keychain is a
        // second, slower one behind it.
        let id = config.id;
        store_in_background(
            move || {
                store::save(&connections, ticket)?;
                secrets.save(&id)
            },
            cx,
        );
    }

    /// Connect to a saved connection the way a card click does, asking first
    /// when it is the footgun the colour exists to flag: production, set to
    /// auto-apply. The editor already warns about this combination while it
    /// is being set up, but that warning is easy to click past and easy to
    /// forget by the time the card is clicked days later — this is the last
    /// chance to catch it before a write goes out unasked. Every other
    /// connection connects straight away, as it always has.
    pub(crate) fn connect_saved_with_confirmation(
        &mut self,
        config: ConnectionConfig,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        // One question at a time; the confirm funnels into `connect`, which
        // carries the in-flight guard.
        if window.has_active_dialog(cx) {
            return;
        }

        if !config.is_risky_auto_apply() {
            self.connect_saved(config, window, cx);
            return;
        }

        let name = config.display_name();
        let welcome = cx.entity().downgrade();

        window.open_alert_dialog(cx, move |alert, _window, _cx| {
            let welcome = welcome.clone();
            let config = config.clone();
            alert
                .title(format!("Connect to {name}?"))
                .description(
                    "This connection is marked production and set to auto-apply: edits are \
                     written the moment you leave a row, with no confirmation.",
                )
                .button_props(
                    DialogButtonProps::default()
                        .ok_text("Connect")
                        .ok_variant(ButtonVariant::Danger)
                        .cancel_text("Cancel")
                        .show_cancel(true),
                )
                .on_ok(move |_, window, cx| {
                    if let Some(welcome) = welcome.upgrade() {
                        welcome.update(cx, |this, cx| {
                            this.connect_saved(config.clone(), window, cx)
                        });
                    }
                    true
                })
        });
    }

    /// Connect to a saved connection, looking its secrets up on demand.
    fn connect_saved(
        &mut self,
        config: ConnectionConfig,
        _window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.connect_resolving(config, SecretEdits::default(), true, cx);
    }

    /// Work out the secrets to connect with off the UI thread, then connect.
    ///
    /// The credential store can prompt, or simply be slow, so it is not read on
    /// the UI thread; the connect starts when the secrets come back. Only the
    /// secrets the connection can use are asked for (`store::credentials`), so
    /// a file database never touches the keychain at all.
    fn connect_resolving(
        &mut self,
        config: ConnectionConfig,
        secrets: SecretEdits,
        saved: bool,
        cx: &mut Context<Self>,
    ) {
        let credentials = {
            let config = config.clone();
            cx.background_spawn(async move { store::credentials(&config, &secrets, saved) })
        };
        cx.spawn(async move |this, cx| {
            let credentials = credentials.await;
            this.update_in(cx, |this, window, cx| match credentials {
                Ok(credentials) => this.connect(config, credentials, window, cx),
                Err(error) => {
                    this.error = Some(format!("{error:#}"));
                    cx.notify();
                }
            })
            .ok();
        })
        .detach();
    }

    /// Open a saved connection by id, connecting to it right away.
    ///
    /// This is the path a card click takes, so a restored connection starts up
    /// exactly the way a manual one does: its password comes from the keychain
    /// and the failure is shown on the launcher.
    pub(crate) fn open(&mut self, id: Uuid, window: &mut Window, cx: &mut Context<Self>) {
        let Some(config) = SavedConnections::read(cx)
            .iter()
            .find(|config| config.id == id)
            .cloned()
        else {
            return;
        };
        self.connect_saved(config, window, cx);
    }

    /// Open `config` with `credentials`, and hand the live connection on.
    fn connect(
        &mut self,
        config: ConnectionConfig,
        credentials: Credentials,
        _window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        // One connection attempt at a time: a second activation while the
        // first is still opening must not start another, or two live sessions
        // would open on the one connection.
        if self.connecting.is_some() {
            return;
        }

        self.connecting = Some(config.id);
        self.error = None;
        cx.notify();

        let task =
            runtime::spawn(async move { Connection::open_with(config.clone(), credentials).await });
        cx.spawn(async move |this, cx| {
            let result = task.await;
            this.update_in(cx, |this, window, cx| {
                this.connecting = None;
                match result {
                    Ok(Ok(connection)) => {
                        this.error = None;
                        this.mark_connected(&connection.config.id, cx);
                        cx.emit(WelcomeEvent::Connected(Arc::new(connection)));
                    }
                    Ok(Err(error)) => {
                        let message = format!("{error:#}");
                        this.error = Some(message.clone());
                        notify_error(window, cx, format!("Error: {message}"));
                    }
                    Err(_) => {
                        this.error = Some("the connection was cancelled".into());
                    }
                }
                cx.notify();
            })
            .ok();
        })
        .detach();
    }

    /// Record that a connection was just opened, for most-recent-first order.
    fn mark_connected(&mut self, id: &Uuid, cx: &mut Context<Self>) {
        let (connections, ticket) = change_saved(cx, |list| {
            if let Some(config) = list.iter_mut().find(|config| &config.id == id) {
                config.last_connected = Some(Utc::now());
            }
        });

        // Writes the launcher's own in-memory list, the same path every other
        // mutation goes through (`save`, `delete_confirmed`), rather than a
        // separate load-mutate-save against the file: a second read of the
        // file here could race a concurrent save from the editor — e.g. a
        // newly added connection whose own write has not landed yet — and
        // overwrite it with a copy that never had the edit. `store_in_background`
        // also surfaces a failed write as a toast rather than only `eprintln!`.
        // The list is the app's one copy, so a launcher in another tab writing
        // it later cannot undo this (see `SavedConnections`).
        store_in_background(move || store::save(&connections, ticket), cx);
    }

    /// Open the editor pre-filled from the saved connection.
    fn edit(&mut self, id: Uuid, window: &mut Window, cx: &mut Context<Self>) {
        let Some(config) = SavedConnections::read(cx)
            .iter()
            .find(|config| config.id == id)
            .cloned()
        else {
            return;
        };
        self.open_editor(Some(config), window, cx);
    }

    /// Copy a saved connection under a new id, without its stored password.
    fn duplicate(&mut self, id: Uuid, _window: &mut Window, cx: &mut Context<Self>) {
        let Some(source) = SavedConnections::read(cx)
            .iter()
            .find(|config| config.id == id)
            .cloned()
        else {
            return;
        };

        let mut copy = source.clone();
        copy.id = Uuid::new_v4();
        copy.last_connected = None;
        if !source.name.trim().is_empty() {
            copy.name = format!("{} copy", source.name.trim());
        }
        let (connections, ticket) = change_saved(cx, |list| list.push(copy));
        store_in_background(move || store::save(&connections, ticket), cx);
    }

    /// Ask before throwing a saved connection away.
    fn delete(&mut self, id: Uuid, window: &mut Window, cx: &mut Context<Self>) {
        let Some(config) = SavedConnections::read(cx)
            .iter()
            .find(|config| config.id == id)
            .cloned()
        else {
            return;
        };
        let name = config.display_name();
        let welcome = cx.entity().downgrade();

        window.open_alert_dialog(cx, move |alert, _window, _cx| {
            let welcome = welcome.clone();
            alert
                .title(format!("Delete \"{name}\"?"))
                .description("This removes the saved connection and its stored password.")
                .button_props(
                    DialogButtonProps::default()
                        .ok_text("Delete")
                        .ok_variant(ButtonVariant::Danger)
                        .cancel_text("Cancel")
                        .show_cancel(true),
                )
                .on_ok(move |_, window, cx| {
                    if let Some(welcome) = welcome.upgrade() {
                        welcome.update(cx, |this, cx| this.delete_confirmed(id, window, cx));
                    }
                    true
                })
        });
    }

    fn delete_confirmed(&mut self, id: Uuid, _window: &mut Window, cx: &mut Context<Self>) {
        let (connections, ticket) = change_saved(cx, |list| list.retain(|config| config.id != id));
        store_in_background(
            move || {
                store::save(&connections, ticket)?;
                store::delete_password(&id)?;
                store::delete_ssh_secret(&id)
            },
            cx,
        );
    }

    /// Open the platform file picker and start a SQLite connection from it.
    fn open_sqlite_file(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
        let prompt = sql_file::prompt_for_open(cx);
        cx.spawn(async move |this, cx| {
            let paths = match prompt.await {
                Ok(Some(paths)) => paths,
                _ => return,
            };
            let Some(path) = paths.into_iter().next() else {
                return;
            };

            this.update_in(cx, |this, window, cx| {
                let mut config = ConnectionConfig::new(Engine::Sqlite);
                config.database = path.to_string_lossy().into_owned();
                this.open_editor(Some(config), window, cx);
            })
            .ok();
        })
        .detach();
    }

    fn render_header(&self, cx: &mut Context<Self>) -> impl IntoElement {
        h_flex()
            .w_full()
            .max_w(px(640.))
            .mx_auto()
            .flex_none()
            .justify_between()
            .gap_3()
            .px_6()
            .pt_6()
            .child(
                v_flex()
                    .gap_1()
                    .child(div().text_xl().child("Zippa DB"))
                    .child(
                        div()
                            .text_sm()
                            .text_color(cx.theme().muted_foreground)
                            .child("Pick a connection, or set up a new one."),
                    ),
            )
            .child(
                Button::new("welcome-new-connection")
                    .primary()
                    .label("New connection")
                    .tooltip_with_action("New connection", &NewConnection, Some("Welcome"))
                    .on_click(
                        cx.listener(|this, _, window, cx| this.open_editor(None, window, cx)),
                    ),
            )
    }

    fn render_error(&self, error: &str, cx: &mut Context<Self>) -> impl IntoElement {
        div().id("error-banner").flex_none().px_6().pt_3().child(
            div()
                .max_h(px(96.))
                .overflow_y_scrollbar()
                .text_sm()
                .text_color(cx.theme().danger)
                .child(format!("Error: {error}")),
        )
    }

    /// The search box and the cards it filters, or the empty state.
    fn render_body(&self, cx: &mut Context<Self>) -> impl IntoElement {
        let connections = SavedConnections::read(cx).to_vec();
        if connections.is_empty() {
            return self.render_empty(cx).into_any_element();
        }

        let query = self.query.read(cx).value().trim().to_string();
        let visible: Vec<&ConnectionConfig> = ordered(&connections)
            .into_iter()
            .filter(|config| matches_query(config, &query))
            .collect();

        // A single reading column, centered and capped so the cards stay a
        // comfortable width on a wide window.
        v_flex()
            .w_full()
            .max_w(px(640.))
            .mx_auto()
            .flex_1()
            .min_h_0()
            .px_6()
            .pt_3()
            .pb_6()
            .gap_3()
            .child(Input::new(&self.query).id("connection-search"))
            .when(visible.is_empty(), |this| {
                this.child(
                    div()
                        .text_sm()
                        .text_color(cx.theme().muted_foreground)
                        .child("No connections match"),
                )
            })
            .child(
                div()
                    .id("connections")
                    .flex_1()
                    .min_h_0()
                    .overflow_y_scrollbar()
                    .child(
                        v_flex().gap_2().children(
                            visible
                                .into_iter()
                                .map(|config| render_card(self, config, cx)),
                        ),
                    ),
            )
            .into_any_element()
    }

    /// The state shown before any connection is saved.
    fn render_empty(&self, cx: &mut Context<Self>) -> impl IntoElement {
        v_flex()
            .flex_1()
            .items_center()
            .justify_center()
            .gap_2()
            .p_6()
            .child(div().text_lg().child("No connections yet"))
            .child(
                div()
                    .text_sm()
                    .text_color(cx.theme().muted_foreground)
                    .child("Add a connection to start querying your databases."),
            )
            .child(
                Button::new("empty-new-connection")
                    .primary()
                    .label("New connection")
                    .tooltip_with_action("New connection", &NewConnection, Some("Welcome"))
                    .on_click(
                        cx.listener(|this, _, window, cx| this.open_editor(None, window, cx)),
                    ),
            )
            .child(
                Button::new("open-sqlite-file")
                    .outline()
                    .label("Open SQLite file…")
                    .on_click(cx.listener(|this, _, window, cx| this.open_sqlite_file(window, cx))),
            )
    }

    /// Put the saved list in place without touching the on-disk store.
    #[cfg(test)]
    pub(crate) fn set_connections_for_test(
        &mut self,
        connections: Vec<ConnectionConfig>,
        cx: &mut Context<Self>,
    ) {
        change_saved(cx, |list| *list = connections);
    }

    /// Show an error banner without a live connection attempt.
    #[cfg(test)]
    pub(crate) fn show_error_for_test(
        &mut self,
        message: impl Into<String>,
        cx: &mut Context<Self>,
    ) {
        self.error = Some(message.into());
        cx.notify();
    }

    /// Whether the editor dialog is open over the launcher.
    #[cfg(test)]
    pub(crate) fn editor_open_for_test(&self) -> bool {
        self.editor.is_some()
    }

    /// The saved connections as the launcher holds them.
    #[cfg(test)]
    pub(crate) fn connections_for_test<'a>(&self, cx: &'a App) -> &'a [ConnectionConfig] {
        SavedConnections::read(cx)
    }

    /// Save a connection the way the editor's Save button does. `password` is
    /// `None` for a box the user never touched.
    #[cfg(test)]
    pub(crate) fn save_for_test(
        &mut self,
        config: ConnectionConfig,
        password: Option<&str>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let secrets = SecretEdits {
            password: password.map(str::to_string),
            ssh: None,
        };
        self.save(config, secrets, window, cx);
    }

    /// Open the editor pre-filled from a saved connection, as its card does.
    #[cfg(test)]
    pub(crate) fn edit_for_test(&mut self, id: Uuid, window: &mut Window, cx: &mut Context<Self>) {
        self.edit(id, window, cx);
    }

    /// The password the open editor would write to the keychain, for a test to
    /// read. `None` when the box has not been typed in.
    #[cfg(test)]
    pub(crate) fn editor_password_intent_for_test(&self, cx: &App) -> Option<String> {
        self.editor
            .as_ref()
            .and_then(|editor| editor.read(cx).password_intent_for_test(cx))
    }

    /// Put the caret in the open editor's password box, the way a click would.
    #[cfg(test)]
    pub(crate) fn focus_editor_password_for_test(
        &self,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let Some(editor) = self.editor.clone() else {
            return;
        };
        editor.update(cx, |editor, cx| editor.focus_password_for_test(window, cx));
    }

    /// Open the editor on a new connection, as "New connection" does.
    #[cfg(test)]
    pub(crate) fn new_connection_for_test(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.open_editor(None, window, cx);
    }

    /// Run `f` against the open editor.
    #[cfg(test)]
    pub(crate) fn with_editor_for_test<R>(
        &self,
        cx: &mut Context<Self>,
        f: impl FnOnce(&mut ConnectionEditor, &mut Context<ConnectionEditor>) -> R,
    ) -> R {
        let editor = self.editor.clone().expect("the editor should be open");
        editor.update(cx, f)
    }

    /// Duplicate a connection the way the card's `…` menu does.
    #[cfg(test)]
    pub(crate) fn duplicate_for_test(
        &mut self,
        id: Uuid,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.duplicate(id, window, cx);
    }

    /// Remove a connection outright, as the confirmation dialog's Delete does.
    #[cfg(test)]
    pub(crate) fn delete_confirmed_for_test(
        &mut self,
        id: Uuid,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        self.delete_confirmed(id, window, cx);
    }
}

/// Run a store write on the background executor, reporting a failure on the
/// launcher the way a synchronous write used to.
///
/// The connection list is small, but writing it is still disk I/O and the UI
/// thread should not wait on it; the keychain behind it is slower still.
/// Change the app's one list of saved connections and return what to write,
/// with the ticket that orders the write after every change made before it.
/// Every launcher observes the list, so each one redraws.
fn change_saved(
    cx: &mut App,
    change: impl FnOnce(&mut Vec<ConnectionConfig>),
) -> (Vec<ConnectionConfig>, store::Ticket) {
    SavedConnections::get(cx);
    let saved = cx.global_mut::<SavedConnections>();
    change(&mut saved.list);
    (saved.list.clone(), store::ticket())
}

fn store_in_background<F>(work: F, cx: &mut Context<Welcome>)
where
    F: FnOnce() -> anyhow::Result<()> + Send + 'static,
{
    let result = cx.background_spawn(async move { work() });
    cx.spawn(async move |this, cx| {
        if let Err(error) = result.await {
            let message = format!("{error:#}");
            this.update_in(cx, |this, window, cx| {
                notify_error(window, cx, format!("Error: {message}"));
                this.error = Some(message);
                cx.notify();
            })
            .ok();
        }
    })
    .detach();
}

impl Render for Welcome {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        v_flex()
            .size_full()
            .track_focus(&self.focus)
            .key_context("Welcome")
            .on_action(cx.listener(Self::on_new_connection))
            .child(self.render_header(cx))
            .when_some(self.error.clone(), |this, error| {
                this.child(self.render_error(&error, cx))
            })
            .child(self.render_body(cx))
    }
}

/// Saved connections, most recently connected first, then by name.
fn ordered(connections: &[ConnectionConfig]) -> Vec<&ConnectionConfig> {
    let mut ordered: Vec<&ConnectionConfig> = connections.iter().collect();
    ordered.sort_by(|a, b| match (a.last_connected, b.last_connected) {
        (Some(x), Some(y)) => y
            .cmp(&x)
            .then_with(|| a.display_name().cmp(&b.display_name())),
        (Some(_), None) => Ordering::Less,
        (None, Some(_)) => Ordering::Greater,
        (None, None) => a.display_name().cmp(&b.display_name()),
    });
    ordered
}

/// Whether a connection matches the search text, across name, host, database
/// and engine.
fn matches_query(config: &ConnectionConfig, query: &str) -> bool {
    if query.is_empty() {
        return true;
    }
    let query = query.to_lowercase();
    config.name.to_lowercase().contains(&query)
        || config.host.to_lowercase().contains(&query)
        || config.database.to_lowercase().contains(&query)
        || config.engine.label().to_lowercase().contains(&query)
}

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

    fn config(name: &str, last_connected: Option<&str>) -> ConnectionConfig {
        ConnectionConfig {
            name: name.to_string(),
            host: "db.internal".into(),
            database: "app".into(),
            last_connected: last_connected
                .map(|when| when.parse::<chrono::DateTime<Utc>>().expect("a timestamp")),
            ..ConnectionConfig::new(Engine::Postgres)
        }
    }

    #[test]
    fn ordering_puts_recent_first_then_name() {
        let a = config("alpha", Some("2024-01-01T00:00:00Z"));
        let b = config("beta", Some("2024-01-03T00:00:00Z"));
        let c = config("gamma", None);

        let names: Vec<String> = ordered(&[a, c, b])
            .into_iter()
            .map(|config| config.name.clone())
            .collect();
        assert_eq!(names, ["beta", "alpha", "gamma"]);
    }

    #[test]
    fn search_matches_name_host_database_and_engine() {
        let config = config("Prod DB", None);

        assert!(matches_query(&config, "prod"));
        assert!(matches_query(&config, "internal"));
        assert!(matches_query(&config, "app"));
        assert!(matches_query(&config, "postgres"));
        assert!(!matches_query(&config, "mysql"));
    }

    #[test]
    fn ordering_uses_display_name_when_untitled() {
        let mut a = config("", None);
        a.database = "zebra.sqlite".into();
        a.engine = Engine::Sqlite;
        let mut b = config("", None);
        b.database = "alpha.sqlite".into();
        b.engine = Engine::Sqlite;

        let names: Vec<String> = ordered(&[a, b])
            .into_iter()
            .map(|config| config.display_name())
            .collect();
        assert_eq!(names, ["alpha.sqlite", "zebra.sqlite"]);
    }
}