tix-tracker 0.5.0

//! The Config mode surface (FR: board/column configuration, tui-config-mode).
//!
//! One sectioned view over the three configuration areas — **dashboards**,
//! **cycles**, and **milestones** — reached with F12. The dashboards section is
//! the former settings modal's row list (column visibility checkboxes, the
//! display toggles, and the `$EDITOR` override); the cycles and milestones
//! sections render the same [`PlanningRow`]s the planning surface does, through
//! the same `rows_lines` helper, so the two surfaces cannot disagree.
//!
//! 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`). It does record its click targets through
//! [`App::record_region`] so pointer hits run the same actions the keys do
//! (D3/D6).

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 crate::app::{Action, App};
use crate::keybindings::{EffectiveBindings, InputContext};
use crate::ui::planning::{PlanningRow, prompt_line, rows_lines};

/// Number of non-column rows in the dashboards section: the display settings
/// (title wrap toggle, line limit, ordering). The app uses this to size the
/// browse cursor and to route toggles; the widget uses it to render the rows.
pub const DISPLAY_ROWS: usize = 3;

/// Non-column rows beyond the display toggles: the `$EDITOR` override and the
/// read-only viewer, both `tix.toml` settings rather than per-record metadata
/// files.
pub const GENERAL_ROWS: usize = 2;

/// Every row in the dashboards section: the board's columns, the display
/// toggles, and the general settings.
pub fn board_rows_len(board: &crate::config::BoardConfiguration) -> usize {
    board.columns.len() + DISPLAY_ROWS + GENERAL_ROWS
}

/// The width of the section rail, in columns. Wide enough for "Milestones"
/// plus the cursor and border.
pub const SECTION_RAIL_WIDTH: u16 = 18;

/// The body area to the right of the section rail, where a section's rows are
/// drawn. Shared by the renderer and the pointer-hit tests so the two never
/// compute different geometry.
pub fn config_body_rect(area: Rect) -> Rect {
    let rail = SECTION_RAIL_WIDTH.min(area.width);
    Rect {
        x: area.x + rail,
        width: area.width - rail,
        ..area
    }
}

/// One configuration section of the Config mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ConfigSection {
    /// Boards: columns, display toggles, and the editor override.
    #[default]
    Dashboards,
    /// Cycles, from `docs/cycles/` (or legacy `tix.toml`).
    Cycles,
    /// Milestones, from `docs/milestones/`.
    Milestones,
}

impl ConfigSection {
    /// The sections, in rail order.
    pub const ALL: [Self; 3] = [Self::Dashboards, Self::Cycles, Self::Milestones];

    /// The rail label.
    pub const fn label(self) -> &'static str {
        match self {
            Self::Dashboards => "Dashboards",
            Self::Cycles => "Cycles",
            Self::Milestones => "Milestones",
        }
    }

    /// The next section, wrapping.
    pub fn next(self) -> Self {
        match self {
            Self::Dashboards => Self::Cycles,
            Self::Cycles => Self::Milestones,
            Self::Milestones => Self::Dashboards,
        }
    }

    /// The previous section, wrapping.
    pub fn prev(self) -> Self {
        match self {
            Self::Dashboards => Self::Milestones,
            Self::Cycles => Self::Dashboards,
            Self::Milestones => Self::Cycles,
        }
    }

    /// The section's position in the rail.
    pub const fn index(self) -> usize {
        match self {
            Self::Dashboards => 0,
            Self::Cycles => 1,
            Self::Milestones => 2,
        }
    }
}

/// Which of the Config mode's two panes holds the focus.
///
/// The surface is the standard two-pane shape: the **section rail** on the
/// left and the active section's **body** on the right. `h`/`l` (and
/// `←`/`→`) move the focus between them, clamped at the ends; `j`/`k` (and
/// `↓`/`↑`) move inside whichever pane is focused — the selected section in
/// the rail, the row cursor in the body.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ConfigPane {
    /// The left rail: the sections (Dashboards / Cycles / Milestones).
    #[default]
    Sections,
    /// The right body: the active section's rows.
    Body,
}

impl ConfigPane {
    /// The pane's position on the horizontal axis, left to right.
    pub const fn index(self) -> usize {
        match self {
            Self::Sections => 0,
            Self::Body => 1,
        }
    }
}

