void_graph/widget/

commit_list.rs

//! Commit list widget with graph visualization.
//!
//! 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, GraphColorSet};
use crate::graph::{calc_graph_owned, Edge, EdgeType, OwnedGraph};
use crate::void_backend::{CommitCid, RefKind, VoidCommit, VoidHead, VoidRef};

/// State for the commit list widget.
#[derive(Debug)]
pub struct CommitListState {
    /// All commits to display
    commits: Vec<VoidCommit>,
    /// All refs for annotation
    refs: Vec<VoidRef>,
    /// Current HEAD
    head: Option<VoidHead>,
    /// Currently selected index (visual position from top of viewport)
    selected: usize,
    /// Scroll offset (first visible commit index)
    offset: usize,
    /// Full graph data computed from commits
    graph: OwnedGraph,
    /// Color set for graph lanes
    color_set: GraphColorSet,
}

impl CommitListState {
    /// Create a new commit list state.
    pub fn new(commits: Vec<VoidCommit>, refs: Vec<VoidRef>, head: Option<VoidHead>) -> Self {
        let graph = calc_graph_owned(&commits);
        Self {
            commits,
            refs,
            head,
            selected: 0,
            offset: 0,
            graph,
            color_set: GraphColorSet::default(),
        }
    }

    /// Returns the total number of commits.
    pub fn len(&self) -> usize {
        self.commits.len()
    }

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

    /// Get the currently selected commit.
    pub fn selected_commit(&self) -> Option<&VoidCommit> {
        let idx = self.offset + self.selected;
        self.commits.get(idx)
    }

    /// Get the selected absolute index.
    pub fn selected_index(&self) -> usize {
        self.offset + self.selected
    }

    /// Move selection down by one.
    pub fn select_next(&mut self, viewport_height: usize) {
        let max_idx = self.commits.len().saturating_sub(1);
        let current_abs = self.offset + self.selected;

        if current_abs < max_idx {
            if self.selected < viewport_height.saturating_sub(1) {
                self.selected += 1;
            } else {
                self.offset += 1;
            }
        }
    }

    /// Move selection up by one.
    pub fn select_prev(&mut self) {
        if self.selected > 0 {
            self.selected -= 1;
        } else if self.offset > 0 {
            self.offset -= 1;
        }
    }

    /// Move selection down by half a page.
    pub fn scroll_down_half(&mut self, viewport_height: usize) {
        let half = viewport_height / 2;
        for _ in 0..half {
            self.select_next(viewport_height);
        }
    }

    /// Move selection up by half a page.
    pub fn scroll_up_half(&mut self, viewport_height: usize) {
        let half = viewport_height / 2;
        for _ in 0..half {
            self.select_prev();
        }
    }

    /// Move selection down by a full page.
    pub fn scroll_down_page(&mut self, viewport_height: usize) {
        for _ in 0..viewport_height {
            self.select_next(viewport_height);
        }
    }

    /// Move selection up by a full page.
    pub fn scroll_up_page(&mut self, viewport_height: usize) {
        for _ in 0..viewport_height {
            self.select_prev();
        }
    }

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

    /// Jump to the last commit.
    pub fn select_last(&mut self, viewport_height: usize) {
        let total = self.commits.len();
        if total <= viewport_height {
            self.offset = 0;
            self.selected = total.saturating_sub(1);
        } else {
            self.offset = total - viewport_height;
            self.selected = viewport_height.saturating_sub(1);
        }
    }

    /// Get refs pointing at a specific commit.
    fn refs_at(&self, cid: &CommitCid) -> Vec<&VoidRef> {
        self.refs
            .iter()
            .filter(|r| &r.target == cid)
            .collect()
    }

    /// Check if a commit CID matches HEAD.
    fn is_head(&self, cid: &CommitCid) -> bool {
        match &self.head {
            Some(VoidHead::Detached(head_cid)) => head_cid == cid,
            Some(VoidHead::Branch(branch_name)) => self
                .refs
                .iter()
                .any(|r| r.kind == RefKind::Branch && &r.name == branch_name && &r.target == cid),
            None => false,
        }
    }
}

/// Map EdgeType to Unicode box-drawing character.
fn edge_type_to_char(edge_type: EdgeType) -> char {
    match edge_type {
        EdgeType::Vertical => '│',
        EdgeType::Horizontal => '─',
        EdgeType::Up => '╵',
        EdgeType::Down => '╷',
        EdgeType::Left => '╴',
        EdgeType::Right => '╶',
        EdgeType::RightTop => '╮',
        EdgeType::RightBottom => '╯',
        EdgeType::LeftTop => '╭',
        EdgeType::LeftBottom => '╰',
    }
}

