oo_ide/

vcs.rs

//! VCS abstraction layer.
//!
//! The [`Vcs`] trait is synchronous — it is always called from within
//! `tokio::task::spawn_blocking`. [`GitVcs`] is the `git2`-backed implementation.

use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};

// ---------------------------------------------------------------------------
// Shared data types
// ---------------------------------------------------------------------------

#[derive(Debug, Clone)]
pub struct StatusEntry {
    pub path: PathBuf,
    pub staged: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DiffKind {
    Context,
    Added,
    Removed,
    /// `@@` hunk header — not a real file line; used as a section separator.
    HunkHeader,
}

#[derive(Debug, Clone)]
pub struct DiffLine {
    /// Line number in the new (workdir) file, if applicable.
    pub line_no: Option<usize>,
    pub kind: DiffKind,
    pub content: String,
}

/// A single commit summary entry used by the git history viewer.
#[derive(Debug, Clone)]
pub struct CommitInfo {
    /// Full 40-character hex OID.
    pub oid: String,
    pub summary: String,
    pub author_name: String,
    pub date_relative: String,
}

/// Change status for a file in a commit.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FileChangeStatus {
    Modified,
    Added,
    Deleted,
    Renamed,
}

impl FileChangeStatus {
    pub fn indicator(&self) -> &'static str {
        match self {
            Self::Modified => "M",
            Self::Added => "A",
            Self::Deleted => "D",
            Self::Renamed => "R",
        }
    }
}

/// A file changed within a commit.
#[derive(Debug, Clone)]
pub struct FileChange {
    pub path: PathBuf,
    pub status: FileChangeStatus,
}

// ---------------------------------------------------------------------------
// Trait
// ---------------------------------------------------------------------------

/// Backend-agnostic VCS interface.
///
/// All methods are synchronous; call them from `tokio::task::spawn_blocking`.
/// `Send` is required so the implementation can be moved into blocking tasks.
/// `Sync` is NOT required — if an async backend is added later, wrap in
/// `Arc<Mutex<dyn Vcs>>` at the call site.
pub trait Vcs: Send {
    /// Returns `(staged, unstaged)` file lists.
    fn status(&self) -> anyhow::Result<(Vec<StatusEntry>, Vec<StatusEntry>)>;

    /// Diff for a single file.
    /// `staged = true`  → HEAD ↔ index (what would be committed).
    /// `staged = false` → index ↔ workdir (what is not yet staged).
    fn diff_file(&self, path: &Path, staged: bool) -> anyhow::Result<Vec<DiffLine>>;

    fn stage_file(&self, path: &Path) -> anyhow::Result<()>;
    fn unstage_file(&self, path: &Path) -> anyhow::Result<()>;

    /// Stage only the selected lines (by index into `diff`).
    /// Uses direct git2 index blob manipulation — no subprocess required.
    fn stage_lines(&self, path: &Path, selected: &[usize], diff: &[DiffLine])
    -> anyhow::Result<()>;

    /// Unstage only the selected lines (revert them to HEAD content in the index).
    fn unstage_lines(
        &self,
        path: &Path,
        selected: &[usize],
        diff: &[DiffLine],
    ) -> anyhow::Result<()>;

    fn commit(&self, message: &str) -> anyhow::Result<()>;

    /// Returns `(all_branches, current_branch)`.
    fn branches(&self) -> anyhow::Result<(Vec<String>, String)>;

    fn create_branch(&self, name: &str) -> anyhow::Result<()>;
    fn checkout_branch(&self, name: &str) -> anyhow::Result<()>;

    /// Return up to `max` commits reachable from HEAD, optionally filtered by
    /// a case-insensitive substring that matches summary, author name, or OID.
    fn log_commits(&self, max: usize, filter: &str) -> anyhow::Result<Vec<CommitInfo>>;

    /// Return the list of files changed in the commit identified by the full
    /// 40-char hex `oid`.
    fn commit_files(&self, oid: &str) -> anyhow::Result<Vec<FileChange>>;

