ratatui_toolkit/master_layout/

footer.rs

//! Footer component for status and help text

use super::InteractionMode;
use ratatui::{
    buffer::Buffer,
    layout::Rect,
    style::{Color, Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Paragraph, Widget},
};

/// Item to display in the footer
#[derive(Clone)]
pub enum FooterItem {
    /// Static text that doesn't change
    Static(String),

    /// Dynamic text generated by a function
    /// Note: Cannot use Fn trait due to Clone requirement
    /// Use helper methods instead
    Dynamic(fn() -> String),
}

impl FooterItem {
    /// Get the text for this item
    pub fn text(&self) -> String {
        match self {
            FooterItem::Static(s) => s.clone(),
            FooterItem::Dynamic(f) => f(),
        }
    }

    /// Create a static footer item
    pub fn static_text(text: impl Into<String>) -> Self {
        Self::Static(text.into())
    }

    /// Create a dynamic footer item
    pub fn dynamic(func: fn() -> String) -> Self {
        Self::Dynamic(func)
    }
}

impl std::fmt::Debug for FooterItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FooterItem::Static(s) => write!(f, "Static({:?})", s),
            FooterItem::Dynamic(_) => write!(f, "Dynamic(fn)"),
        }
    }
}

/// Footer component for displaying status information
#[derive(Clone, Debug)]
pub struct Footer {
    pub(crate) items: Vec<FooterItem>,
}

impl Footer {
    /// Create a new empty footer
    pub fn new() -> Self {
        Self { items: Vec::new() }
    }

    /// Create a footer with mode indicator
    pub fn with_mode() -> Self {
        let mut footer = Self::new();
        footer.add_mode_indicator();
        footer
    }

    /// Add a footer item
    pub fn add_item(&mut self, item: FooterItem) {
        self.items.push(item);
    }

    /// Add static text
    pub fn add_static(&mut self, text: impl Into<String>) {
        self.add_item(FooterItem::static_text(text));
    }

    /// Add a mode indicator (shows Layout/Focus mode)
    pub fn add_mode_indicator(&mut self) {
        // This will be rendered specially based on mode
        self.add_static("Mode: ");
    }

    /// Add keybinding hint
    pub fn add_hint(&mut self, keys: impl Into<String>, description: impl Into<String>) {
        self.add_static(format!("{}: {}", keys.into(), description.into()));
    }

    /// Render the footer with a specific mode
    pub fn render_with_mode(&self, area: Rect, buf: &mut Buffer, mode: &InteractionMode) {
        // Build spans from items
        let mut spans = Vec::new();

        for (i, item) in self.items.iter().enumerate() {
            if i > 0 {
                spans.push(Span::raw(" │ "));
            }

            // Special handling for mode indicator
            let text = item.text();
            if text == "Mode: " {
                // Add mode with color
                spans.push(Span::raw("Mode: "));
                let (mode_text, mode_color) = match mode {
                    InteractionMode::Layout { .. } => ("Layout", Color::Yellow),
                    InteractionMode::Focus { .. } => ("Focus", Color::Cyan),
                };
                spans.push(Span::styled(
                    mode_text,
                    Style::default().fg(mode_color).add_modifier(Modifier::BOLD),
                ));
            } else {
                spans.push(Span::raw(text));
            }
        }

        // Add selection/focus info
        match mode {
            InteractionMode::Layout { selected_pane } => {
                if selected_pane.is_some() {
                    spans.push(Span::raw(" │ "));
                    spans.push(Span::raw("↵: focus"));
                }
            }
            InteractionMode::Focus { .. } => {
                spans.push(Span::raw(" │ "));
                spans.push(Span::raw("Ctrl-A: exit"));
            }
        }

        let line = Line::from(spans);

        // Change border color based on mode
        let border_color = match mode {
            InteractionMode::Layout { .. } => Color::Yellow, // Command mode
            InteractionMode::Focus { .. } => Color::Cyan,    // Focus mode
        };

        let paragraph = Paragraph::new(line).block(
            Block::default()
                .borders(Borders::ALL)
                .border_style(Style::default().fg(border_color)),
        );

        paragraph.render(area, buf);
    }
}

impl Default for Footer {
    fn default() -> Self {
        Self::new()
    }
}

impl Widget for Footer {
    fn render(self, area: Rect, buf: &mut Buffer) {
        self.render_with_mode(area, buf, &InteractionMode::default());
    }
}

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

    #[test]
    fn test_footer_creation() {
        let footer = Footer::new();
        assert_eq!(footer.items.len(), 0);
    }

    #[test]
    fn test_add_static_item() {
        let mut footer = Footer::new();
        footer.add_static("Test");
        assert_eq!(footer.items.len(), 1);
    }

    #[test]
    fn test_static_item_text() {
        let item = FooterItem::static_text("Hello");
        assert_eq!(item.text(), "Hello");
    }

    #[test]
    fn test_dynamic_item_text() {
        fn get_text() -> String {
            "Dynamic".to_string()
        }
        let item = FooterItem::dynamic(get_text);
        assert_eq!(item.text(), "Dynamic");
    }

    #[test]
    fn test_add_hint() {
        let mut footer = Footer::new();
        footer.add_hint("Ctrl-Q", "Quit");
        assert_eq!(footer.items.len(), 1);
        assert_eq!(footer.items[0].text(), "Ctrl-Q: Quit");
    }

    #[test]
    fn test_with_mode() {
        let footer = Footer::with_mode();
        assert_eq!(footer.items.len(), 1);
        assert_eq!(footer.items[0].text(), "Mode: ");
    }

    #[test]
    fn test_multiple_items() {
        let mut footer = Footer::new();
        footer.add_static("Item 1");
        footer.add_static("Item 2");
        footer.add_static("Item 3");
        assert_eq!(footer.items.len(), 3);
    }

    #[test]
    fn test_render_with_layout_mode() {
        let mut footer = Footer::new();
        footer.add_mode_indicator();

        let area = Rect::new(0, 0, 80, 1);
        let mut buf = Buffer::empty(area);
        let mode = InteractionMode::layout();

        footer.render_with_mode(area, &mut buf, &mode);

        // Just verify it doesn't panic
    }

    #[test]
    fn test_render_with_focus_mode() {
        use super::super::PaneId;

        let mut footer = Footer::new();
        footer.add_mode_indicator();

        let area = Rect::new(0, 0, 80, 1);
        let mut buf = Buffer::empty(area);
        let mode = InteractionMode::focus(PaneId::new("test"));

        footer.render_with_mode(area, &mut buf, &mode);

        // Just verify it doesn't panic
    }

    #[test]
    fn test_footer_clone() {
        let mut footer = Footer::new();
        footer.add_static("Test");

        let cloned = footer.clone();
        assert_eq!(cloned.items.len(), 1);
    }
}