turbo_vision/views/

msgbox.rs

// (C) 2025 - Enzo Lombardi

//! `MsgBox` - message box utilities for displaying alerts and confirmations.

use super::button::Button;
use super::dialog::Dialog;
use super::input_line::InputLine;
use super::label::Label;
use super::static_text::StaticText;
use crate::app::Application;
use crate::core::command::{CM_CANCEL, CM_NO, CM_OK, CM_YES, CommandId};
use crate::core::geometry::Rect;
use crate::core::state::{deprecated_aliases, flags};
use crate::views::group::GroupLike;
use std::time::Duration;

flags! {
    /// Message-box options (Borland: `mfXxxx`): a type in the low four bits,
    /// button flags above, and behaviour flags.
    pub struct MsgBox: u16 {
        const WARNING = 0x0000;
        const ERROR = 0x0001;
        const INFORMATION = 0x0002;
        const CONFIRMATION = 0x0003;
        const ABOUT = 0x0004;
        const YES_BUTTON = 0x0100;
        const NO_BUTTON = 0x0200;
        const OK_BUTTON = 0x0400;
        const CANCEL_BUTTON = 0x0800;
        /// Close the message box on its own after
        /// [`MESSAGE_BOX_AUTO_DISMISS_TIMEOUT`] if the user has not dismissed
        /// it. The result is the default button's command (OK when present,
        /// otherwise the first button).
        const AUTO_DISMISS = 0x1000;
        const YES_NO_CANCEL = 0x0E00;
        const OK_CANCEL = 0x0C00;
    }
}

/// The type bits of a `MsgBox` (Borland: `mfWarning`..`mfAbout`).
const MSGBOX_TYPE_MASK: MsgBox = MsgBox::from_bits(0x000F);

deprecated_aliases! { MsgBox:
    MF_WARNING => WARNING, MF_ERROR => ERROR, MF_INFORMATION => INFORMATION,
    MF_CONFIRMATION => CONFIRMATION, MF_ABOUT => ABOUT, MF_YES_BUTTON => YES_BUTTON,
    MF_NO_BUTTON => NO_BUTTON, MF_OK_BUTTON => OK_BUTTON, MF_CANCEL_BUTTON => CANCEL_BUTTON,
    MF_AUTO_DISMISS => AUTO_DISMISS, MF_YES_NO_CANCEL => YES_NO_CANCEL, MF_OK_CANCEL => OK_CANCEL,
}

/// How long an `MsgBox::AUTO_DISMISS` message box stays open before closing itself.
pub const MESSAGE_BOX_AUTO_DISMISS_TIMEOUT: Duration = Duration::from_secs(3);

/// Display a message box with the given message and options.
///
/// Long messages are word-wrapped to fit the dialog's text area —
/// `StaticText` itself only honours explicit `\n`, so without this the
/// tail of a long line would be clipped right at the frame. The
/// dialog stays at a fixed 60-column max width; long messages grow
/// the dialog vertically instead.
pub fn message_box(app: &mut Application, message: &str, options: MsgBox) -> CommandId {
    let (screen_w, screen_h) = app.terminal.size();

    // Fixed dialog width — keep modal dialogs neat and consistent.
    let target_w = 60usize;
    // Inner text area: x=3, x_end=W-2 in message_box_rect → 5 chars
    // of frame/margins. Leave one extra column of breathing room so a
    // wrapped line never sits flush against the right frame.
    let inner_w = target_w.saturating_sub(6).max(10);

    let wrapped = wrap_message(message, inner_w);

    let msg_width = wrapped
        .lines()
        .map(|l| l.chars().count())
        .max()
        .unwrap_or(20);
    let msg_height = wrapped.lines().count().max(1);

    let width = (msg_width + 6).min(target_w).max(30);
    // Frame, one row of padding above and below the text, and the
    // button row only when there is at least one button to show.
    let chrome_rows = if has_buttons(options) { 6 } else { 4 };
    let min_height = chrome_rows + 1;
    let max_height = (screen_h as usize).saturating_sub(2).max(min_height);
    let height = (msg_height + chrome_rows).min(max_height).max(min_height);

    let x = (screen_w - width as i16) / 2;
    let y = (screen_h - height as i16) / 2;

    let bounds = Rect::new(x, y, x + width as i16, y + height as i16);

    message_box_rect(app, bounds, &wrapped, options)
}