    /// Return the diff for a single file within the commit identified by the
    /// full 40-char hex `oid`.
    fn commit_diff(&self, oid: &str, path: &Path) -> anyhow::Result<Vec<DiffLine>>;
}

// ---------------------------------------------------------------------------
// GitVcs
// ---------------------------------------------------------------------------

pub struct GitVcs {
    /// Root path — used for resolving relative paths.
    pub root: PathBuf,
    repo: git2::Repository,
}

// git2::Repository doesn't implement Debug.
impl fmt::Debug for GitVcs {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GitVcs")
            .field("root", &self.root)
            .finish_non_exhaustive()
    }
}

impl GitVcs {
    pub fn open(path: &Path) -> anyhow::Result<Self> {
        let repo = git2::Repository::open(path)?;
        Ok(Self {
            root: path.to_owned(),
            repo,
        })
    }
}

impl Vcs for GitVcs {
    // -----------------------------------------------------------------------
    // status
    // -----------------------------------------------------------------------

    fn status(&self) -> anyhow::Result<(Vec<StatusEntry>, Vec<StatusEntry>)> {
        let mut opts = git2::StatusOptions::new();
        opts.include_untracked(true)
            .recurse_untracked_dirs(true)
            .include_ignored(false);

        let statuses = self.repo.statuses(Some(&mut opts))?;

        let mut staged = Vec::new();
        let mut unstaged = Vec::new();

        for entry in statuses.iter() {
            let path = match entry.path() {
                Some(p) => PathBuf::from(p),
                None => continue,
            };
            let s = entry.status();

            let is_staged = s.intersects(
                git2::Status::INDEX_NEW
                    | git2::Status::INDEX_MODIFIED
                    | git2::Status::INDEX_DELETED
                    | git2::Status::INDEX_RENAMED
                    | git2::Status::INDEX_TYPECHANGE,
            );
            let is_unstaged = s.intersects(
                git2::Status::WT_MODIFIED
                    | git2::Status::WT_DELETED
                    | git2::Status::WT_RENAMED
                    | git2::Status::WT_TYPECHANGE
                    | git2::Status::WT_NEW,
            );

            if is_staged {
                staged.push(StatusEntry {
                    path: path.clone(),
                    staged: true,
                });
            }
            if is_unstaged {
                unstaged.push(StatusEntry {
                    path,
                    staged: false,
                });
            }
        }

        Ok((staged, unstaged))
    }

    // -----------------------------------------------------------------------
    // diff_file
    // -----------------------------------------------------------------------

    fn diff_file(&self, path: &Path, staged: bool) -> anyhow::Result<Vec<DiffLine>> {
        let mut diff_opts = git2::DiffOptions::new();
        diff_opts
            .pathspec(path.to_string_lossy().as_ref())
            // Include the full file as context so callers can fold at will.
            .context_lines(999_999);

        let diff = if staged {
            // HEAD tree ↔ index
            let head_tree = self.repo.head().ok().and_then(|h| h.peel_to_tree().ok());
            self.repo
                .diff_tree_to_index(head_tree.as_ref(), None, Some(&mut diff_opts))?
        } else {
            // index ↔ workdir  (include untracked handled below)
            self.repo
                .diff_index_to_workdir(None, Some(&mut diff_opts))?
        };

        let mut lines: Vec<DiffLine> = Vec::new();

        diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {
            let content = String::from_utf8_lossy(line.content())
                .trim_end_matches('\n')
                .trim_end_matches('\r')
                .to_string();

            match line.origin() {
                '+' => {
                    let line_no = line.new_lineno().map(|n| n as usize);
                    lines.push(DiffLine {
                        line_no,
                        kind: DiffKind::Added,
                        content,
                    });
                }
                '-' => {
                    let line_no = line.old_lineno().map(|n| n as usize);
                    lines.push(DiffLine {
                        line_no,
                        kind: DiffKind::Removed,
                        content,
                    });
                }
                ' ' => {
                    let line_no = line.new_lineno().map(|n| n as usize);
                    lines.push(DiffLine {
                        line_no,
                        kind: DiffKind::Context,
                        content,
                    });
                }
                'H' => {
                    // Hunk header — strip leading @@ prefix for display
                    lines.push(DiffLine {
                        line_no: None,
                        kind: DiffKind::HunkHeader,
                        content,
                    });
                }
                _ => {} // file headers, binary markers, etc.
            }
            true
        })?;

