void_graph/widget/

ref_list.rs

//! Reference list widget for branches and tags.
//!
//! Displays a tree-like view of repository references (branches and tags).
//!
//! Adapted from [Serie](https://github.com/lusingander/serie) by lusingander.

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

use crate::color::ColorTheme;
use crate::void_backend::{RefKind, VoidHead, VoidRef};

/// A node in the ref tree.
#[derive(Debug, Clone)]
enum RefNode {
    /// Category header (Branches, Tags)
    Category { name: String, expanded: bool },
    /// Leaf ref (branch or tag)
    Leaf { ref_: VoidRef },
}

/// State for the ref list widget.
#[derive(Debug)]
pub struct RefListState {
    /// All refs
    refs: Vec<VoidRef>,
    /// Current HEAD
    head: Option<VoidHead>,
    /// Flattened visible nodes
    nodes: Vec<RefNode>,
    /// Selected node index
    selected: usize,
    /// Scroll offset
    offset: usize,
    /// Categories expanded state
    branches_expanded: bool,
    tags_expanded: bool,
}

impl RefListState {
    /// Create a new ref list state.
    pub fn new(refs: Vec<VoidRef>, head: Option<VoidHead>) -> Self {
        let branches_expanded = true;
        let tags_expanded = true;

        let mut state = Self {
            refs,
            head,
            nodes: Vec::new(),
            selected: 0,
            offset: 0,
            branches_expanded,
            tags_expanded,
        };
        state.rebuild_nodes();
        state
    }

    /// Rebuild the flattened node list based on expansion state.
    fn rebuild_nodes(&mut self) {
        self.nodes.clear();

        // Branches category
        let branches: Vec<_> = self
            .refs
            .iter()
            .filter(|r| r.kind == RefKind::Branch)
            .cloned()
            .collect();

        if !branches.is_empty() {
            self.nodes.push(RefNode::Category {
                name: "Branches".to_string(),
                expanded: self.branches_expanded,
            });

            if self.branches_expanded {
                for branch in branches {
                    self.nodes.push(RefNode::Leaf { ref_: branch });
                }
            }
        }

        // Tags category
        let tags: Vec<_> = self
            .refs
            .iter()
            .filter(|r| r.kind == RefKind::Tag)
            .cloned()
            .collect();

        if !tags.is_empty() {
            self.nodes.push(RefNode::Category {
                name: "Tags".to_string(),
                expanded: self.tags_expanded,
            });

            if self.tags_expanded {
                for tag in tags {
                    self.nodes.push(RefNode::Leaf { ref_: tag });
                }
            }
        }
    }

    /// Returns true if there are no refs.
    pub fn is_empty(&self) -> bool {
        self.refs.is_empty()
    }

    /// Get the currently selected ref name, if a leaf is selected.
    pub fn selected_ref_name(&self) -> Option<&str> {
        self.nodes.get(self.selected).and_then(|node| match node {
            RefNode::Leaf { ref_ } => Some(ref_.name.as_str()),
            RefNode::Category { .. } => None,
        })
    }

    /// Get the selected ref if a leaf is selected.
    pub fn selected_ref(&self) -> Option<&VoidRef> {
        self.nodes.get(self.selected).and_then(|node| match node {
            RefNode::Leaf { ref_ } => Some(ref_),
            RefNode::Category { .. } => None,
        })
    }

    /// Move selection down.
    pub fn select_next(&mut self, viewport_height: usize) {
        if self.selected < self.nodes.len().saturating_sub(1) {
            self.selected += 1;
            // Adjust scroll if needed
            if self.selected >= self.offset + viewport_height {
                self.offset = self.selected - viewport_height + 1;
            }
        }
    }

    /// Move selection up.
    pub fn select_prev(&mut self) {
        if self.selected > 0 {
            self.selected -= 1;
            // Adjust scroll if needed
            if self.selected < self.offset {
                self.offset = self.selected;
            }
        }
    }

    /// Toggle expansion of selected category.
    pub fn toggle_selected(&mut self) {
        if let Some(RefNode::Category { name, expanded }) = self.nodes.get(self.selected).cloned() {
            if name == "Branches" {
                self.branches_expanded = !expanded;
            } else if name == "Tags" {
                self.tags_expanded = !expanded;
            }
            self.rebuild_nodes();
        }
    }

    /// Jump to first node.
    pub fn select_first(&mut self) {
        self.selected = 0;
        self.offset = 0;
    }