/// The dashboards section's data: the active board, its name, and the
/// `$EDITOR` override. Bundled so the render entry points stay within a sane
/// argument count.
#[derive(Debug, Clone, Copy)]
pub struct DashboardView<'a> {
    /// The active board's name.
    pub name: &'a str,
    /// The active board's configuration.
    pub board: &'a crate::config::BoardConfiguration,
    /// The configured editor override, if any.
    pub editor: Option<&'a str>,
    /// The Viewer row's label: the configured override, or the resolved auto
    /// viewer (tix #1507).
    pub viewer: &'a str,
}

/// An active inline prompt inside the Config mode.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SettingsPrompt {
    /// Naming a new column (`a`).
    AddColumn(String),
    /// Naming a new board (`n`).
    NewBoard(String),
    /// Renaming the current board (`e`), seeded with its current name.
    RenameBoard {
        /// The board's current name.
        old: String,
        /// The in-progress new name.
        buffer: String,
    },
    /// Confirming deletion of the current board (`x`), naming how many issues
    /// reference it (always 0 today: nothing in issue frontmatter names a
    /// board, but the count is reported rather than assumed).
    ConfirmDeleteBoard {
        /// The board's name.
        name: String,
        /// Issues that reference the board (0 — see the variant docs).
        referencing: usize,
    },
    /// Setting the `$EDITOR` override in `tix.toml`.
    SetEditor(String),
    /// Setting the read-only `viewer` of the TUI's `v` key in `tix.toml`
    /// (tix #1507).
    SetViewer(String),
}

