oo_ide/widgets/

status_bar.rs

//! Global status bar widget.
//!
//! Views populate a [`StatusBarBuilder`] with left-side items; the
//! [`StatusBarRenderer`] then draws the full status bar — left items from the
//! view on the left, task-status on the right — into a one-row [`Rect`].

use ratatui::{
    Frame,
    layout::Rect,
    style::{Modifier, Style},
    text::{Line, Span},
    widgets::Paragraph,
};

use crate::commands::CommandId;
use crate::task_registry::{TaskRegistry, TaskStatus};

// ---------------------------------------------------------------------------
// Public types
// ---------------------------------------------------------------------------

/// A single item on the left side of the status bar.
#[derive(Debug, Clone)]
pub enum StatusItem {
    /// Non-interactive text label.
    Label(String),
    /// Clickable item that dispatches a command when selected.
    Menu { label: String, command: CommandId },
    /// Clickable action button.
    Action { label: String, command: CommandId },
}

/// Collects left-side status bar items from a view.
#[derive(Debug, Default)]
pub struct StatusBarBuilder {
    items: Vec<StatusItem>,
}

impl StatusBarBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    /// Append a non-interactive text label.
    pub fn label(&mut self, text: impl Into<String>) -> &mut Self {
        self.items.push(StatusItem::Label(text.into()));
        self
    }

    /// Append a clickable menu item (shows a dropdown indicator `▼`).
    pub fn menu(&mut self, label: impl Into<String>, command: CommandId) -> &mut Self {
        self.items.push(StatusItem::Menu { label: label.into(), command });
        self
    }

    /// Append a clickable action button.
    pub fn action(&mut self, label: impl Into<String>, command: CommandId) -> &mut Self {
        self.items.push(StatusItem::Action { label: label.into(), command });
        self
    }

    /// Consume the builder and return the collected items.
    pub fn build(self) -> Vec<StatusItem> {
        self.items
    }
}

// ---------------------------------------------------------------------------
// Click state
// ---------------------------------------------------------------------------

/// Records the clickable regions produced by the last render call.
///
/// Stored on `AppState` so that `handle_mouse` can dispatch the right command
/// or cancel-task operation without re-running layout logic.
#[derive(Debug, Default, Clone)]
pub struct StatusBarClickState {
    /// `(rect, command_id)` for each interactive status item.
    pub item_clicks: Vec<(Rect, CommandId)>,
    /// `(rect, task_id)` for each rendered cancel button.
    pub cancel_clicks: Vec<(Rect, crate::task_registry::TaskId)>,
    /// `(rect, task_id)` for each rendered task label (click → open log view).
    pub task_label_clicks: Vec<(Rect, crate::task_registry::TaskId)>,
}

impl StatusBarClickState {
    /// Returns the `CommandId` to dispatch if `(col, row)` hit a menu/action item.
    pub fn hit_command(&self, col: u16, row: u16) -> Option<&CommandId> {
        for (rect, cmd) in &self.item_clicks {
            if col >= rect.x && col < rect.x + rect.width && row >= rect.y && row < rect.y + rect.height {
                return Some(cmd);
            }
        }
        None
    }

    /// Returns the `TaskId` to cancel if `(col, row)` hit a cancel button.
    pub fn hit_cancel(&self, col: u16, row: u16) -> Option<crate::task_registry::TaskId> {
        for (rect, id) in &self.cancel_clicks {
            if col >= rect.x && col < rect.x + rect.width && row >= rect.y && row < rect.y + rect.height {
                return Some(*id);
            }
        }
        None
    }

    /// Returns the `TaskId` whose log view to open if `(col, row)` hit a task label.
    pub fn hit_task_label(&self, col: u16, row: u16) -> Option<crate::task_registry::TaskId> {
        for (rect, id) in &self.task_label_clicks {
            if col >= rect.x && col < rect.x + rect.width && row >= rect.y && row < rect.y + rect.height {
                return Some(*id);
            }
        }
        None
    }
}

// ---------------------------------------------------------------------------
// Renderer
// ---------------------------------------------------------------------------

/// Renders the global status bar.
pub struct StatusBarRenderer;

