envision 0.16.0

//! A modal dialog component with configurable buttons.
//!
//! [`Dialog`] provides a centered overlay dialog with title, message, and
//! configurable buttons. State is stored in [`DialogState`], updated via
//! [`DialogMessage`], and produces [`DialogOutput`]. Buttons are configured
//! with [`DialogButton`].
//!
//! Implements [`Toggleable`].
//!
//! See also [`ConfirmDialog`](super::ConfirmDialog) for a purpose-built
//! confirmation dialog with preset button configurations.
//!
//! # Example
//!
//! ```rust
//! use envision::component::{Dialog, DialogMessage, DialogOutput, DialogState, Component, Toggleable};
//!
//! // Create an alert dialog
//! let mut state = DialogState::alert("Error", "File not found.");
//! Dialog::show(&mut state);
//!
//! // Press the OK button
//! let output = Dialog::update(&mut state, DialogMessage::Press);
//! assert_eq!(output, Some(DialogOutput::ButtonPressed("ok".into())));
//! ```

use ratatui::prelude::*;
use ratatui::widgets::{Block, Borders, Clear, Paragraph, Wrap};

use super::{Component, EventContext, RenderContext, Toggleable};
use crate::input::{Event, Key};
use crate::theme::Theme;

/// A button configuration for a dialog.
///
/// Each button has a unique identifier that is returned when the button
/// is pressed, and a display label shown to the user.
///
/// # Example
///
/// ```rust
/// use envision::component::DialogButton;
///
/// let button = DialogButton::new("save", "Save Changes");
/// assert_eq!(button.id(), "save");
/// assert_eq!(button.label(), "Save Changes");
/// ```
#[derive(Clone, Debug, PartialEq, Eq)]
#[cfg_attr(
    feature = "serialization",
    derive(serde::Serialize, serde::Deserialize)
)]
pub struct DialogButton {
    /// Unique identifier returned when this button is pressed.
    id: String,
    /// Display label for the button.
    label: String,
}

impl DialogButton {
    /// Creates a new dialog button.
    ///
    /// # Arguments
    ///
    /// * `id` - Unique identifier returned when pressed
    /// * `label` - Display text for the button
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogButton;
    ///
    /// let button = DialogButton::new("ok", "OK");
    /// ```
    pub fn new(id: impl Into<String>, label: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            label: label.into(),
        }
    }

    /// Returns the button's unique identifier.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogButton;
    ///
    /// let button = DialogButton::new("confirm", "Confirm");
    /// assert_eq!(button.id(), "confirm");
    /// ```
    pub fn id(&self) -> &str {
        &self.id
    }

    /// Returns the button's display label.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogButton;
    ///
    /// let button = DialogButton::new("save", "Save Changes");
    /// assert_eq!(button.label(), "Save Changes");
    /// ```
    pub fn label(&self) -> &str {
        &self.label
    }
}

/// Messages that can be sent to a Dialog component.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DialogMessage {
    /// Move focus to the next button.
    FocusNext,
    /// Move focus to the previous button.
    FocusPrev,
    /// Press the currently focused button.
    Press,
    /// Close the dialog without selecting a button.
    Close,
    /// Show the dialog.
    Open,
}

/// Output messages from a Dialog component.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DialogOutput {
    /// A button was pressed (returns the button id).
    ButtonPressed(String),
    /// The dialog was closed without selection (e.g., Escape).
    Closed,
}

/// State for a Dialog component.
///
/// Contains all the state needed to render and manage a dialog,
/// including title, message, buttons, and focus state.
#[derive(Clone, Debug, Default, PartialEq)]
#[cfg_attr(
    feature = "serialization",
    derive(serde::Serialize, serde::Deserialize)
)]
pub struct DialogState {
    /// Dialog title.
    title: String,
    /// Dialog message/content.
    message: String,
    /// Available buttons.
    buttons: Vec<DialogButton>,
    /// Index of the primary/default button.
    primary_button: usize,
    /// Index of the currently focused button.
    focused_button: usize,
    /// Whether the dialog is visible.
    visible: bool,
}