/// The Config mode's cursor state: the active section, the focused pane, the
/// dashboards row cursor, and an optional inline prompt.
#[derive(Debug, Clone, Default)]
pub struct SettingsModal {
    /// Row cursor within the dashboards section (a board's columns, then the
    /// display toggles, then the general rows).
    pub selected: usize,
    /// Active inline prompt (None = browsing the checkbox list).
    pub prompt: Option<SettingsPrompt>,
    /// The active section.
    pub section: ConfigSection,
    /// Which pane holds the focus (the section rail or the body).
    pub pane: ConfigPane,
}

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

    /// Focus `pane` (an `h`/`l` step, or a click on that pane).
    pub fn focus(&mut self, pane: ConfigPane) {
        self.pane = pane;
    }

    /// Move the pane focus `delta` panes along the horizontal axis, clamped at
    /// the ends (`Sections` on the left, `Body` on the right) rather than
    /// wrapping — the same rule the board's columns follow.
    pub fn move_pane(&mut self, delta: isize) {
        let next = self.pane.index() as isize + delta;
        self.pane = if next <= 0 {
            ConfigPane::Sections
        } else {
            ConfigPane::Body
        };
    }

    /// Switch to `section`, putting the dashboards cursor back at the top when
    /// the section changes (the cursor is per-section state).
    pub fn set_section(&mut self, section: ConfigSection) {
        if self.section != section {
            self.section = section;
            self.selected = 0;
        }
    }

    /// Move the row cursor (clamped to `total_rows`, i.e. the board's columns
    /// plus [`DISPLAY_ROWS`] and [`GENERAL_ROWS`]).
    pub fn move_selected(&mut self, delta: isize, total_rows: usize) {
        if total_rows == 0 {
            self.selected = 0;
            return;
        }
        let next = self.selected as isize + delta;
        self.selected = next.clamp(0, total_rows as isize - 1) as usize;
    }

    /// Jump the row cursor straight to `row` (a row click, D6), clamped to the
    /// same range the arrow keys navigate.
    pub fn move_selected_to(&mut self, row: usize, total_rows: usize) {
        if total_rows == 0 {
            self.selected = 0;
            return;
        }
        self.selected = row.min(total_rows - 1);
    }

    /// Render the dashboards rows into `rect`: the column checkboxes, the
    /// display toggles, the general rows, and the active prompt. Shared by the
    /// Config mode's dashboards section and the widget's own tests.
    ///
    /// `focused` is whether the body pane holds the Config mode's focus; the
    /// focused pane's border is accented and the other pane's is dimmed, so the
    /// two panes read apart at a glance.
    pub fn render_body(
        &self,
        f: &mut Frame,
        rect: Rect,
        view: DashboardView<'_>,
        bindings: &EffectiveBindings,
        focused: bool,
    ) {
        let DashboardView {
            name: board_name,
            board,
            editor,
            viewer,
        } = view;
        let context = InputContext::Settings;
        let columns = &board.columns;
        let hidden = &board.hidden_columns;
        let wrap_titles = board.wrap_titles;
        let title_lines = board.title_lines;
        let order_by = board.order_by;
        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 = row_style(i == self.selected);
            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),
            ]));
        }

        let display_texts = [
            format!("Wrap titles: {}", if wrap_titles { "[x]" } else { "[ ]" }),
            format!("Title lines: {title_lines}"),
            format!("Order by: {}", order_by.as_str()),
            format!("Editor: {}", editor.unwrap_or("(default)")),
            format!("Viewer: {viewer}"),
        ];
        for (row, text) in display_texts.into_iter().enumerate() {
            let idx = columns.len() + row;
            let style = row_style(idx == self.selected);
            let cursor = if idx == self.selected { "> " } else { "  " };
            rows.push(Line::from(vec![
                ratatui::text::Span::styled(cursor, style),
                ratatui::text::Span::styled(text, 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::RenameBoard { buffer, .. } => {
                    format!("Rename board to: {buffer}_")
                }
                SettingsPrompt::ConfirmDeleteBoard { name, referencing } => format!(
                    "Delete board '{name}'? {referencing} {} reference it. [y/N]",
                    crate::ui::planning::issues_word(*referencing)
                ),
                SettingsPrompt::SetEditor(buffer) => format!("Editor: {buffer}_"),
                SettingsPrompt::SetViewer(buffer) => format!("Viewer: {buffer}_"),
            };
            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(
                format!(
                    "{}: toggle · {}: new column · {}: activate row · {}: new board · {}: rename board · {}: delete board · {}: switch board · {} / {}: pane · {}: close",
                    bindings.label(context, crate::keybindings::TuiAction::Toggle),
                    bindings.label(context, crate::keybindings::TuiAction::AddColumn),
                    bindings.label(context, crate::keybindings::TuiAction::Submit),
                    bindings.label(context, crate::keybindings::TuiAction::NewBoard),
                    bindings.label(context, crate::keybindings::TuiAction::EditPlanningItem),
                    bindings.label(context, crate::keybindings::TuiAction::Delete),
                    bindings.label(context, crate::keybindings::TuiAction::NextBoard),
                    bindings.label(context, crate::keybindings::TuiAction::MoveLeft),
                    bindings.label(context, crate::keybindings::TuiAction::MoveRight),
                    bindings.label(context, crate::keybindings::TuiAction::Close),
                ),
                Style::default().fg(Color::DarkGray),
            )));
        }

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

fn row_style(selected: bool) -> Style {
    if selected {
        Style::default()
            .fg(Color::Yellow)
            .add_modifier(Modifier::BOLD)
    } else {
        Style::default().fg(Color::White)
    }
}

/// A pane's border/title style: the focused pane is accented, the unfocused
/// one dimmed. The pane that owns the keys is visible at a glance, and the
/// focused pane's selected entry keeps the [`row_style`] cursor.
fn pane_style(focused: bool) -> Style {
    if focused {
        Style::default().fg(Color::Yellow)
    } else {
        Style::default().fg(Color::DarkGray)
    }
}

/// Render the Config mode: the section rail on the left and the active
/// section's body to its right. Records a click target per rail entry and per
/// body row so pointer hits run the same actions the keys do (D3/D6).
pub fn render_config(
    app: &App,
    f: &mut Frame,
    area: Rect,
    view: DashboardView<'_>,
    cycles: &[PlanningRow],
    milestones: &[PlanningRow],
) {
    let Some(modal) = app.settings.as_ref() else {
        return;
    };
    let body_focused = modal.pane == ConfigPane::Body;
    render_section_rail(
        app,
        f,
        area,
        modal.section,
        modal.pane == ConfigPane::Sections,
    );
    let body = config_body_rect(area);
    match modal.section {
        ConfigSection::Dashboards => {
            modal.render_body(f, body, view, &app.bindings, body_focused);
            for row in 0..board_rows_len(view.board) {
                app.record_region(body_row_rect(body, row), Action::SettingsRow(row));
            }
        }
        ConfigSection::Cycles => {
            render_planning_section(app, f, body, "Cycles", cycles, body_focused);
        }
        ConfigSection::Milestones => {
            render_planning_section(app, f, body, "Milestones", milestones, body_focused);
        }
    }
}

/// The click target of dashboards row `row`: the body's first inner line is row
/// 0, exactly where [`SettingsModal::render_body`] draws it.
fn body_row_rect(body: Rect, row: usize) -> Rect {
    Rect {
        x: body.x + 1,
        y: body.y + 1 + row as u16,
        width: body.width.saturating_sub(2),
        height: 1,
    }
}

/// The section rail: the three sections as a vertical list, the active one
/// highlighted, each entry a click target. `focused` accents the rail's border
/// when it holds the Config mode's focus.
fn render_section_rail(app: &App, f: &mut Frame, area: Rect, active: ConfigSection, focused: bool) {
    let rail = Rect {
        width: SECTION_RAIL_WIDTH.min(area.width),
        ..area
    };
    let mut lines: Vec<Line> = Vec::new();
    for section in ConfigSection::ALL {
        let style = if section == active {
            row_style(true)
        } else if app.is_hovered(&Action::ConfigSection(section)) {
            // Hover highlight only — the active section is untouched.
            Style::default()
                .fg(Color::Black)
                .bg(Color::DarkGray)
                .add_modifier(Modifier::BOLD)
        } else {
            row_style(false)
        };
        let cursor = if section == active { "> " } else { "  " };
        lines.push(Line::from(vec![
            ratatui::text::Span::styled(cursor, style),
            ratatui::text::Span::styled(section.label(), style),
        ]));
    }
    let block = Block::default()
        .borders(Borders::ALL)
        .title(" Sections ")
        .style(pane_style(focused));
    f.render_widget(Paragraph::new(lines).block(block), rail);
    for section in ConfigSection::ALL {
        let hit = Rect {
            x: rail.x + 1,
            y: rail.y + 1 + section.index() as u16,
            width: rail.width.saturating_sub(2),
            height: 1,
        };
        app.record_region(hit, Action::ConfigSection(section));
    }
}

/// Render one of the Config mode's planning sections (cycles or milestones):
/// the same rows and prompt the planning surface draws, plus this mode's key
/// hints. Records a click target per row. `focused` accents the border when the
/// body pane holds the Config mode's focus.
fn render_planning_section(
    app: &App,
    f: &mut Frame,
    body: Rect,
    label: &str,
    rows: &[PlanningRow],
    focused: bool,
) {
    let selected = app.planning.as_ref().map(|p| p.selected).unwrap_or(0);
    let prompt = app.planning.as_ref().and_then(|p| p.prompt.as_ref());
    let inner = body.height.saturating_sub(2) as usize;
    let view_h = inner.saturating_sub(2);

    let mut lines: Vec<Line> = Vec::new();
    if rows.is_empty() {
        if prompt.is_none() {
            lines.push(Line::from(format!(
                "No {} yet — press n to create one.",
                label.to_lowercase()
            )));
        }
    } else {
        lines.extend(rows_lines(rows, selected, view_h));
    }
    lines.push(Line::from(""));
    match prompt {
        Some(prompt) => lines.push(prompt_line(prompt)),
        None => lines.push(Line::from(ratatui::text::Span::styled(
            format!(
                "{}: new · {}: edit · {}: delete · {}: activate row · {} / {}: pane · {}: close",
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::NewBoard
                ),
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::EditPlanningItem
                ),
                // `delete` is the bound action in this context (x / Shift+X).
                // `delete_planning_item` is the planning surface's own name for the
                // same key and is not bound here, so its label would be "—".
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::Delete
                ),
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::Submit
                ),
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::MoveLeft
                ),
                app.bindings.label(
                    InputContext::Settings,
                    crate::keybindings::TuiAction::MoveRight
                ),
                app.bindings
                    .label(InputContext::Settings, crate::keybindings::TuiAction::Close),
            ),
            Style::default().fg(Color::DarkGray),
        ))),
    }

    let block = Block::default()
        .borders(Borders::ALL)
        .title(format!(" {label} — {} items ", rows.len()))
        .style(pane_style(focused));
    f.render_widget(Paragraph::new(lines).block(block), body);
    // Rows are drawn from the body's first inner line, so a click on row `i`
    // resolves to `ConfigPlanningRow(i)` — the same index the cursor uses.
    for i in 0..rows.len() {
        app.record_region(body_row_rect(body, i), Action::ConfigPlanningRow(i));
    }
}

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

    /// Draw the dashboards body in the old centered modal geometry and return
    /// the terminal, so a test can inspect the buffer.
    fn draw(
        modal: &SettingsModal,
        board: &crate::config::BoardConfiguration,
        w: u16,
        h: u16,
    ) -> Terminal<TestBackend> {
        draw_focused(modal, board, w, h, false)
    }

    /// [`draw`], with the body's pane-focus flag under test's control.
    fn draw_focused(
        modal: &SettingsModal,
        board: &crate::config::BoardConfiguration,
        w: u16,
        h: u16,
        focused: bool,
    ) -> Terminal<TestBackend> {
        let backend = TestBackend::new(w, h);
        let mut terminal = Terminal::new(backend).unwrap();
        let bindings =
            crate::keybindings::KeyBindings::resolve(&crate::keybindings::KeyBindings::default())
                .expect("built-in bindings are valid");
        terminal
            .draw(|f| {
                modal.render_body(
                    f,
                    modal_rect(f.area()),
                    DashboardView {
                        name: "default",
                        board,
                        editor: None,
                        viewer: "mdterm (auto)",
                    },
                    &bindings,
                    focused,
                );
            })
            .unwrap();
        terminal
    }

    fn rows_of(terminal: &Terminal<TestBackend>) -> Vec<String> {
        let buffer = terminal.backend().buffer();
        (0..buffer.area().height)
            .map(|y| {
                (0..buffer.area().width)
                    .map(|x| buffer[(x, y)].symbol().chars().next().unwrap_or(' '))
                    .collect()
            })
            .collect()
    }

    fn test_board() -> crate::config::BoardConfiguration {
        crate::config::BoardConfiguration {
            columns: vec!["todo".to_string(), "done".to_string()],
            hidden_columns: vec!["done".to_string()],
            ..Default::default()
        }
    }

    fn render_smoke(prompt: Option<SettingsPrompt>, w: u16, h: u16) {
        let modal = SettingsModal {
            selected: 1,
            prompt,
            ..SettingsModal::default()
        };
        let _ = draw(&modal, &test_board(), w, h);
    }

    #[test]
    fn renders_display_rows_after_columns() {
        let modal = SettingsModal {
            selected: 2,
            prompt: None,
            ..SettingsModal::default()
        };
        let board = crate::config::BoardConfiguration {
            columns: vec!["todo".to_string(), "done".to_string()],
            hidden_columns: vec![],
            wrap_titles: false,
            title_lines: 5,
            order_by: crate::config::OrderBy::None,
            ..Default::default()
        };
        let terminal = draw(&modal, &board, 80, 24);
        let buffer = terminal.backend().buffer();
        let rows = rows_of(&terminal);

        let row_of =
            |needle: &str| -> Option<usize> { rows.iter().position(|r| r.contains(needle)) };

        let wrap_row = row_of("Wrap titles: [ ]").expect("wrap row shows unchecked mark");
        let lines_row = row_of("Title lines: 5").expect("line-limit row shows the value");
        let order_row = row_of("Order by: none").expect("ordering row shows the value");
        let editor_row = row_of("Editor: (default)").expect("general row shows the editor");
        let viewer_row = row_of("Viewer: mdterm (auto)").expect("general row shows the viewer");
        assert!(
            wrap_row < lines_row
                && lines_row < order_row
                && order_row < editor_row
                && editor_row < viewer_row,
            "display and general rows render beneath the columns in order"
        );

        // The selected display row (selected=2 → first display row) is highlighted.
        assert!(
            rows[wrap_row].contains('>'),
            "selected display row shows the cursor: {:?}",
            rows[wrap_row]
        );
        assert!(
            !rows[lines_row].contains('>'),
            "unselected display row has no cursor: {:?}",
            rows[lines_row]
        );
        let selection_x = rows[wrap_row].find('>').expect("cursor sits in the row") as u16;
        let selected = &buffer[(selection_x + 2, wrap_row as u16)];
        assert_eq!(selected.fg, Color::Yellow, "selected row gets cursor style");
    }

    #[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_rename_and_delete_prompts_at_80x24() {
        render_smoke(
            Some(SettingsPrompt::RenameBoard {
                old: "default".into(),
                buffer: "ops".into(),
            }),
            80,
            24,
        );
        render_smoke(
            Some(SettingsPrompt::ConfirmDeleteBoard {
                name: "default".into(),
                referencing: 0,
            }),
            80,
            24,
        );
        render_smoke(Some(SettingsPrompt::SetEditor("nvim".into())), 80, 24);
        render_smoke(Some(SettingsPrompt::SetViewer("less".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);
        assert_eq!(SettingsModal::new().section, ConfigSection::Dashboards);
    }

    #[test]
    fn sections_cycle_in_both_directions_and_wrap() {
        assert_eq!(ConfigSection::Dashboards.next(), ConfigSection::Cycles);
        assert_eq!(ConfigSection::Cycles.next(), ConfigSection::Milestones);
        assert_eq!(ConfigSection::Milestones.next(), ConfigSection::Dashboards);
        assert_eq!(ConfigSection::Dashboards.prev(), ConfigSection::Milestones);
        assert_eq!(ConfigSection::ALL.len(), 3);
    }

    #[test]
    fn set_section_resets_the_row_cursor_only_on_a_change() {
        let mut modal = SettingsModal {
            selected: 2,
            ..SettingsModal::default()
        };
        modal.set_section(ConfigSection::Cycles);
        assert_eq!(modal.selected, 0);
        modal.selected = 1;
        modal.set_section(ConfigSection::Cycles);
        assert_eq!(
            modal.selected, 1,
            "re-selecting the same section keeps the cursor"
        );
    }

    #[test]
    fn board_rows_len_counts_columns_display_and_general_rows() {
        let board = crate::config::BoardConfiguration {
            columns: vec!["todo".into(), "done".into()],
            ..Default::default()
        };
        assert_eq!(board_rows_len(&board), 2 + DISPLAY_ROWS + GENERAL_ROWS);
    }

    #[test]
    fn pane_focus_defaults_to_the_section_rail() {
        let modal = SettingsModal::new();
        assert_eq!(modal.pane, ConfigPane::Sections);
        assert_eq!(ConfigPane::Sections.index(), 0);
        assert_eq!(ConfigPane::Body.index(), 1);
    }

    #[test]
    fn move_pane_clamps_at_both_ends() {
        let mut modal = SettingsModal::new();
        modal.move_pane(1);
        assert_eq!(modal.pane, ConfigPane::Body);
        modal.move_pane(1);
        assert_eq!(modal.pane, ConfigPane::Body, "the right end clamps");
        modal.move_pane(-1);
        assert_eq!(modal.pane, ConfigPane::Sections);
        modal.move_pane(-1);
        assert_eq!(modal.pane, ConfigPane::Sections, "the left end clamps");
        modal.focus(ConfigPane::Body);
        assert_eq!(modal.pane, ConfigPane::Body);
    }

    #[test]
    fn focused_pane_border_is_rendered_distinctly() {
        let board = test_board();
        let modal = SettingsModal::new();
        let focused = draw_focused(&modal, &board, 80, 24, true);
        let unfocused = draw_focused(&modal, &board, 80, 24, false);
        let rect = modal_rect(focused.backend().buffer().area);
        let border = |term: &Terminal<TestBackend>| term.backend().buffer()[(rect.x, rect.y)].fg;
        assert_eq!(
            border(&focused),
            Color::Yellow,
            "the focused pane's border is accented"
        );
        assert_eq!(
            border(&unfocused),
            Color::DarkGray,
            "the unfocused pane's border is dimmed"
        );
        assert_ne!(border(&focused), border(&unfocused));
    }
}