        // Untracked (new) files produce no diff against the index.
        // Read the file content directly and present it as all-Added lines.
        if !staged && lines.is_empty() {
            let abs = self.root.join(path);
            let in_index = self
                .repo
                .index()
                .ok()
                .and_then(|idx| idx.get_path(path, 0))
                .is_some();
            if abs.exists()
                && !in_index
                && let Ok(content) = fs::read_to_string(&abs)
            {
                lines.push(DiffLine {
                    line_no: None,
                    kind: DiffKind::HunkHeader,
                    content: "@@ new file @@".to_string(),
                });
                for (i, line_content) in content.lines().enumerate() {
                    lines.push(DiffLine {
                        line_no: Some(i + 1),
                        kind: DiffKind::Added,
                        content: line_content.to_owned(),
                    });
                }
            }
        }

        Ok(lines)
    }

    // -----------------------------------------------------------------------
    // stage_file / unstage_file
    // -----------------------------------------------------------------------

    fn stage_file(&self, path: &Path) -> anyhow::Result<()> {
        let mut index = self.repo.index()?;
        let abs = self.root.join(path);
        if abs.exists() {
            index.add_path(path)?;
        } else {
            // Deleted file — remove from index.
            index.remove_path(path)?;
        }
        index.write()?;
        Ok(())
    }

    fn unstage_file(&self, path: &Path) -> anyhow::Result<()> {
        // Reset path in index to HEAD state.
        match self.repo.head() {
            Ok(head_ref) => {
                let head_commit = head_ref.peel_to_commit()?;
                let mut checkout_opts = git2::build::CheckoutBuilder::new();
                checkout_opts.path(path).force();
                self.repo
                    .reset_default(Some(head_commit.as_object()), [path])?;
            }
            Err(_) => {
                // No HEAD (initial repo) — just remove from index.
                let mut index = self.repo.index()?;
                index.remove_path(path)?;
                index.write()?;
            }
        }
        Ok(())
    }

    // -----------------------------------------------------------------------
    // stage_lines / unstage_lines — direct index blob manipulation
    // -----------------------------------------------------------------------

    fn stage_lines(
        &self,
        path: &Path,
        selected: &[usize],
        diff: &[DiffLine],
    ) -> anyhow::Result<()> {
        // 1. Read current index content (or HEAD content if nothing is staged).
        let index_lines = self.index_file_lines(path)?;

        // 2. Build new index content by applying selected additions/removals.
        let new_content = apply_selected_lines(&index_lines, diff, selected, true)?;

        // 3. Write blob back to index.
        self.write_index_blob(path, &new_content)
    }

    fn unstage_lines(
        &self,
        path: &Path,
        selected: &[usize],
        diff: &[DiffLine],
    ) -> anyhow::Result<()> {
        // Same as stage_lines but inverse — reverts selected lines to HEAD.
        let index_lines = self.index_file_lines(path)?;
        let new_content = apply_selected_lines(&index_lines, diff, selected, false)?;
        self.write_index_blob(path, &new_content)
    }

    // -----------------------------------------------------------------------
    // commit
    // -----------------------------------------------------------------------

    fn commit(&self, message: &str) -> anyhow::Result<()> {
        let sig = self.repo.signature()?;
        let mut index = self.repo.index()?;
        let tree_oid = index.write_tree()?;
        let tree = self.repo.find_tree(tree_oid)?;

        match self.repo.head() {
            Ok(head_ref) => {
                let parent = head_ref.peel_to_commit()?;
                self.repo
                    .commit(Some("HEAD"), &sig, &sig, message, &tree, &[&parent])?;
            }
            Err(_) => {
                // Initial commit — no parent.
                self.repo
                    .commit(Some("HEAD"), &sig, &sig, message, &tree, &[])?;
            }
        }
        Ok(())
    }

    // -----------------------------------------------------------------------
    // branches
    // -----------------------------------------------------------------------

    fn branches(&self) -> anyhow::Result<(Vec<String>, String)> {
        let mut names = Vec::new();
        for branch in self.repo.branches(Some(git2::BranchType::Local))? {
            let (b, _) = branch?;
            if let Some(name) = b.name()? {
                names.push(name.to_owned());
            }
        }
        names.sort();

        let current = self
            .repo
            .head()
            .ok()
            .and_then(|h| h.shorthand().map(|s| s.to_owned()))
            .unwrap_or_else(|| "(detached)".to_owned());

        Ok((names, current))
    }

    fn create_branch(&self, name: &str) -> anyhow::Result<()> {
        let head = self.repo.head()?.peel_to_commit()?;
        self.repo.branch(name, &head, false)?;
        Ok(())
    }

    fn checkout_branch(&self, name: &str) -> anyhow::Result<()> {
        let obj = self.repo.revparse_single(&format!("refs/heads/{}", name))?;
        let mut checkout = git2::build::CheckoutBuilder::new();
        checkout.safe();
        self.repo.checkout_tree(&obj, Some(&mut checkout))?;
        self.repo.set_head(&format!("refs/heads/{}", name))?;
        Ok(())
    }

    // -----------------------------------------------------------------------
    // log_commits
    // -----------------------------------------------------------------------

    fn log_commits(&self, max: usize, filter: &str) -> anyhow::Result<Vec<CommitInfo>> {
        let mut revwalk = self.repo.revwalk()?;
        revwalk.push_head()?;
        revwalk.set_sorting(git2::Sort::TIME | git2::Sort::TOPOLOGICAL)?;

        let filter_lower = filter.to_lowercase();
        let mut commits = Vec::new();

        for oid_result in revwalk {
            if commits.len() >= max {
                break;
            }
            let oid = oid_result?;
            let commit = self.repo.find_commit(oid)?;

            let summary = commit.summary().unwrap_or("").to_owned();
            let author_name = commit.author().name().unwrap_or("").to_owned();
            let oid_str = oid.to_string();

            if !filter_lower.is_empty() {
                let matches = summary.to_lowercase().contains(&filter_lower)
                    || author_name.to_lowercase().contains(&filter_lower)
                    || oid_str.contains(&filter_lower);
                if !matches {
                    continue;
                }
            }

            let date_relative = format_relative_time(commit.time().seconds());
            commits.push(CommitInfo {
                oid: oid_str,
                summary,
                author_name,
                date_relative,
            });
        }

        Ok(commits)
    }

    // -----------------------------------------------------------------------
    // commit_files
    // -----------------------------------------------------------------------

    fn commit_files(&self, oid: &str) -> anyhow::Result<Vec<FileChange>> {
        let oid = git2::Oid::from_str(oid)?;
        let commit = self.repo.find_commit(oid)?;
        let tree = commit.tree()?;

        let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

        let mut diff_opts = git2::DiffOptions::new();
        let diff = self
            .repo
            .diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), Some(&mut diff_opts))?;

        let mut files = Vec::new();
        diff.foreach(
            &mut |delta, _progress| {
                let status = match delta.status() {
                    git2::Delta::Added | git2::Delta::Untracked => FileChangeStatus::Added,
                    git2::Delta::Deleted => FileChangeStatus::Deleted,
                    git2::Delta::Renamed | git2::Delta::Copied => FileChangeStatus::Renamed,
                    _ => FileChangeStatus::Modified,
                };
                let path = delta
                    .new_file()
                    .path()
                    .or_else(|| delta.old_file().path())
                    .map(PathBuf::from)
                    .unwrap_or_default();
                files.push(FileChange { path, status });
                true
            },
            None,
            None,
            None,
        )?;

        Ok(files)
    }

    // -----------------------------------------------------------------------
    // commit_diff
    // -----------------------------------------------------------------------

    fn commit_diff(&self, oid: &str, path: &Path) -> anyhow::Result<Vec<DiffLine>> {
        let oid = git2::Oid::from_str(oid)?;
        let commit = self.repo.find_commit(oid)?;
        let tree = commit.tree()?;

        let parent_tree = commit.parent(0).ok().and_then(|p| p.tree().ok());

        let mut diff_opts = git2::DiffOptions::new();
        diff_opts
            .pathspec(path.to_string_lossy().as_ref())
            .context_lines(999_999);

        let diff = self
            .repo
            .diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), Some(&mut diff_opts))?;

        let mut lines: Vec<DiffLine> = Vec::new();
        diff.print(git2::DiffFormat::Patch, |_delta, _hunk, line| {
            let content = String::from_utf8_lossy(line.content())
                .trim_end_matches('\n')
                .trim_end_matches('\r')
                .to_string();
            match line.origin() {
                '+' => lines.push(DiffLine {
                    line_no: line.new_lineno().map(|n| n as usize),
                    kind: DiffKind::Added,
                    content,
                }),
                '-' => lines.push(DiffLine {
                    line_no: line.old_lineno().map(|n| n as usize),
                    kind: DiffKind::Removed,
                    content,
                }),
                ' ' => lines.push(DiffLine {
                    line_no: line.new_lineno().map(|n| n as usize),
                    kind: DiffKind::Context,
                    content,
                }),
                'H' => lines.push(DiffLine {
                    line_no: None,
                    kind: DiffKind::HunkHeader,
                    content,
                }),
                _ => {}
            }
            true
        })?;

        Ok(lines)
    }
}