impl DialogState {
    /// Creates a new dialog with the given title, message, and buttons.
    ///
    /// The first button is set as the primary button by default.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogButton, DialogState};
    ///
    /// let buttons = vec![
    ///     DialogButton::new("ok", "OK"),
    ///     DialogButton::new("cancel", "Cancel"),
    /// ];
    /// let state = DialogState::new("Title", "Message", buttons);
    /// assert_eq!(state.title(), "Title");
    /// assert_eq!(state.primary_button(), 0);
    /// ```
    pub fn new(
        title: impl Into<String>,
        message: impl Into<String>,
        buttons: Vec<DialogButton>,
    ) -> Self {
        Self {
            title: title.into(),
            message: message.into(),
            buttons,
            primary_button: 0,
            focused_button: 0,
            visible: false,
        }
    }

    /// Creates a dialog with a primary button specified.
    ///
    /// The primary button index is clamped to the valid range.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogButton, DialogState};
    ///
    /// let buttons = vec![
    ///     DialogButton::new("cancel", "Cancel"),
    ///     DialogButton::new("ok", "OK"),
    /// ];
    /// let state = DialogState::with_primary("Title", "Message", buttons, 1);
    /// assert_eq!(state.primary_button(), 1);
    /// ```
    pub fn with_primary(
        title: impl Into<String>,
        message: impl Into<String>,
        buttons: Vec<DialogButton>,
        primary: usize,
    ) -> Self {
        let primary = if buttons.is_empty() {
            0
        } else {
            primary.min(buttons.len() - 1)
        };
        Self {
            title: title.into(),
            message: message.into(),
            buttons,
            primary_button: primary,
            focused_button: primary,
            visible: false,
        }
    }

    /// Creates a simple alert dialog with an "OK" button.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::alert("Error", "Something went wrong.");
    /// assert_eq!(state.buttons().len(), 1);
    /// assert_eq!(state.buttons()[0].id(), "ok");
    /// ```
    pub fn alert(title: impl Into<String>, message: impl Into<String>) -> Self {
        Self::new(title, message, vec![DialogButton::new("ok", "OK")])
    }

    /// Creates a confirmation dialog with "Cancel" and "OK" buttons.
    ///
    /// The "OK" button is set as the primary button.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::confirm("Delete?", "This cannot be undone.");
    /// assert_eq!(state.buttons().len(), 2);
    /// assert_eq!(state.buttons()[0].id(), "cancel");
    /// assert_eq!(state.buttons()[1].id(), "ok");
    /// assert_eq!(state.primary_button(), 1);
    /// ```
    pub fn confirm(title: impl Into<String>, message: impl Into<String>) -> Self {
        Self::with_primary(
            title,
            message,
            vec![
                DialogButton::new("cancel", "Cancel"),
                DialogButton::new("ok", "OK"),
            ],
            1,
        )
    }

    /// Returns the dialog title.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let state = DialogState::alert("Error", "Something went wrong.");
    /// assert_eq!(state.title(), "Error");
    /// ```
    pub fn title(&self) -> &str {
        &self.title
    }

    /// Returns the dialog message.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let state = DialogState::alert("Error", "File not found.");
    /// assert_eq!(state.message(), "File not found.");
    /// ```
    pub fn message(&self) -> &str {
        &self.message
    }

    /// Returns the dialog buttons.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let state = DialogState::confirm("Delete?", "Are you sure?");
    /// assert_eq!(state.buttons().len(), 2);
    /// assert_eq!(state.buttons()[0].id(), "cancel");
    /// assert_eq!(state.buttons()[1].id(), "ok");
    /// ```
    pub fn buttons(&self) -> &[DialogButton] {
        &self.buttons
    }

    /// Returns the index of the primary button.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::confirm("Delete?", "Are you sure?");
    /// assert_eq!(state.primary_button(), 1);
    /// ```
    pub fn primary_button(&self) -> usize {
        self.primary_button
    }

    /// Returns the index of the currently focused button.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::confirm("Delete?", "Are you sure?");
    /// // Starts at primary button index
    /// assert_eq!(state.focused_button(), state.primary_button());
    /// ```
    pub fn focused_button(&self) -> usize {
        self.focused_button
    }

    /// Sets the dialog title.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let mut state = DialogState::alert("Old Title", "Message");
    /// state.set_title("New Title");
    /// assert_eq!(state.title(), "New Title");
    /// ```
    pub fn set_title(&mut self, title: impl Into<String>) {
        self.title = title.into();
    }

    /// Sets the dialog message.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let mut state = DialogState::alert("Title", "Old message");
    /// state.set_message("New message");
    /// assert_eq!(state.message(), "New message");
    /// ```
    pub fn set_message(&mut self, message: impl Into<String>) {
        self.message = message.into();
    }