/// Word-wrap `message` so every line is at most `max_width` characters
/// wide. Existing newlines act as hard breaks; words longer than
/// `max_width` (e.g. file paths) are split character-wise rather than
/// dropped, so the user always sees the full content.
#[allow(
    unused_assignments,
    reason = "line_len / first_word_in_line are dead on the last iteration of the inner loop but used on every other"
)]
fn wrap_message(message: &str, max_width: usize) -> String {
    let max_width = max_width.max(1);
    let mut out = String::new();

    for (i, paragraph) in message.split('\n').enumerate() {
        if i > 0 {
            out.push('\n');
        }
        if paragraph.chars().count() <= max_width {
            out.push_str(paragraph);
            continue;
        }

        let mut line_len = 0usize;
        let mut first_word_in_line = true;

        for word in paragraph.split_whitespace() {
            let word_chars: Vec<char> = word.chars().collect();
            let word_len = word_chars.len();

            // Words longer than the wrap width can't fit on a single
            // line — break them forcibly so we never lose content.
            if word_len > max_width {
                if !first_word_in_line {
                    out.push('\n');
                    line_len = 0;
                    first_word_in_line = true;
                }
                let mut start = 0;
                while start < word_len {
                    let end = (start + max_width).min(word_len);
                    if start > 0 {
                        out.push('\n');
                    }
                    for ch in &word_chars[start..end] {
                        out.push(*ch);
                    }
                    start = end;
                }
                line_len = (word_len % max_width).max(if word_len.is_multiple_of(max_width) {
                    max_width
                } else {
                    0
                });
                first_word_in_line = false;
                continue;
            }

            let needed = if first_word_in_line {
                word_len
            } else {
                line_len + 1 + word_len
            };
            if needed > max_width {
                out.push('\n');
                out.push_str(word);
                line_len = word_len;
            } else {
                if !first_word_in_line {
                    out.push(' ');
                    line_len += 1;
                }
                out.push_str(word);
                line_len += word_len;
            }
            first_word_in_line = false;
        }
    }
    out
}

/// Display a message box at a specific location
pub fn message_box_rect(
    app: &mut Application,
    bounds: Rect,
    message: &str,
    options: MsgBox,
) -> CommandId {
    // Determine title based on message type
    let title = match options & MSGBOX_TYPE_MASK {
        MsgBox::WARNING => "\u{26A0} Warning",
        MsgBox::ERROR => "\u{274C} Error",
        MsgBox::INFORMATION => "\u{2139}\u{FE0F} Information",
        MsgBox::CONFIRMATION => "\u{2753} Confirm",
        MsgBox::ABOUT => "\u{2139}\u{FE0F} About",
        _ => "Message",
    };

    let mut dialog = Dialog::new(bounds, title);

    // Add static text with message (one row higher). Left-align so
    // wrapped lines hang from a consistent left margin instead of
    // each being independently centered (which makes a wrapped
    // diagnostic look like staggered poetry).
    // Without buttons the text area runs down to the bottom frame.
    let text_bottom = if has_buttons(options) {
        bounds.height() - 4
    } else {
        bounds.height() - 2
    };
    let text_bounds = Rect::new(3, 1, bounds.width() - 2, text_bottom);
    dialog.add(StaticText::new(text_bounds, message));

    // Determine which buttons to show
    let button_configs = [
        (MsgBox::YES_BUTTON, " ~Y~es", CM_YES),
        (MsgBox::NO_BUTTON, " ~N~o", CM_NO),
        (MsgBox::OK_BUTTON, " ~O~K", CM_OK),
        (MsgBox::CANCEL_BUTTON, " ~C~ancel", CM_CANCEL),
    ];

    let mut buttons = Vec::new();
    for (flag, label, cmd) in &button_configs {
        if options.contains(*flag) {
            buttons.push((*label, *cmd));
        }
    }

    // Calculate button positions (one row higher)
    let button_y = bounds.height() - 4;
    let total_width: usize = buttons.iter().map(|(label, _)| label.len() + 2).sum();
    let mut x = (bounds.width_clamped() as usize - total_width) / 2;

    // Add buttons
    let is_default = buttons.len() == 1 || options.contains(MsgBox::OK_BUTTON);
    for (i, (label, cmd)) in buttons.iter().enumerate() {
        let button_width = label.len() as i16;
        let button_bounds = Rect::new(x as i16, button_y, x as i16 + button_width, button_y + 2);
        let is_this_default = is_default && (i == 0 || *cmd == CM_OK);
        dialog.add(Button::new(button_bounds, label, *cmd, is_this_default));
        x += button_width as usize + 2;
    }

    if options.contains(MsgBox::AUTO_DISMISS) {
        dialog.set_auto_dismiss(
            MESSAGE_BOX_AUTO_DISMISS_TIMEOUT,
            auto_dismiss_command(&buttons.iter().map(|(_, cmd)| *cmd).collect::<Vec<_>>()),
        );
    }

    dialog.set_initial_focus();
    dialog.execute(app)
}