// ---------------------------------------------------------------------------
// GitVcs helpers
// ---------------------------------------------------------------------------

impl GitVcs {
    /// Return the current index content for `path` as lines, falling back to
    /// HEAD content if the path isn't yet in the index, or empty for new files.
    fn index_file_lines(&self, path: &Path) -> anyhow::Result<Vec<String>> {
        let index = self.repo.index()?;
        if let Some(entry) = index.get_path(path, 0) {
            let blob = self.repo.find_blob(entry.id)?;
            let text = std::str::from_utf8(blob.content())?.to_owned();
            return Ok(split_lines(&text));
        }
        // Try HEAD tree.
        if let Ok(head) = self.repo.head()
            && let Ok(tree) = head.peel_to_tree()
            && let Ok(entry) = tree.get_path(path)
            && let Ok(obj) = entry.to_object(&self.repo)
            && let Some(blob) = obj.as_blob()
        {
            let text = std::str::from_utf8(blob.content())?.to_owned();
            return Ok(split_lines(&text));
        }
        Ok(Vec::new())
    }

    /// Write `content` as a blob into the index for `path`.
    fn write_index_blob(&self, path: &Path, content: &str) -> anyhow::Result<()> {
        let oid = self.repo.blob(content.as_bytes())?;
        let mut index = self.repo.index()?;

        // Build an IndexEntry — copy the existing one if present, else synthesise.
        let mut entry = index.get_path(path, 0).unwrap_or_else(|| git2::IndexEntry {
            ctime: git2::IndexTime::new(0, 0),
            mtime: git2::IndexTime::new(0, 0),
            dev: 0,
            ino: 0,
            mode: 0o100644,
            uid: 0,
            gid: 0,
            file_size: 0,
            id: git2::Oid::zero(),
            flags: 0,
            flags_extended: 0,
            path: path.to_string_lossy().as_bytes().to_vec(),
        });
        entry.id = oid;
        entry.file_size = content.len() as u32;

        index.add(&entry)?;
        index.write()?;
        Ok(())
    }
}

