knotra 0.34.0

knotra: multi-project VCS dashboard and bulk-operation tool.
//! Workspace management dialogs.
//!
//! RFC-034 R9: these three dialogs are the validating migration for the
//! overlay host. Content is unchanged from RFC-023; only the surrounding
//! surface (opaque, via [`knotra_ui::widget::overlay`]) and its routing
//! (through `AppLayout::dialog` in `view.rs`, giving the scrim and input
//! blocking) changed.

use iced::{
    Alignment, Element, Length,
    widget::{Space, button, column, row, text},
};

use knotra_ui::widget::{
    BUTTON_HEIGHT, centered_button_label, guided_field_focused,
    overlay::{OverlayWidth, surface},
    style,
};

use crate::{
    message::{Message, WorkspaceMessage},
    state::{
        AppState,
        focus::{FocusTarget, LayerFocus},
        workspace_mgr,
    },
};

/// Stable keys for the non-text-input `FocusTarget`s these dialogs share
/// (RFC-036 Stage 3), kept alongside [`focus_order`] so the order and the
/// dialog it describes cannot drift apart.
mod focus_target {
    pub const CONFIRM: &str = "workspace_mgr.dialog.confirm";
    pub const CANCEL: &str = "workspace_mgr.dialog.cancel";
    pub const CLOSE: &str = "workspace_mgr.dialog.close";
}

/// Whether the Confirm button's disabled-reason text should render.
/// Reproduces `guided_button`'s own rule verbatim: the reason shows only
/// while the button is genuinely disabled. Neither dialog builder calls
/// `guided_button` any more (RFC-036 Stage 5), so this behaviour has to be
/// preserved explicitly rather than inherited — `pub(crate)` so it can be
/// tested directly rather than by inspecting rendered output, which this
/// codebase's test suite has no existing way to do.
pub(crate) fn confirm_shows_reason(has_on_press: bool, reason: Option<&str>) -> bool {
    !has_on_press && reason.is_some()
}

/// The focus order and entry for whichever workspace-manager dialog is
/// open, or an empty order with no entry if none is (RFC-066 D2/R2).
/// `order` is reading order: header close first, then the body/footer left
/// to right — matching `workspace_name_dialog`'s/`delete_dialog`'s own
/// `row![confirm, Space, cancel_btn]` footer layout, Confirm before Cancel.
/// `entry` is unchanged from RFC-036: the name field for create/rename;
/// `Cancel` — the safe action — for delete, which has no field.
pub fn layer_focus(state: &AppState) -> LayerFocus<Message> {
    if let Some(dialog) = &state.workspace_mgr.create_dialog {
        return name_dialog_layer_focus(
            dialog.name.trim().is_empty(),
            WorkspaceMessage::CreateWorkspaceConfirmed,
            WorkspaceMessage::CreateWorkspaceCancelled,
        );
    }
    if let Some(dialog) = &state.workspace_mgr.rename_dialog {
        return name_dialog_layer_focus(
            dialog.new_name.trim().is_empty(),
            WorkspaceMessage::RenameWorkspaceConfirmed,
            WorkspaceMessage::RenameWorkspaceCancelled,
        );
    }
    if let Some(dialog) = &state.workspace_mgr.confirm_delete {
        let can_delete = state.all_workspaces.len() > 1 && dialog.error.is_none();
        return delete_dialog_layer_focus(can_delete);
    }
    LayerFocus {
        order: Vec::new(),
        entry: None,
    }
}

/// Shared shape for the create and rename dialogs: header close, field,
/// Confirm (gated on a non-empty name, exactly like the view's own
/// `guided_button` call), Cancel. Close and Cancel dispatch the same
/// `cancel` message the view wires to both controls.
fn name_dialog_layer_focus(
    name_is_empty: bool,
    confirm: WorkspaceMessage,
    cancel: WorkspaceMessage,
) -> LayerFocus<Message> {
    let field = FocusTarget::text_input(knotra_ui::widget::focus_id::WORKSPACE_NAME.clone());
    LayerFocus {
        order: vec![
            (
                FocusTarget::control(focus_target::CLOSE),
                Some(Message::Workspace(cancel.clone())),
            ),
            (field.clone(), None),
            (
                FocusTarget::control(focus_target::CONFIRM),
                (!name_is_empty).then_some(Message::Workspace(confirm)),
            ),
            (
                FocusTarget::control(focus_target::CANCEL),
                Some(Message::Workspace(cancel)),
            ),
        ],
        entry: Some(field),
    }
}

