tix-tracker 0.2.0

//! Settings modal widget (FR: board/column configuration).
//!
//! A centered modal editing the act board's columns: a multiple-choice
//! checkbox list (visible/hidden) plus inline prompts to add a column, create
//! a board, or delete the current board. Like `filter_modal`, this widget is a
//! **pure view + model**: it does not read keys or mutate the config — the app
//! routes keys and applies mutations (`App::handle_settings_key`).

use ratatui::Frame;
use ratatui::layout::Rect;
use ratatui::style::{Color, Modifier, Style};
use ratatui::text::Line;
use ratatui::widgets::{Block, Borders, Clear, Paragraph};

use super::modal::modal_rect;

/// An active inline prompt inside the settings modal.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SettingsPrompt {
    /// Naming a new column (`a`).
    AddColumn(String),
    /// Naming a new board (`n`).
    NewBoard(String),
    /// Confirming deletion of the current board (`x`).
    ConfirmDeleteBoard(String),
}

/// The settings modal: a cursor over the column checkbox rows plus an optional
/// inline prompt.
#[derive(Debug, Clone, Default)]
pub struct SettingsModal {
    /// Row cursor over the board's columns.
    pub selected: usize,
    /// Active inline prompt (None = browsing the checkbox list).
    pub prompt: Option<SettingsPrompt>,
}

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

    /// Move the row cursor (clamped to `column_count`).
    pub fn move_selected(&mut self, delta: isize, column_count: usize) {
        if column_count == 0 {
            self.selected = 0;
            return;
        }
        let next = self.selected as isize + delta;
        self.selected = next.clamp(0, column_count as isize - 1) as usize;
    }

    /// Render the settings modal over `area` for the given board.
    pub fn render(
        &self,
        f: &mut Frame,
        area: Rect,
        board_name: &str,
        columns: &[String],
        hidden: &[String],
    ) {
        let rect = modal_rect(area);
        let mut rows: Vec<Line> = Vec::new();

        for (i, col) in columns.iter().enumerate() {
            let is_hidden = hidden.iter().any(|h| h == col);
            let mark = if is_hidden { "[ ]" } else { "[x]" };
            let cursor = if i == self.selected { "> " } else { "  " };
            let style = if i == self.selected {
                Style::default()
                    .fg(Color::Yellow)
                    .add_modifier(Modifier::BOLD)
            } else {
                Style::default().fg(Color::White)
            };
            let hidden_suffix = if is_hidden { " (hidden)" } else { "" };
            rows.push(Line::from(vec![
                ratatui::text::Span::styled(cursor, style),
                ratatui::text::Span::styled(format!("{mark} {col}{hidden_suffix}"), style),
            ]));
        }

        if let Some(prompt) = &self.prompt {
            rows.push(Line::from(""));
            let line = match prompt {
                SettingsPrompt::AddColumn(buffer) => format!("New column: {buffer}_"),
                SettingsPrompt::NewBoard(buffer) => format!("New board: {buffer}_"),
                SettingsPrompt::ConfirmDeleteBoard(name) => {
                    format!("Delete board '{name}'? [y/N]")
                }
            };
            rows.push(Line::from(ratatui::text::Span::styled(
                line,
                Style::default().fg(Color::Cyan),
            )));
        } else {
            rows.push(Line::from(""));
            rows.push(Line::from(ratatui::text::Span::styled(
                "Space: toggle · a: new column · n: new board · x: delete board · Tab: switch · q: close",
                Style::default().fg(Color::DarkGray),
            )));
        }

        let block = Block::default()
            .borders(Borders::ALL)
            .title(format!(" Settings — {board_name} "))
            .style(Style::default().fg(Color::Cyan));
        let para = Paragraph::new(rows).block(block).style(Style::default());
        f.render_widget(Clear, rect);
        f.render_widget(para, rect);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use ratatui::Terminal;
    use ratatui::backend::TestBackend;

    fn render_smoke(prompt: Option<SettingsPrompt>, w: u16, h: u16) {
        let backend = TestBackend::new(w, h);
        let mut terminal = Terminal::new(backend).unwrap();
        let modal = SettingsModal {
            selected: 1,
            prompt,
        };
        let columns = vec!["todo".to_string(), "done".to_string()];
        let hidden = vec!["done".to_string()];
        terminal
            .draw(|f| modal.render(f, f.area(), "default", &columns, &hidden))
            .unwrap();
    }

    #[test]
    fn renders_at_80x24() {
        render_smoke(None, 80, 24);
    }

    #[test]
    fn renders_prompt_at_80x24() {
        render_smoke(Some(SettingsPrompt::AddColumn("".into())), 80, 24);
    }

    #[test]
    fn renders_at_tiny_20x5() {
        render_smoke(None, 20, 5);
    }

    #[test]
    fn move_selected_clamps_within_columns() {
        let mut modal = SettingsModal::new();
        modal.move_selected(-1, 3);
        assert_eq!(modal.selected, 0);
        modal.move_selected(5, [0usize, 1, 2, 3].len());
        assert_eq!(modal.selected, 3);
        modal.move_selected(1, 0);
        assert_eq!(modal.selected, 0);
    }

    #[test]
    fn defaults_to_first_row() {
        assert_eq!(SettingsModal::new().selected, 0);
        assert_eq!(SettingsModal::new().prompt, None);
    }
}