improvise/src/ui/category_panel.rs

use ratatui::{
    buffer::Buffer,
    layout::Rect,
    style::{Color, Modifier, Style},
    widgets::{Block, Borders, Widget},
};

use crate::model::Model;
use crate::ui::app::AppMode;
use crate::view::Axis;

fn axis_display(axis: Axis) -> (&'static str, Color) {
    match axis {
        Axis::Row => ("Row ↕", Color::Green),
        Axis::Column => ("Col ↔", Color::Blue),
        Axis::Page => ("Page ☰", Color::Magenta),
        Axis::None => ("None ∅", Color::DarkGray),
    }
}

pub struct CategoryPanel<'a> {
    pub model: &'a Model,
    pub mode: &'a AppMode,
    pub cursor: usize,
}

impl<'a> CategoryPanel<'a> {
    pub fn new(model: &'a Model, mode: &'a AppMode, cursor: usize) -> Self {
        Self {
            model,
            mode,
            cursor,
        }
    }
}

impl<'a> Widget for CategoryPanel<'a> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        let is_item_add = matches!(self.mode, AppMode::ItemAdd { .. });
        let is_cat_add = matches!(self.mode, AppMode::CategoryAdd { .. });
        let is_active = matches!(self.mode, AppMode::CategoryPanel) || is_item_add || is_cat_add;

        let (border_color, title) = if is_cat_add {
            (
                Color::Yellow,
                " Categories — New category (Enter:add  Esc:done) ",
            )
        } else if is_item_add {
            (
                Color::Green,
                " Categories — Adding items (Enter:add  Esc:done) ",
            )
        } else if is_active {
            (Color::Cyan, " Categories  n:new  a:add-items  Space:axis ")
        } else {
            (Color::DarkGray, " Categories ")
        };

        let block = Block::default()
            .borders(Borders::ALL)
            .border_style(Style::default().fg(border_color))
            .title(title);
        let inner = block.inner(area);
        block.render(area, buf);

        let view = self.model.active_view();

        let cat_names: Vec<&str> = self.model.category_names();
        if cat_names.is_empty() {
            buf.set_string(
                inner.x,
                inner.y,
                "(no categories — use :add-cat <name>)",
                Style::default().fg(Color::DarkGray),
            );
            return;
        }

        // How many rows for the list vs the prompt at bottom
        let prompt_rows = if is_item_add { 2u16 } else { 0 };
        let list_height = inner.height.saturating_sub(prompt_rows);

        for (i, cat_name) in cat_names.iter().enumerate() {
            if i as u16 >= list_height {
                break;
            }
            let y = inner.y + i as u16;

            let (axis_str, axis_color) = axis_display(view.axis_of(cat_name));

            let item_count = self
                .model
                .category(cat_name)
                .map(|c| c.items.len())
                .unwrap_or(0);

            // Highlight the selected category both in CategoryPanel and ItemAdd modes
            let is_selected_cat = if is_item_add {
                if let AppMode::ItemAdd { category, .. } = self.mode {
                    *cat_name == category.as_str()
                } else {
                    false
                }
            } else {
                i == self.cursor && is_active
            };

            let base_style = if is_selected_cat {
                Style::default()
                    .fg(Color::Black)
                    .bg(Color::Cyan)
                    .add_modifier(Modifier::BOLD)
            } else {
                Style::default()
            };

            if is_selected_cat {
                let fill = " ".repeat(inner.width as usize);
                buf.set_string(inner.x, y, &fill, base_style);
            }

            let name_part = format!(" {cat_name} ({item_count})");
            let axis_part = format!(" [{axis_str}]");

            buf.set_string(inner.x, y, &name_part, base_style);
            if name_part.len() + axis_part.len() < inner.width as usize {
                buf.set_string(
                    inner.x + name_part.len() as u16,
                    y,
                    &axis_part,
                    if is_selected_cat {
                        base_style
                    } else {
                        Style::default().fg(axis_color)
                    },
                );
            }
        }

        // Inline prompt at the bottom for CategoryAdd or ItemAdd
        let (prompt_color, prompt_text) = match self.mode {
            AppMode::CategoryAdd { buffer } => (Color::Yellow, format!(" + category: {buffer}▌")),
            AppMode::ItemAdd { buffer, .. } => (Color::Green, format!(" + item: {buffer}▌")),
            _ => return,
        };

        let sep_y = inner.y + list_height;
        let prompt_y = sep_y + 1;
        if sep_y < inner.y + inner.height {
            let sep = "─".repeat(inner.width as usize);
            buf.set_string(inner.x, sep_y, &sep, Style::default().fg(prompt_color));
        }
        if prompt_y < inner.y + inner.height {
            buf.set_string(
                inner.x,
                prompt_y,
                &prompt_text,
                Style::default()
                    .fg(prompt_color)
                    .add_modifier(Modifier::BOLD),
            );
        }
    }
}