/// Render a graph row using the full edge data with per-lane coloring.
///
/// Returns a vector of (character, color) pairs for each cell.
fn render_graph_row_full(
    edges: &[Edge],
    commit_pos_x: usize,
    max_pos_x: usize,
    color_set: &GraphColorSet,
) -> Vec<(char, ratatui::style::Color)> {
    use ratatui::style::Color;

    let width = max_pos_x + 1;
    let mut cells: Vec<(char, Option<usize>)> = vec![(' ', None); width];

    // Place edges
    for edge in edges {
        if edge.pos_x < width {
            let ch = edge_type_to_char(edge.edge_type);
            cells[edge.pos_x] = (ch, Some(edge.associated_line_pos_x));
        }
    }

    // Place commit node (overrides edges)
    if commit_pos_x < width {
        cells[commit_pos_x] = ('●', Some(commit_pos_x));
    }

    // Convert to colored output
    cells
        .into_iter()
        .map(|(ch, lane)| {
            let color = lane
                .map(|l| color_set.get(l).to_ratatui_color())
                .unwrap_or(Color::DarkGray);
            (ch, color)
        })
        .collect()
}

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

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

impl<'a> StatefulWidget for CommitList<'a> {
    type State = CommitListState;

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

        if state.is_empty() {
            return;
        }

        let viewport_height = inner.height as usize;

        // Calculate column widths - graph width depends on max_pos_x
        // Each lane takes 2 chars: "│ " or "● " etc.
        let graph_width = ((state.graph.max_pos_x + 1).max(1) * 2) as u16;
        let cid_width = 9_u16; // 8 chars + space
        let date_width = 11_u16; // "YYYY-MM-DD "
        let remaining = inner
            .width
            .saturating_sub(graph_width + cid_width + date_width);
        let subject_width = remaining;

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

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

            // Apply selection styling
            let base_style = if is_selected {
                Style::default()
                    .fg(self.theme.list_selected_fg)
                    .bg(self.theme.list_selected_bg)
            } else {
                Style::default()
            };

            // Get commit position from graph
            let commit_pos_x = state
                .graph
                .commit_pos_map
                .get(&commit.cid)
                .map(|(x, _)| *x)
                .unwrap_or(0);

            // Get edges for this row
            let edges = state.graph.edges.get(idx).map(|e| e.as_slice()).unwrap_or(&[]);

            // Render graph with full edge types and colors
            let colored_cells = render_graph_row_full(
                edges,
                commit_pos_x,
                state.graph.max_pos_x,
                &state.color_set,
            );

            // Draw each cell with its lane color
            for (x_offset, (ch, color)) in colored_cells.iter().enumerate() {
                let style = if is_selected {
                    base_style
                } else {
                    Style::default().fg(*color)
                };
                let cell_x = inner.x + (x_offset * 2) as u16;
                if cell_x < inner.x + graph_width {
                    buf.set_string(cell_x, y, ch.to_string(), style);
                    // Add space after each character
                    if cell_x + 1 < inner.x + graph_width {
                        buf.set_string(cell_x + 1, y, " ", Style::default());
                    }
                }
            }

            // Render CID
            let cid_area = Rect::new(inner.x + graph_width, y, cid_width, 1);
            buf.set_string(
                cid_area.x,
                cid_area.y,
                format!("{:<8}", commit.cid.short()),
                if is_selected {
                    base_style
                } else {
                    Style::default().fg(self.theme.list_hash_fg)
                },
            );

            // Subject with refs
            let refs_at = state.refs_at(&commit.cid);
            let is_head = state.is_head(&commit.cid);

            let mut subject_parts: Vec<Span> = Vec::new();

            // Add HEAD indicator
            if is_head {
                subject_parts.push(Span::styled(
                    "HEAD ",
                    Style::default()
                        .fg(self.theme.list_head_fg)
                        .add_modifier(Modifier::BOLD),
                ));
            }

            // Add refs
            if !refs_at.is_empty() {
                subject_parts.push(Span::styled(
                    "(",
                    Style::default().fg(self.theme.list_ref_paren_fg),
                ));

                for (j, r) in refs_at.iter().enumerate() {
                    if j > 0 {
                        subject_parts.push(Span::styled(
                            ", ",
                            Style::default().fg(self.theme.list_ref_paren_fg),
                        ));
                    }
                    let color = match r.kind {
                        RefKind::Branch => self.theme.list_ref_branch_fg,
                        RefKind::Tag => self.theme.list_ref_tag_fg,
                    };
                    subject_parts.push(Span::styled(&r.name, Style::default().fg(color)));
                }

                subject_parts.push(Span::styled(
                    ") ",
                    Style::default().fg(self.theme.list_ref_paren_fg),
                ));
            }