    /// Sets the dialog buttons.
    ///
    /// Resets focus to the first button or primary button index.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogState, DialogButton};
    ///
    /// let mut state = DialogState::alert("Info", "Done");
    /// state.set_buttons(vec![
    ///     DialogButton::new("yes", "Yes"),
    ///     DialogButton::new("no", "No"),
    /// ]);
    /// assert_eq!(state.buttons().len(), 2);
    /// ```
    pub fn set_buttons(&mut self, buttons: Vec<DialogButton>) {
        self.buttons = buttons;
        if self.buttons.is_empty() {
            self.primary_button = 0;
            self.focused_button = 0;
        } else {
            self.primary_button = self.primary_button.min(self.buttons.len() - 1);
            self.focused_button = self.primary_button;
        }
    }

    /// Sets the primary button index.
    ///
    /// The index is clamped to the valid range.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogButton, DialogState};
    ///
    /// let mut state = DialogState::new("T", "M", vec![
    ///     DialogButton::new("cancel", "Cancel"),
    ///     DialogButton::new("ok", "OK"),
    /// ]);
    /// state.set_primary_button(1);
    /// assert_eq!(state.primary_button(), 1);
    /// ```
    pub fn set_primary_button(&mut self, index: usize) {
        if self.buttons.is_empty() {
            self.primary_button = 0;
        } else {
            self.primary_button = index.min(self.buttons.len() - 1);
        }
    }

    /// Sets the dialog title (builder method).
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::default().with_title("My Title");
    /// assert_eq!(state.title(), "My Title");
    /// ```
    pub fn with_title(mut self, title: impl Into<String>) -> Self {
        self.title = title.into();
        self
    }

    /// Sets the dialog message (builder method).
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::DialogState;
    ///
    /// let state = DialogState::default().with_message("Important message");
    /// assert_eq!(state.message(), "Important message");
    /// ```
    pub fn with_message(mut self, message: impl Into<String>) -> Self {
        self.message = message.into();
        self
    }

    /// Sets the dialog buttons (builder method).
    ///
    /// Resets focus to the first button or primary button index.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogButton, DialogState};
    ///
    /// let state = DialogState::default().with_buttons(vec![
    ///     DialogButton::new("ok", "OK"),
    ///     DialogButton::new("cancel", "Cancel"),
    /// ]);
    /// assert_eq!(state.buttons().len(), 2);
    /// ```
    pub fn with_buttons(mut self, buttons: Vec<DialogButton>) -> Self {
        self.set_buttons(buttons);
        self
    }

    /// Sets the primary button index (builder method).
    ///
    /// The index is clamped to the valid range.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogButton, DialogState};
    ///
    /// let state = DialogState::new("T", "M", vec![
    ///     DialogButton::new("a", "A"),
    ///     DialogButton::new("b", "B"),
    /// ]).with_primary_button(1);
    /// assert_eq!(state.primary_button(), 1);
    /// ```
    pub fn with_primary_button(mut self, index: usize) -> Self {
        self.set_primary_button(index);
        self
    }

    /// Returns true if the dialog is visible.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let state = DialogState::alert("Info", "Done.");
    /// assert!(!state.is_visible());
    /// ```
    pub fn is_visible(&self) -> bool {
        self.visible
    }

    /// Sets the visibility state.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let mut state = DialogState::alert("Info", "Done.");
    /// state.set_visible(true);
    /// assert!(state.is_visible());
    /// ```
    pub fn set_visible(&mut self, visible: bool) {
        Dialog::set_visible(self, visible);
    }

    /// Sets the visibility state using builder pattern.
    ///
    /// # Examples
    ///
    /// ```
    /// use envision::prelude::*;
    ///
    /// let state = DialogState::alert("Info", "Done.").with_visible(true);
    /// assert!(state.is_visible());
    /// ```
    pub fn with_visible(mut self, visible: bool) -> Self {
        Dialog::set_visible(&mut self, visible);
        self
    }

    /// Maps an input event to a dialog message.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogMessage, DialogState, Toggleable, Dialog};
    /// use envision::input::{Event, Key};
    ///
    /// let mut state = DialogState::alert("Info", "Done.");
    /// Dialog::show(&mut state);
    /// let event = Event::key(Key::Enter);
    /// assert_eq!(state.handle_event(&event), Some(DialogMessage::Press));
    /// ```
    pub fn handle_event(&self, event: &Event) -> Option<DialogMessage> {
        Dialog::handle_event(self, event, &EventContext::default())
    }