/// Whether `options` asks for at least one button.
fn has_buttons(options: MsgBox) -> bool {
    options.intersects(MsgBox::YES_NO_CANCEL | MsgBox::OK_BUTTON)
}

/// The command an auto-dismissed message box reports: OK when present,
/// otherwise the first button, matching the default-button choice above.
fn auto_dismiss_command(commands: &[CommandId]) -> CommandId {
    if commands.contains(&CM_OK) {
        CM_OK
    } else {
        commands.first().copied().unwrap_or(CM_CANCEL)
    }
}

/// Display a simple message box with OK button
///
/// Returns `CM_OK` when dismissed.
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::message_box_ok;
///
/// message_box_ok(&mut app, "File saved successfully!");
/// ```
pub fn message_box_ok(app: &mut Application, message: &str) -> CommandId {
    message_box(app, message, MsgBox::INFORMATION | MsgBox::OK_BUTTON)
}

/// Display an error message box with OK button
///
/// Returns `CM_OK` when dismissed.
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::message_box_error;
///
/// message_box_error(&mut app, "Failed to open file");
/// ```
pub fn message_box_error(app: &mut Application, message: &str) -> CommandId {
    message_box(app, message, MsgBox::ERROR | MsgBox::OK_BUTTON)
}

/// Display a warning message box with OK button
///
/// Returns `CM_OK` when dismissed.
pub fn message_box_warning(app: &mut Application, message: &str) -> CommandId {
    message_box(app, message, MsgBox::WARNING | MsgBox::OK_BUTTON)
}

/// Display a confirmation dialog with Yes/No/Cancel buttons
///
/// Returns `CM_YES`, `CM_NO`, or `CM_CANCEL` based on user choice.
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::{confirmation_box, CM_YES, CM_NO};
///
/// match confirmation_box(&mut app, "Save changes?") {
///     result if result == CM_YES => { /* save */ },
///     result if result == CM_NO => { /* don't save */ },
///     _ => { /* cancel */ },
/// }
/// ```
pub fn confirmation_box(app: &mut Application, message: &str) -> CommandId {
    message_box(app, message, MsgBox::CONFIRMATION | MsgBox::YES_NO_CANCEL)
}

/// Display a confirmation dialog with Yes/No buttons
///
/// Returns `CM_YES` or `CM_NO` based on user choice.
pub fn confirmation_box_yes_no(app: &mut Application, message: &str) -> CommandId {
    message_box(
        app,
        message,
        MsgBox::CONFIRMATION | MsgBox::YES_BUTTON | MsgBox::NO_BUTTON,
    )
}

/// Display a confirmation dialog with OK/Cancel buttons
///
/// Returns `CM_OK` or `CM_CANCEL` based on user choice.
pub fn confirmation_box_ok_cancel(app: &mut Application, message: &str) -> CommandId {
    message_box(app, message, MsgBox::CONFIRMATION | MsgBox::OK_CANCEL)
}

/// Display an input box that prompts the user for a string
pub fn input_box(
    app: &mut Application,
    title: &str,
    label: &str,
    initial: &str,
    max_length: usize,
) -> Option<String> {
    // Calculate dialog size
    let label_len = label.len();
    let width = (label_len + max_length + 12).clamp(30, 60);
    let height = 8;

    // Center on screen
    let (screen_w, screen_h) = app.terminal.size();
    let x = (screen_w - width as i16) / 2;
    let y = (screen_h - height as i16) / 2;

    let bounds = Rect::new(x, y, x + width as i16, y + height as i16);

    input_box_rect(app, bounds, title, label, initial, max_length)
}