    /// Jump to last node.
    pub fn select_last(&mut self, viewport_height: usize) {
        self.selected = self.nodes.len().saturating_sub(1);
        if self.nodes.len() > viewport_height {
            self.offset = self.nodes.len() - viewport_height;
        }
    }

    /// Check if a ref is the current HEAD branch.
    fn is_head_branch(&self, name: &str) -> bool {
        matches!(&self.head, Some(VoidHead::Branch(b)) if b == name)
    }
}

/// The ref list widget.
pub struct RefList<'a> {
    theme: &'a ColorTheme,
}

impl<'a> RefList<'a> {
    /// Create a new ref list widget.
    pub fn new(theme: &'a ColorTheme) -> Self {
        Self { theme }
    }
}

impl<'a> StatefulWidget for RefList<'a> {
    type State = RefListState;

    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
        let block = Block::default()
            .borders(Borders::ALL)
            .title(" Refs ");
        let inner = block.inner(area);
        block.render(area, buf);

        if state.nodes.is_empty() {
            return;
        }

        let viewport_height = inner.height as usize;

        for (i, idx) in (state.offset..).take(viewport_height).enumerate() {
            if idx >= state.nodes.len() {
                break;
            }

            let node = &state.nodes[idx];
            let is_selected = idx == state.selected;
            let y = inner.y + i as u16;

            let base_style = if is_selected {
                Style::default()
                    .fg(self.theme.ref_selected_fg)
                    .bg(self.theme.ref_selected_bg)
            } else {
                Style::default()
            };

            let line = match node {
                RefNode::Category { name, expanded } => {
                    let arrow = if *expanded { " " } else { " " };
                    Line::from(vec![
                        Span::styled(arrow, base_style.add_modifier(Modifier::BOLD)),
                        Span::styled(name.clone(), base_style.add_modifier(Modifier::BOLD)),
                    ])
                }
                RefNode::Leaf { ref_ } => {
                    let indent = "  ";
                    let color = match ref_.kind {
                        RefKind::Branch => {
                            if state.is_head_branch(&ref_.name) {
                                self.theme.list_head_fg
                            } else {
                                self.theme.list_ref_branch_fg
                            }
                        }
                        RefKind::Tag => self.theme.list_ref_tag_fg,
                    };

                    let name_style = if is_selected {
                        base_style
                    } else {
                        Style::default().fg(color)
                    };

                    let mut spans = vec![Span::styled(indent, base_style)];

                    // Add HEAD marker if this is the current branch
                    if state.is_head_branch(&ref_.name) {
                        spans.push(Span::styled(
                            "* ",
                            if is_selected {
                                base_style.add_modifier(Modifier::BOLD)
                            } else {
                                Style::default()
                                    .fg(self.theme.list_head_fg)
                                    .add_modifier(Modifier::BOLD)
                            },
                        ));
                    }

                    spans.push(Span::styled(ref_.name.clone(), name_style));
                    Line::from(spans)
                }
            };

            buf.set_line(inner.x, y, &line, inner.width);
        }
    }
}

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

    fn make_refs() -> Vec<VoidRef> {
        vec![
            VoidRef {
                name: "main".to_string(),
                kind: RefKind::Branch,
                target: CommitCid("aaa".to_string()),
            },
            VoidRef {
                name: "feature".to_string(),
                kind: RefKind::Branch,
                target: CommitCid("bbb".to_string()),
            },
            VoidRef {
                name: "v1.0".to_string(),
                kind: RefKind::Tag,
                target: CommitCid("ccc".to_string()),
            },
        ]
    }

    #[test]
    fn test_ref_list_state_new() {
        let refs = make_refs();
        let state = RefListState::new(refs, Some(VoidHead::Branch("main".to_string())));

        // Should have: Branches category, 2 branches, Tags category, 1 tag = 5 nodes
        assert_eq!(state.nodes.len(), 5);
    }

    #[test]
    fn test_ref_list_toggle_category() {
        let refs = make_refs();
        let mut state = RefListState::new(refs, None);

        // Initially all expanded: 5 nodes
        assert_eq!(state.nodes.len(), 5);

        // Select Branches category and toggle
        state.selected = 0;
        state.toggle_selected();

        // Now branches collapsed: Branches header + Tags header + 1 tag = 3 nodes
        assert_eq!(state.nodes.len(), 3);
    }

    #[test]
    fn test_selected_ref() {
        let refs = make_refs();
        let state = RefListState::new(refs, None);

        // Index 0 is Branches category - should return None
        assert!(state.selected_ref_name().is_none());
    }
}