    /// Dispatches an event, updating state and returning any output.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogOutput, DialogState, Toggleable, Dialog};
    /// use envision::input::{Event, Key};
    ///
    /// let mut state = DialogState::alert("Info", "Done.");
    /// Dialog::show(&mut state);
    /// let event = Event::key(Key::Enter);
    /// let output = state.dispatch_event(&event);
    /// assert_eq!(output, Some(DialogOutput::ButtonPressed("ok".into())));
    /// ```
    pub fn dispatch_event(&mut self, event: &Event) -> Option<DialogOutput> {
        Dialog::dispatch_event(self, event, &EventContext::default())
    }

    /// Updates the dialog state with a message, returning any output.
    ///
    /// # Example
    ///
    /// ```rust
    /// use envision::component::{DialogMessage, DialogOutput, DialogState, Toggleable, Dialog};
    ///
    /// let mut state = DialogState::alert("Info", "Done.");
    /// Dialog::show(&mut state);
    /// let output = state.update(DialogMessage::Close);
    /// assert_eq!(output, Some(DialogOutput::Closed));
    /// ```
    pub fn update(&mut self, msg: DialogMessage) -> Option<DialogOutput> {
        Dialog::update(self, msg)
    }
}

/// A modal dialog component with configurable buttons.
///
/// `Dialog` displays a centered overlay with a title, message, and
/// configurable buttons. It implements:
/// - [`Component`] for update/view logic
/// - [`Toggleable`] for visibility control
///
/// # Visual Format
///
/// ```text
/// ┌─────── Title ───────┐
/// │                     │
/// │  Message text here  │
/// │                     │
/// │   [Cancel]  [OK]    │
/// └─────────────────────┘
/// ```
///
/// # Messages
///
/// - `FocusNext` - Move focus to the next button
/// - `FocusPrev` - Move focus to the previous button
/// - `Press` - Press the currently focused button
/// - `Close` - Close the dialog without selection
/// - `Open` - Show the dialog
///
/// # Output
///
/// - `ButtonPressed(id)` - A button was pressed
/// - `Closed` - The dialog was closed without selection
///
/// # Example
///
/// ```rust
/// use envision::component::{
///     Dialog, DialogMessage, DialogOutput, DialogState, Component, Toggleable
/// };
///
/// // Create and show a confirmation dialog
/// let mut state = DialogState::confirm("Delete?", "This cannot be undone.");
/// Dialog::show(&mut state);
///
/// // Navigate to Cancel
/// Dialog::update(&mut state, DialogMessage::FocusPrev);
///
/// // Press Cancel
/// let output = Dialog::update(&mut state, DialogMessage::Press);
/// assert_eq!(output, Some(DialogOutput::ButtonPressed("cancel".into())));
/// ```
pub struct Dialog;

impl Component for Dialog {
    type State = DialogState;
    type Message = DialogMessage;
    type Output = DialogOutput;

    fn init() -> Self::State {
        DialogState::default()
    }

    fn update(state: &mut Self::State, msg: Self::Message) -> Option<Self::Output> {
        if !state.visible {
            if matches!(msg, DialogMessage::Open) {
                state.visible = true;
                state.focused_button = state.primary_button;
            }
            return None;
        }

        match msg {
            DialogMessage::FocusNext => {
                if !state.buttons.is_empty() {
                    state.focused_button = (state.focused_button + 1) % state.buttons.len();
                }
                None
            }
            DialogMessage::FocusPrev => {
                if !state.buttons.is_empty() {
                    state.focused_button = state
                        .focused_button
                        .checked_sub(1)
                        .unwrap_or(state.buttons.len() - 1);
                }
                None
            }
            DialogMessage::Press => state.buttons.get(state.focused_button).map(|btn| {
                state.visible = false;
                DialogOutput::ButtonPressed(btn.id.clone())
            }),
            DialogMessage::Close => {
                state.visible = false;
                Some(DialogOutput::Closed)
            }
            DialogMessage::Open => None,
        }
    }