/// Display an input box at a specific location
pub fn input_box_rect(
    app: &mut Application,
    bounds: Rect,
    title: &str,
    label: &str,
    initial: &str,
    max_length: usize,
) -> Option<String> {
    let mut dialog = Dialog::new(bounds, title);

    // Add label
    let label_x = 2;
    let label_width = label.len() as i16;
    let label_bounds = Rect::new(label_x, 2, label_x + label_width, 3);
    dialog.add(Label::new(label_bounds, label));

    // Add input line
    let input_x = label_x + label_width + 1;
    let input_width = (bounds.width() - input_x - 3).min(max_length as i16 + 2);
    let input_bounds = Rect::new(input_x, 2, input_x + input_width, 3);
    let mut input = InputLine::new(input_bounds, max_length);
    input.set_text(initial);
    let input = dialog.add_typed(input);

    // Add OK button
    let button_y = bounds.height() - 4;
    let ok_x = bounds.width() / 2 - 11;
    let ok_bounds = Rect::new(ok_x, button_y, ok_x + 10, button_y + 2);
    dialog.add(Button::new(ok_bounds, " ~O~K", CM_OK, true));

    // Add Cancel button
    let cancel_x = ok_x + 12;
    let cancel_bounds = Rect::new(cancel_x, button_y, cancel_x + 10, button_y + 2);
    dialog.add(Button::new(cancel_bounds, " ~C~ancel", CM_CANCEL, false));

    dialog.set_initial_focus();

    let result = dialog.execute(app);

    if result == CM_OK {
        dialog.get(input).map(|f| f.text().to_string())
    } else {
        None
    }
}

/// Display a search dialog that prompts the user for search text
///
/// Returns `Some(search_text)` if OK was pressed, None if cancelled
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::search_box;
///
/// if let Some(text) = search_box(&mut app, "Search") {
///     // Perform search with text
/// }
/// ```
pub fn search_box(app: &mut Application, title: &str) -> Option<String> {
    // Calculate dialog size
    let width = 50;
    let height = 9;

    // Center on screen
    let (screen_w, screen_h) = app.terminal.size();
    let x = (screen_w - width) / 2;
    let y = (screen_h - height) / 2;

    let bounds = Rect::new(x, y, x + width, y + height);

    let mut dialog = Dialog::new(bounds, title);

    // Add label
    let label_bounds = Rect::new(2, 2, 20, 3);
    dialog.add(Label::new(label_bounds, "~F~ind:"));

    // Add input line
    let input_bounds = Rect::new(2, 3, width - 4, 4);
    let input = dialog.add_typed(InputLine::new(input_bounds, 100));

    // Add OK button
    let ok_bounds = Rect::new(15, 5, 25, 7);
    dialog.add(Button::new(ok_bounds, " ~O~K", CM_OK, true));

    // Add Cancel button
    let cancel_bounds = Rect::new(27, 5, 37, 7);
    dialog.add(Button::new(cancel_bounds, " ~C~ancel", CM_CANCEL, false));

    dialog.set_initial_focus();

    let result = dialog.execute(app);

    if result == CM_OK {
        let text = dialog
            .get(input)
            .map(|f| f.text().to_string())
            .unwrap_or_default();
        (!text.is_empty()).then_some(text)
    } else {
        None
    }
}

/// Display a search and replace dialog that prompts for find and replace text
///
/// Returns `Some((find_text`, `replace_text`)) if OK was pressed, None if cancelled
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::search_replace_box;
///
/// if let Some((find, replace)) = search_replace_box(&mut app, "Replace") {
///     // Perform search and replace
/// }
/// ```
pub fn search_replace_box(app: &mut Application, title: &str) -> Option<(String, String)> {
    // Calculate dialog size
    let width = 50;
    let height = 13;

    // Center on screen
    let (screen_w, screen_h) = app.terminal.size();
    let x = (screen_w - width) / 2;
    let y = (screen_h - height) / 2;

    let bounds = Rect::new(x, y, x + width, y + height);

    let mut dialog = Dialog::new(bounds, title);

    // Add find label
    let label1_bounds = Rect::new(2, 2, 20, 3);
    dialog.add(Label::new(label1_bounds, "~F~ind:"));

    // Add find input line
    let input1_bounds = Rect::new(2, 3, width - 4, 4);
    let find_input = dialog.add_typed(InputLine::new(input1_bounds, 100));

    // Add replace label
    let label2_bounds = Rect::new(2, 5, 20, 6);
    dialog.add(Label::new(label2_bounds, "~R~eplace with:"));

    // Add replace input line
    let input2_bounds = Rect::new(2, 6, width - 4, 7);
    let replace_input = dialog.add_typed(InputLine::new(input2_bounds, 100));

    // Add OK button
    let ok_bounds = Rect::new(15, 9, 25, 11);
    dialog.add(Button::new(ok_bounds, " ~O~K", CM_OK, true));

    // Add Cancel button
    let cancel_bounds = Rect::new(27, 9, 37, 11);
    dialog.add(Button::new(cancel_bounds, " ~C~ancel", CM_CANCEL, false));

    dialog.set_initial_focus();

    let result = dialog.execute(app);

    if result == CM_OK {
        let text_of = |h| {
            dialog
                .get(h)
                .map(|f: &InputLine| f.text().to_string())
                .unwrap_or_default()
        };
        let find_text = text_of(find_input);
        (!find_text.is_empty()).then(|| {
            let replace_text = text_of(replace_input);
            (find_text, replace_text)
        })
    } else {
        None
    }
}