// ---------------------------------------------------------------------------
// Line-level patch helpers
// ---------------------------------------------------------------------------

/// Apply (or reverse-apply) selected diff lines to `base_lines`.
///
/// `apply = true`  → stage: add/remove the selected changes into the base.
/// `apply = false` → unstage: revert the selected changes (keep the rest).
fn apply_selected_lines(
    base_lines: &[String],
    diff: &[DiffLine],
    selected: &[usize],
    apply: bool,
) -> anyhow::Result<String> {
    let selected_set: std::collections::HashSet<usize> = selected.iter().copied().collect();

    // We replay the diff against `base_lines`.
    // base_pos tracks our position in base_lines.
    let mut result: Vec<String> = Vec::new();
    let mut base_pos: usize = 0;

    for (i, dl) in diff.iter().enumerate() {
        match &dl.kind {
            DiffKind::HunkHeader => {} // not a real content line — skip
            DiffKind::Context => {
                // Consume one line from base unchanged.
                if base_pos < base_lines.len() {
                    result.push(base_lines[base_pos].clone());
                    base_pos += 1;
                }
            }
            DiffKind::Added => {
                if apply && selected_set.contains(&i) {
                    result.push(dl.content.clone());
                } else if !apply && !selected_set.contains(&i) {
                    // Keep already-staged lines that are NOT being unstaged.
                    result.push(dl.content.clone());
                }
                // If not selected (stage) or selected (unstage), drop the line.
            }
            DiffKind::Removed => {
                if apply && selected_set.contains(&i) {
                    // Remove this line from base — skip consuming it.
                    base_pos += 1;
                } else {
                    // Keep it.
                    if base_pos < base_lines.len() {
                        result.push(base_lines[base_pos].clone());
                        base_pos += 1;
                    }
                }
            }
        }
    }

    // Append any remaining base lines.
    while base_pos < base_lines.len() {
        result.push(base_lines[base_pos].clone());
        base_pos += 1;
    }

    Ok(result.join("\n") + "\n")
}