    fn handle_event(
        state: &Self::State,
        event: &Event,
        _ctx: &EventContext,
    ) -> Option<Self::Message> {
        if !state.visible {
            return None;
        }
        if let Some(key) = event.as_key() {
            match key.code {
                Key::Tab if key.modifiers.shift() => Some(DialogMessage::FocusPrev),
                Key::Tab => Some(DialogMessage::FocusNext),
                Key::Enter => Some(DialogMessage::Press),
                Key::Esc => Some(DialogMessage::Close),
                _ => None,
            }
        } else {
            None
        }
    }

    fn view(state: &Self::State, ctx: &mut RenderContext<'_, '_>) {
        if !state.visible {
            return;
        }

        crate::annotation::with_registry(|reg| {
            reg.register(
                ctx.area,
                crate::annotation::Annotation::dialog(state.title.as_str())
                    .with_id("dialog")
                    .with_focus(ctx.focused)
                    .with_disabled(ctx.disabled),
            );
        });

        // Calculate dialog size
        let dialog_width = (ctx.area.width * 60 / 100).clamp(30, 80);
        let message_lines = state.message.lines().count().max(1) as u16;
        let dialog_height = (5 + message_lines).min(ctx.area.height);

        // Center the dialog
        let dialog_area = centered_rect(dialog_width, dialog_height, ctx.area);

        // Clear the dialog ctx.area (overlay effect)
        ctx.frame.render_widget(Clear, dialog_area);

        // Render dialog box
        let block = Block::default()
            .title(format!(" {} ", state.title))
            .borders(Borders::ALL)
            .border_style(ctx.theme.border_style());

        let inner = block.inner(dialog_area);
        ctx.frame.render_widget(block, dialog_area);

        // Layout: message ctx.area + button row
        let chunks = Layout::default()
            .direction(Direction::Vertical)
            .constraints([
                Constraint::Min(1),    // Message
                Constraint::Length(3), // Buttons
            ])
            .split(inner);

        // Render message
        let message = Paragraph::new(state.message.as_str()).wrap(Wrap { trim: true });
        ctx.frame.render_widget(message, chunks[0]);

        // Render buttons horizontally centered
        render_buttons(
            state,
            ctx.frame,
            chunks[1],
            ctx.theme,
            ctx.focused,
            ctx.disabled,
        );
    }
}

impl Toggleable for Dialog {
    fn is_visible(state: &Self::State) -> bool {
        state.visible
    }

    fn set_visible(state: &mut Self::State, visible: bool) {
        state.visible = visible;
        if visible {
            state.focused_button = state.primary_button;
        }
    }
}

/// Re-export of [`crate::util::centered_rect`] for backward compatibility.
fn centered_rect(width: u16, height: u16, area: Rect) -> Rect {
    crate::util::centered_rect(width, height, area)
}

/// Renders the dialog buttons horizontally centered.
fn render_buttons(
    state: &DialogState,
    frame: &mut Frame,
    area: Rect,
    theme: &Theme,
    focused: bool,
    disabled: bool,
) {
    if state.buttons.is_empty() {
        return;
    }

    // Calculate button widths (label + padding + borders)
    let button_widths: Vec<u16> = state
        .buttons
        .iter()
        .map(|b| (b.label.len() + 4) as u16)
        .collect();
    let total_width: u16 =
        button_widths.iter().sum::<u16>() + (state.buttons.len().saturating_sub(1) as u16 * 2);

    // Center the buttons
    let start_x = area.x + area.width.saturating_sub(total_width) / 2;
    let mut x = start_x;

    for (i, button) in state.buttons.iter().enumerate() {
        let width = button_widths[i];
        let button_area = Rect::new(x, area.y, width, 3.min(area.height));

        let is_focused = i == state.focused_button && focused;
        let is_primary = i == state.primary_button;

        let style = if disabled {
            theme.disabled_style()
        } else if is_focused {
            theme.focused_bold_style()
        } else if is_primary {
            Style::default().add_modifier(Modifier::BOLD)
        } else {
            theme.normal_style()
        };

        let border_style = if is_focused && !disabled {
            theme.focused_border_style()
        } else {
            theme.border_style()
        };

        let btn = Paragraph::new(button.label.as_str())
            .style(style)
            .alignment(Alignment::Center)
            .block(
                Block::default()
                    .borders(Borders::ALL)
                    .border_style(border_style),
            );

        frame.render_widget(btn, button_area);
        x += width + 2;
    }
}

#[cfg(test)]
mod tests;