/// Display a goto line dialog that prompts for a line number
///
/// Returns `Some(line_number)` if OK was pressed, None if cancelled or invalid
///
/// # Example
/// ```ignore
/// use turbo_vision::views::msgbox::goto_line_box;
///
/// if let Some(line) = goto_line_box(&mut app, "Go to Line") {
///     // Jump to line number
/// }
/// ```
pub fn goto_line_box(app: &mut Application, title: &str) -> Option<usize> {
    // Calculate dialog size
    let width = 40;
    let height = 8;

    // Center on screen
    let (screen_w, screen_h) = app.terminal.size();
    let x = (screen_w - width) / 2;
    let y = (screen_h - height) / 2;

    let bounds = Rect::new(x, y, x + width, y + height);

    let mut dialog = Dialog::new(bounds, title);

    // Add label
    let label_bounds = Rect::new(2, 2, 20, 3);
    dialog.add(Label::new(label_bounds, " ~L~ine number:"));

    // Add input line
    let input_bounds = Rect::new(2, 3, width - 4, 4);
    let input = dialog.add_typed(InputLine::new(input_bounds, 10));

    // Add OK button
    let ok_bounds = Rect::new(10, 5, 20, 7);
    dialog.add(Button::new(ok_bounds, " ~O~K", CM_OK, true));

    // Add Cancel button
    let cancel_bounds = Rect::new(22, 5, 32, 7);
    dialog.add(Button::new(cancel_bounds, " ~C~ancel", CM_CANCEL, false));

    dialog.set_initial_focus();

    let result = dialog.execute(app);

    if result == CM_OK {
        dialog
            .get(input)
            .and_then(|f| f.text().parse::<usize>().ok())
    } else {
        None
    }
}

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

    #[test]
    fn auto_dismiss_prefers_ok_then_first_button() {
        assert_eq!(auto_dismiss_command(&[CM_YES, CM_NO, CM_OK]), CM_OK);
        assert_eq!(auto_dismiss_command(&[CM_YES, CM_NO]), CM_YES);
        assert_eq!(auto_dismiss_command(&[]), CM_CANCEL);
    }

    #[test]
    fn has_buttons_reflects_button_flags_only() {
        assert!(has_buttons(MsgBox::INFORMATION | MsgBox::OK_BUTTON));
        assert!(has_buttons(MsgBox::CONFIRMATION | MsgBox::YES_NO_CANCEL));
        assert!(!has_buttons(MsgBox::INFORMATION | MsgBox::AUTO_DISMISS));
    }

    #[test]
    fn auto_dismiss_flag_does_not_overlap_type_or_button_bits() {
        assert!((MsgBox::AUTO_DISMISS & MSGBOX_TYPE_MASK).is_empty());
        assert!(!MsgBox::AUTO_DISMISS.intersects(MsgBox::YES_NO_CANCEL | MsgBox::OK_BUTTON));
    }

    #[test]
    fn wraps_long_lines_at_word_boundaries() {
        let out = wrap_message(
            "Parse error: line 1:1: expected 'program', found identifier 'hello'",
            30,
        );
        for line in out.lines() {
            assert!(line.chars().count() <= 30, "line too long: {line:?}");
        }
        // Round-tripping by re-joining whitespace must give the original
        // message back — wrapping must not lose or reorder words.
        let original_words: Vec<&str> =
            "Parse error: line 1:1: expected 'program', found identifier 'hello'"
                .split_whitespace()
                .collect();
        let wrapped_words: Vec<&str> = out.split_whitespace().collect();
        assert_eq!(original_words, wrapped_words);
    }

    #[test]
    fn preserves_existing_newlines() {
        let out = wrap_message("first paragraph\nsecond paragraph", 40);
        assert_eq!(out, "first paragraph\nsecond paragraph");
    }

    #[test]
    fn breaks_overlong_words_character_wise() {
        let path = "averylongfilenameWithoutSpaces.txt";
        let out = wrap_message(path, 10);
        for line in out.lines() {
            assert!(line.chars().count() <= 10);
        }
        let recombined: String = out.lines().collect();
        assert_eq!(recombined, path);
    }
}