/// Delete has no text field, so Cancel — not Confirm — is the entry point
/// (R6): a destructive dialog should not default focus onto its destructive
/// action.
fn delete_dialog_layer_focus(can_delete: bool) -> LayerFocus<Message> {
    let cancel_target = FocusTarget::control(focus_target::CANCEL);
    LayerFocus {
        order: vec![
            (
                FocusTarget::control(focus_target::CLOSE),
                Some(Message::Workspace(
                    WorkspaceMessage::DeleteWorkspaceCancelled,
                )),
            ),
            (
                FocusTarget::control(focus_target::CONFIRM),
                can_delete.then_some(Message::Workspace(
                    WorkspaceMessage::DeleteWorkspaceConfirmed,
                )),
            ),
            (
                cancel_target.clone(),
                Some(Message::Workspace(
                    WorkspaceMessage::DeleteWorkspaceCancelled,
                )),
            ),
        ],
        entry: Some(cancel_target),
    }
}

pub fn view(state: &AppState) -> Option<Element<'_, Message>> {
    if let Some(dialog) = &state.workspace_mgr.create_dialog {
        return Some(workspace_name_dialog(state, NameDialog::Create(dialog)));
    }

    if let Some(dialog) = &state.workspace_mgr.rename_dialog {
        return Some(workspace_name_dialog(state, NameDialog::Rename(dialog)));
    }

    if let Some(dialog) = &state.workspace_mgr.confirm_delete {
        return Some(delete_dialog(state, dialog));
    }

    None
}

#[derive(Clone, Copy)]
enum NameDialog<'a> {
    Create(&'a workspace_mgr::CreateWorkspaceDialog),
    Rename(&'a workspace_mgr::RenameWorkspaceDialog),
}

fn workspace_name_dialog<'a>(state: &'a AppState, dialog: NameDialog<'a>) -> Element<'a, Message> {
    let (title, confirm_label, value, error, confirm, cancel) = match dialog {
        NameDialog::Create(dialog) => (
            state.t("workspace.create.title"),
            state.t("workspace.create.confirm"),
            dialog.name.as_str(),
            dialog.error.as_deref(),
            WorkspaceMessage::CreateWorkspaceConfirmed,
            WorkspaceMessage::CreateWorkspaceCancelled,
        ),
        NameDialog::Rename(dialog) => (
            state.t("workspace.rename.title"),
            state.t("workspace.rename.confirm"),
            dialog.new_name.as_str(),
            dialog.error.as_deref(),
            WorkspaceMessage::RenameWorkspaceConfirmed,
            WorkspaceMessage::RenameWorkspaceCancelled,
        ),
    };

    let field = match dialog {
        NameDialog::Create(_) => guided_field_focused(
            &state.theme.tokens,
            state.t("workspace.name_label"),
            state.t("workspace.name_hint"),
            value,
            |s| Message::Workspace(WorkspaceMessage::CreateWorkspaceNameChanged(s)),
            error,
            knotra_ui::widget::focus_id::WORKSPACE_NAME.clone(),
        ),
        NameDialog::Rename(_) => guided_field_focused(
            &state.theme.tokens,
            state.t("workspace.name_label"),
            state.t("workspace.name_hint"),
            value,
            |s| Message::Workspace(WorkspaceMessage::RenameWorkspaceNameChanged(s)),
            error,
            knotra_ui::widget::focus_id::WORKSPACE_NAME.clone(),
        ),
    };

    let reason = if value.trim().is_empty() {
        Some(state.t("workspace.error.empty_name"))
    } else {
        None
    };

    let tokens = &state.theme.tokens;
    let confirm_on_press = (!value.trim().is_empty()).then_some(Message::Workspace(confirm));
    let confirm_focused = crate::app::ring(state, &FocusTarget::control(focus_target::CONFIRM));
    let confirm_btn = {
        let t = tokens.clone();
        button(centered_button_label(
            text(confirm_label)
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens)),
        ))
        .height(BUTTON_HEIGHT)
        .padding([0, 18])
        .on_press_maybe(confirm_on_press.clone())
        .style(move |_theme, status| {
            style::with_focus_ring(&t, confirm_focused, style::primary(&t, status))
        })
    };
    let confirm: Element<'_, Message> = if confirm_shows_reason(confirm_on_press.is_some(), reason)
    {
        column![
            confirm_btn,
            // RFC-071 Amendment A3 D14: a reason — `body`.
            text(reason.unwrap_or_default())
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens))
        ]
        .spacing(6)
        .into()
    } else {
        confirm_btn.into()
    };

    let cancel_focused = crate::app::ring(state, &FocusTarget::control(focus_target::CANCEL));
    let cancel_btn = {
        let t = tokens.clone();
        button(centered_button_label(
            text(state.t("action.cancel"))
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens)),
        ))
        .height(BUTTON_HEIGHT)
        .padding([0, 18])
        .on_press(Message::Workspace(cancel.clone()))
        .style(move |_theme, status| {
            style::with_focus_ring(&t, cancel_focused, style::secondary(&t, status))
        })
    };

    let footer =
        row![confirm, Space::new().width(Length::Fill), cancel_btn].align_y(Alignment::Center);

    surface(
        tokens,
        OverlayWidth::Standard.resolve(state.window_width),
        title,
        Some(Message::Workspace(cancel)),
        crate::app::ring(state, &FocusTarget::control(focus_target::CLOSE)),
        field,
        footer,
    )
}