fn split_lines(text: &str) -> Vec<String> {
    // Preserve last empty line correctly.
    let lines: Vec<String> = text.lines().map(|l| l.to_owned()).collect();
    // `str::lines` drops a trailing newline; re-add empty last element if needed.
    if text.ends_with('\n') && !lines.is_empty() {
        // nothing — lines() already stripped the final newline token
    }
    lines
}

/// Format a Unix timestamp as a human-readable relative time string.
fn format_relative_time(unix_secs: i64) -> String {
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs() as i64)
        .unwrap_or(0);
    let delta = now.saturating_sub(unix_secs);
    if delta < 60 {
        "just now".to_owned()
    } else if delta < 3_600 {
        format!("{}m ago", delta / 60)
    } else if delta < 86_400 {
        format!("{}h ago", delta / 3_600)
    } else if delta < 86_400 * 30 {
        format!("{}d ago", delta / 86_400)
    } else if delta < 86_400 * 365 {
        format!("{}mo ago", delta / (86_400 * 30))
    } else {
        format!("{}y ago", delta / (86_400 * 365))
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

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

    #[test]
    fn test_apply_selected_add() {
        let base = vec!["line1".to_owned(), "line2".to_owned()];
        let diff = vec![
            DiffLine {
                line_no: Some(1),
                kind: DiffKind::Context,
                content: "line1".into(),
            },
            DiffLine {
                line_no: Some(2),
                kind: DiffKind::Added,
                content: "new".into(),
            },
            DiffLine {
                line_no: Some(3),
                kind: DiffKind::Context,
                content: "line2".into(),
            },
        ];
        let result = apply_selected_lines(&base, &diff, &[1], true).unwrap();
        assert_eq!(result, "line1\nnew\nline2\n");
    }

    #[test]
    fn test_apply_selected_remove() {
        let base = vec!["line1".to_owned(), "old".to_owned(), "line2".to_owned()];
        let diff = vec![
            DiffLine {
                line_no: Some(1),
                kind: DiffKind::Context,
                content: "line1".into(),
            },
            DiffLine {
                line_no: None,
                kind: DiffKind::Removed,
                content: "old".into(),
            },
            DiffLine {
                line_no: Some(2),
                kind: DiffKind::Context,
                content: "line2".into(),
            },
        ];
        let result = apply_selected_lines(&base, &diff, &[1], true).unwrap();
        assert_eq!(result, "line1\nline2\n");
    }
}