            // Subject text (first line of message)
            let subject = commit
                .message
                .lines()
                .next()
                .unwrap_or("")
                .to_string();
            subject_parts.push(Span::styled(
                subject,
                Style::default().fg(self.theme.list_subject_fg),
            ));

            // Truncate subject to fit
            let subject_line = Line::from(subject_parts);

            // Render subject (with refs)
            let subj_area = Rect::new(
                inner.x + graph_width + cid_width,
                y,
                subject_width.saturating_sub(date_width),
                1,
            );
            let line_with_style = if is_selected {
                Line::from(
                    subject_line
                        .spans
                        .into_iter()
                        .map(|s| s.style(base_style))
                        .collect::<Vec<_>>(),
                )
            } else {
                subject_line
            };
            buf.set_line(subj_area.x, subj_area.y, &line_with_style, subj_area.width);

            // Render date at the end
            let date_x = inner.x + inner.width.saturating_sub(date_width);
            buf.set_string(
                date_x,
                y,
                format_timestamp(commit.timestamp_ms),
                if is_selected {
                    base_style
                } else {
                    Style::default().fg(self.theme.list_date_fg)
                },
            );
        }
    }
}

/// Format a Unix timestamp (in milliseconds) as YYYY-MM-DD.
fn format_timestamp(ts_ms: u64) -> String {
    use std::time::{Duration, UNIX_EPOCH};
    let d = UNIX_EPOCH + Duration::from_millis(ts_ms);
    let datetime: chrono::DateTime<chrono::Utc> = d.into();
    datetime.format("%Y-%m-%d").to_string()
}

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

    fn make_commit(cid: &str, parents: Vec<&str>) -> VoidCommit {
        VoidCommit {
            cid: CommitCid(cid.to_string()),
            parents: parents.into_iter().map(|p| CommitCid(p.to_string())).collect(),
            message: String::new(),
            timestamp_ms: 0,
            is_signed: false,
            signature_valid: None,
            author: None,
        }
    }

    #[test]
    fn test_calc_graph_owned_empty() {
        let graph = calc_graph_owned(&[]);
        assert!(graph.commit_pos_map.is_empty());
        assert!(graph.edges.is_empty());
        assert_eq!(graph.max_pos_x, 0);
    }

    #[test]
    fn test_calc_graph_owned_linear() {
        let commits = vec![
            make_commit("aaa", vec!["bbb"]),
            make_commit("bbb", vec!["ccc"]),
            make_commit("ccc", vec![]),
        ];

        let graph = calc_graph_owned(&commits);
        // All should be in x position 0 for a linear history
        assert_eq!(graph.commit_pos_map.len(), 3);
        for commit in &commits {
            let (x, _) = graph.commit_pos_map[&commit.cid];
            assert_eq!(x, 0);
        }
    }

    #[test]
    fn test_edge_type_to_char() {
        assert_eq!(edge_type_to_char(EdgeType::Vertical), '│');
        assert_eq!(edge_type_to_char(EdgeType::Horizontal), '─');
        assert_eq!(edge_type_to_char(EdgeType::Up), '╵');
        assert_eq!(edge_type_to_char(EdgeType::Down), '╷');
        assert_eq!(edge_type_to_char(EdgeType::Left), '╴');
        assert_eq!(edge_type_to_char(EdgeType::Right), '╶');
        assert_eq!(edge_type_to_char(EdgeType::RightTop), '╮');
        assert_eq!(edge_type_to_char(EdgeType::RightBottom), '╯');
        assert_eq!(edge_type_to_char(EdgeType::LeftTop), '╭');
        assert_eq!(edge_type_to_char(EdgeType::LeftBottom), '╰');
    }

    #[test]
    fn test_render_graph_row_full_single_commit() {
        let color_set = GraphColorSet::default();
        let edges = vec![Edge::new(EdgeType::Down, 0, 0)];
        let cells = render_graph_row_full(&edges, 0, 0, &color_set);
        // Should have commit node at position 0
        assert_eq!(cells.len(), 1);
        assert_eq!(cells[0].0, '●'); // Commit node overrides edge
    }

    #[test]
    fn test_render_graph_row_full_with_vertical_line() {
        let color_set = GraphColorSet::default();
        let edges = vec![
            Edge::new(EdgeType::Vertical, 1, 1),
        ];
        let cells = render_graph_row_full(&edges, 0, 1, &color_set);
        assert_eq!(cells.len(), 2);
        assert_eq!(cells[0].0, '●'); // Commit node at position 0
        assert_eq!(cells[1].0, '│'); // Vertical line at position 1
    }
}