fn delete_dialog<'a>(
    state: &'a AppState,
    dialog: &'a crate::state::workspace_mgr::DeleteWorkspaceDialog,
) -> Element<'a, Message> {
    let body_text = format!(
        "{} \"{}\". {}",
        state.t("workspace.delete.body_prefix"),
        dialog.workspace_name,
        state.t("workspace.delete.body_suffix"),
    );
    let project_count = format!(
        "{} {}",
        dialog.project_count,
        state.t("workspace.delete.project_count_suffix"),
    );

    let can_delete = state.all_workspaces.len() > 1 && dialog.error.is_none();
    let reason = if state.all_workspaces.len() <= 1 {
        Some(state.t("workspace.delete.disabled_last"))
    } else {
        dialog.error.as_deref()
    };

    let tokens = &state.theme.tokens;
    let confirm_on_press = can_delete.then_some(Message::Workspace(
        WorkspaceMessage::DeleteWorkspaceConfirmed,
    ));
    let confirm_focused = crate::app::ring(state, &FocusTarget::control(focus_target::CONFIRM));
    let confirm_btn = {
        let t = tokens.clone();
        button(centered_button_label(
            text(state.t("workspace.delete.confirm"))
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens)),
        ))
        .height(BUTTON_HEIGHT)
        .padding([0, 18])
        .on_press_maybe(confirm_on_press.clone())
        .style(move |_theme, status| {
            style::with_focus_ring(&t, confirm_focused, style::danger(&t, status))
        })
    };
    let confirm: Element<'_, Message> = if confirm_shows_reason(confirm_on_press.is_some(), reason)
    {
        column![
            confirm_btn,
            // RFC-071 Amendment A3 D14: a reason — `body`.
            text(reason.unwrap_or_default())
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens))
        ]
        .spacing(6)
        .into()
    } else {
        confirm_btn.into()
    };

    let cancel_focused = crate::app::ring(state, &FocusTarget::control(focus_target::CANCEL));
    let cancel_btn = {
        let t = tokens.clone();
        button(centered_button_label(
            text(state.t("action.cancel"))
                .size(snora::design::style::text::body_size(tokens))
                .line_height(snora::design::style::text::body_line_height(tokens)),
        ))
        .height(BUTTON_HEIGHT)
        .padding([0, 18])
        .on_press(Message::Workspace(
            WorkspaceMessage::DeleteWorkspaceCancelled,
        ))
        .style(move |_theme, status| {
            style::with_focus_ring(&t, cancel_focused, style::secondary(&t, status))
        })
    };

    let footer =
        row![confirm, Space::new().width(Length::Fill), cancel_btn].align_y(Alignment::Center);

    let body = column![
        text(body_text)
            .size(snora::design::style::text::body_size(tokens))
            .line_height(snora::design::style::text::body_line_height(tokens)),
        // RFC-071 Amendment A3 D14: a second sentence of the dialog's own
        // body, warning of a consequence — `body`, not a metadata count.
        text(project_count)
            .size(snora::design::style::text::body_size(tokens))
            .line_height(snora::design::style::text::body_line_height(tokens)),
    ]
    .spacing(8);

    surface(
        tokens,
        OverlayWidth::Standard.resolve(state.window_width),
        state.t("workspace.delete.title"),
        Some(Message::Workspace(
            WorkspaceMessage::DeleteWorkspaceCancelled,
        )),
        crate::app::ring(state, &FocusTarget::control(focus_target::CLOSE)),
        body,
        footer,
    )
}