impl StatusBarRenderer {
    /// Draw the status bar into `area` (expected to be 1 row tall).
    ///
    /// Returns a [`StatusBarClickState`] recording the clickable regions so
    /// the caller can wire up mouse dispatch.
    pub fn render(
        frame: &mut Frame,
        area: Rect,
        items: Vec<StatusItem>,
        task_registry: &TaskRegistry,
        theme: &crate::theme::Theme,
    ) -> StatusBarClickState {
        if area.height == 0 {
            return StatusBarClickState::default();
        }

        let bg = theme.status_bar_bg();
        let fg = theme.status_bar_fg();
        let base_style = Style::default().fg(fg).bg(bg);

        // --- Build left spans ---
        let mut left_spans: Vec<Span> = Vec::new();
        let mut click_state = StatusBarClickState::default();
        // Left content is rendered starting at area.x + 1 (one char padding).
        let mut x_cursor = area.x + 1;

        for item in &items {
            // Double-space separator between items (skip before first).
            if !left_spans.is_empty() {
                left_spans.push(Span::styled("  ", base_style));
                x_cursor += 2;
            }

            match item {
                StatusItem::Label(text) => {
                    let text = truncate(text, 30);
                    x_cursor += unicode_width::UnicodeWidthStr::width(text.as_str()) as u16;
                    left_spans.push(Span::styled(text, base_style));
                }
                StatusItem::Menu { label, command } => {
                    let text = truncate(label, 28);
                    let full = format!("{} ▼", text);
                    let w = unicode_width::UnicodeWidthStr::width(full.as_str()) as u16;
                    // Add a small padding to the clickable region so the arrow glyph
                    // and adjacent spacing are reliably clickable across terminals.
                    let item_rect = Rect {
                        x: x_cursor,
                        y: area.y,
                        width: w + 1,
                        height: 1,
                    };
                    click_state.item_clicks.push((item_rect, command.clone()));
                    x_cursor += w + 1;
                    left_spans.push(Span::styled(
                        full,
                        base_style.add_modifier(Modifier::UNDERLINED),
                    ));
                }
                StatusItem::Action { label, command } => {
                    let text = truncate(label, 20);
                    let w = unicode_width::UnicodeWidthStr::width(text.as_str()) as u16;
                    let item_rect = Rect {
                        x: x_cursor,
                        y: area.y,
                        width: w + 1,
                        height: 1,
                    };
                    click_state.item_clicks.push((item_rect, command.clone()));
                    x_cursor += w + 1;
                    left_spans.push(Span::styled(
                        text,
                        base_style.add_modifier(Modifier::BOLD),
                    ));
                }
            }
        }

        // --- Build right side: task status ---
        // Strategy: pre-build all strings first, measure actual char widths,
        // then compute positions in a single pass — no manual width accounting.
        struct RightEntry {
            task_id: crate::task_registry::TaskId,
            sep:     String, // "  "
            ind:     String, // "● " / "✓ " etc.
            label:   String,
            cancel:  Option<String>, // " ⊘" for running tasks only
            style:   Style,
        }

        let mut entries: Vec<RightEntry> = Vec::new();
        let mut shown_queues: std::collections::HashSet<crate::task_registry::TaskQueueId> = std::collections::HashSet::new();

        // 1. Currently running tasks: prefer these and mark their queues as shown.
        for (queue_id, &task_id) in task_registry.running_tasks() {
            if let Some(task) = task_registry.get(task_id) {
                let raw = format!("{}: {}", queue_id.0, task.command);
                let (indicator, style) = task_status_style(task.status.clone(), theme);
                entries.push(RightEntry {
                    task_id,
                    sep:    "  ".into(),
                    ind:    format!("{} ", indicator),
                    label:  truncate(&raw, 25),
                    cancel: Some(" ⊘".into()),
                    style,
                });
                shown_queues.insert(queue_id.clone());
            }
        }

        // 2. Recently finished tasks: show at most one per queue, skipping queues
        // already represented by a running task.
        for task_id in task_registry.recently_finished_tasks() {
            if let Some(task) = task_registry.get(task_id) {
                if shown_queues.contains(&task.key.queue) {
                    continue;
                }
                let raw = format!("{}: {}", task.key.queue.0, task.command);
                let (indicator, style) = task_status_style(task.status.clone(), theme);
                entries.push(RightEntry {
                    task_id,
                    sep:    "  ".into(),
                    ind:    format!("{} ", indicator),
                    label:  truncate(&raw, 25),
                    cancel: None,
                    style,
                });
                shown_queues.insert(task.key.queue.clone());
            }
        }

        // Total rendered width (columns).
        let right_total_w: u16 = entries.iter().map(|e| {
            unicode_width::UnicodeWidthStr::width(e.sep.as_str())
            + unicode_width::UnicodeWidthStr::width(e.ind.as_str())
            + unicode_width::UnicodeWidthStr::width(e.label.as_str())
            + e.cancel.as_deref().map(unicode_width::UnicodeWidthStr::width).unwrap_or(0)
        }).sum::<usize>() as u16;

        // Left side occupies up to x_cursor; leave a minimum 2-col gap.
        // Skip right content entirely if there isn't enough room.
        let min_right_x = x_cursor + 2;
        // Use area.x + area.width - right_total_w to compute the left edge.
        // area.right() is x + width - 1 which causes an off-by-one when
        // subtracting the total width.  Use saturating_add/saturating_sub for safety.
        let right_x_start = area.x.saturating_add(area.width.saturating_sub(right_total_w));
        let right_fits = right_total_w > 0
            && right_x_start >= min_right_x
            && right_total_w <= area.width;

        let mut right_spans: Vec<Span> = Vec::new();
        if right_fits {
            let mut rx = right_x_start;
            for e in &entries {
                // Separator.
                right_spans.push(Span::styled(e.sep.clone(), base_style));
                rx += unicode_width::UnicodeWidthStr::width(e.sep.as_str()) as u16;

                // Indicator.
                right_spans.push(Span::styled(e.ind.clone(), e.style.bg(bg)));
                rx += unicode_width::UnicodeWidthStr::width(e.ind.as_str()) as u16;

                // Label — clickable.
                let label_w = unicode_width::UnicodeWidthStr::width(e.label.as_str()) as u16;
                click_state.task_label_clicks.push((
                    Rect { x: rx, y: area.y, width: label_w, height: 1 },
                    e.task_id,
                ));
                right_spans.push(Span::styled(
                    e.label.clone(),
                    e.style.bg(bg).add_modifier(Modifier::UNDERLINED),
                ));
                rx += label_w;

                // Cancel button (running only).
                if let Some(ref cancel_str) = e.cancel {
                    let cancel_w = unicode_width::UnicodeWidthStr::width(cancel_str.as_str()) as u16;
                    click_state.cancel_clicks.push((
                        Rect { x: rx, y: area.y, width: cancel_w, height: 1 },
                        e.task_id,
                    ));
                    right_spans.push(Span::styled(cancel_str.clone(), e.style.bg(bg)));
                    rx += cancel_w;
                }
            }
        }

        // --- Render ---
        // Fill the whole row with the background first.
        frame.render_widget(
            Paragraph::new(Line::from(vec![Span::styled(
                " ".repeat(area.width as usize),
                base_style,
            )])),
            area,
        );

        // Left side.
        if !left_spans.is_empty() {
            let left_line = Line::from(left_spans);
            let left_area = Rect { x: area.x + 1, width: area.width.saturating_sub(2), ..area };
            frame.render_widget(Paragraph::new(left_line), left_area);
        }

        // Right side (task status).
        if !right_spans.is_empty() {
            let right_area = Rect {
                x: right_x_start,
                y: area.y,
                width: right_total_w,
                height: 1,
            };
            frame.render_widget(Paragraph::new(Line::from(right_spans)), right_area);
        }

        click_state
    }
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn truncate(s: &str, max_chars: usize) -> String {
    let chars: Vec<char> = s.chars().collect();
    if chars.len() <= max_chars {
        s.to_owned()
    } else {
        chars[..max_chars.saturating_sub(1)].iter().collect::<String>() + "…"
    }
}

fn task_status_style(status: TaskStatus, theme: &crate::theme::Theme) -> (&'static str, Style) {
    match status {
        TaskStatus::Running  => ("●", Style::default().fg(theme.fg())),
        TaskStatus::Success  => ("✓", Style::default().fg(theme.level_success())),
        TaskStatus::Warning  => ("⚠", Style::default().fg(theme.level_warn())),
        TaskStatus::Error    => ("✗", Style::default().fg(theme.level_error())),
        TaskStatus::Cancelled => ("—", Style::default().fg(theme.fg_dim())),
        TaskStatus::Pending  => ("○", Style::default().fg(theme.fg_dim())),
    }
}