void_core/diff/

content.rs

//! Content-level diff generation.
//!
//! Builds on the hash-only `TreeDiff` to produce line-by-line unified diffs.
//! Content is only loaded when unified output is needed — the fast hash-only
//! diff phase is unchanged.

use std::fs;
use std::path::Path;

use crate::crypto::SecretKey;
use crate::diff::types::{DiffKind, TreeDiff};
use crate::index::WorkspaceIndex;

use crate::staged::read_staged_blob;
use crate::{cid, refs, ContentHash, Result, VoidContext};

use crate::cid::VoidCid;

/// Maximum file size (in bytes) we'll diff. Larger files get a placeholder.
const MAX_DIFF_SIZE: usize = 1024 * 1024; // 1 MB

/// Number of bytes to scan for binary detection.
const BINARY_PROBE_SIZE: usize = 8192;

/// A content-level diff for a single file.
#[derive(Debug, Clone)]
pub struct ContentDiff {
    /// File path (new path for renames).
    pub path: String,
    /// Type of change.
    pub kind: DiffKind,
    /// True if binary content detected.
    pub binary: bool,
    /// True if file exceeds size limit.
    pub too_large: bool,
    /// Diff hunks (empty if binary or too large).
    pub hunks: Vec<Hunk>,
    /// Original path for renames.
    pub rename_from: Option<String>,
}

/// A contiguous range of changed lines with surrounding context.
#[derive(Debug, Clone)]
pub struct Hunk {
    /// 1-based start line in old file.
    pub old_start: usize,
    /// Number of lines from old file.
    pub old_count: usize,
    /// 1-based start line in new file.
    pub new_start: usize,
    /// Number of lines from new file.
    pub new_count: usize,
    /// Lines in this hunk (context, additions, deletions).
    pub lines: Vec<DiffLine>,
}

/// A single line in a diff hunk.
#[derive(Debug, Clone)]
pub struct DiffLine {
    /// '+' for additions, '-' for deletions, ' ' for context.
    pub tag: char,
    /// Line content without trailing newline.
    pub content: String,
}

// ---------------------------------------------------------------------------
// Binary / size detection
// ---------------------------------------------------------------------------

/// Checks if content appears to be binary (null bytes in first 8KB).
fn is_binary(content: &[u8]) -> bool {
    let probe = &content[..content.len().min(BINARY_PROBE_SIZE)];
    probe.contains(&0)
}

// ---------------------------------------------------------------------------
// Hunk generation via `similar`
// ---------------------------------------------------------------------------

/// Generates unified diff hunks from old and new text.
fn generate_hunks(old: &str, new: &str) -> Vec<Hunk> {
    let diff = similar::TextDiff::from_lines(old, new);
    let mut hunks = Vec::new();

    for group in diff.grouped_ops(3) {
        let mut lines = Vec::new();
        let mut old_start = 0;
        let mut old_count = 0;
        let mut new_start = 0;
        let mut new_count = 0;

        for op in &group {
            // Track range boundaries from first op
            if lines.is_empty() {
                old_start = op.old_range().start;
                new_start = op.new_range().start;
            }

            match op.tag() {
                similar::DiffTag::Equal => {
                    for value in diff.iter_changes(op) {
                        lines.push(DiffLine {
                            tag: ' ',
                            content: value.value().trim_end_matches('\n').to_string(),
                        });
                        old_count += 1;
                        new_count += 1;
                    }
                }
                similar::DiffTag::Delete => {
                    for value in diff.iter_changes(op) {
                        lines.push(DiffLine {
                            tag: '-',
                            content: value.value().trim_end_matches('\n').to_string(),
                        });
                        old_count += 1;
                    }
                }
                similar::DiffTag::Insert => {
                    for value in diff.iter_changes(op) {
                        lines.push(DiffLine {
                            tag: '+',
                            content: value.value().trim_end_matches('\n').to_string(),
                        });
                        new_count += 1;
                    }
                }
                similar::DiffTag::Replace => {
                    for value in diff.iter_changes(op) {
                        match value.tag() {
                            similar::ChangeTag::Delete => {
                                lines.push(DiffLine {
                                    tag: '-',
                                    content: value.value().trim_end_matches('\n').to_string(),
                                });
                                old_count += 1;
                            }
                            similar::ChangeTag::Insert => {
                                lines.push(DiffLine {
                                    tag: '+',
                                    content: value.value().trim_end_matches('\n').to_string(),
                                });
                                new_count += 1;
                            }
                            similar::ChangeTag::Equal => {
                                lines.push(DiffLine {
                                    tag: ' ',
                                    content: value.value().trim_end_matches('\n').to_string(),
                                });
                                old_count += 1;
                                new_count += 1;
                            }
                        }
                    }
                }
            }
        }

        hunks.push(Hunk {
            old_start: old_start + 1, // 1-based
            old_count,
            new_start: new_start + 1, // 1-based
            new_count,
            lines,
        });
    }

    hunks
}

// ---------------------------------------------------------------------------
// Single-file diff builder
// ---------------------------------------------------------------------------

/// Builds a `ContentDiff` from raw old/new content bytes.
fn diff_single_file(
    path: &str,
    kind: DiffKind,
    old_content: Option<&[u8]>,
    new_content: Option<&[u8]>,
) -> ContentDiff {
    let rename_from = match &kind {
        DiffKind::Renamed { from, .. } => Some(from.clone()),
        _ => None,
    };

    let old_bytes = old_content.unwrap_or(&[]);
    let new_bytes = new_content.unwrap_or(&[]);

    // Size check
    if old_bytes.len() > MAX_DIFF_SIZE || new_bytes.len() > MAX_DIFF_SIZE {
        return ContentDiff {
            path: path.to_string(),
            kind,
            binary: false,
            too_large: true,
            hunks: Vec::new(),
            rename_from,
        };
    }

    // Binary check
    if (!old_bytes.is_empty() && is_binary(old_bytes))
        || (!new_bytes.is_empty() && is_binary(new_bytes))
    {
        return ContentDiff {
            path: path.to_string(),
            kind,
            binary: true,
            too_large: false,
            hunks: Vec::new(),
            rename_from,
        };
    }

    // UTF-8 validation — treat non-UTF-8 as binary
    let old_str = match std::str::from_utf8(old_bytes) {
        Ok(s) => s,
        Err(_) => {
            return ContentDiff {
                path: path.to_string(),
                kind,
                binary: true,
                too_large: false,
                hunks: Vec::new(),
                rename_from,
            };
        }
    };
    let new_str = match std::str::from_utf8(new_bytes) {
        Ok(s) => s,
        Err(_) => {
            return ContentDiff {
                path: path.to_string(),
                kind,
                binary: true,
                too_large: false,
                hunks: Vec::new(),
                rename_from,
            };
        }
    };

    let hunks = generate_hunks(old_str, new_str);

    ContentDiff {
        path: path.to_string(),
        kind,
        binary: false,
        too_large: false,
        hunks,
        rename_from,
    }
}

// ---------------------------------------------------------------------------
// Content retrieval helpers
// ---------------------------------------------------------------------------

/// Loaded commit state needed for manifest-driven file reads.
struct CommitFiles {
    store: crate::store::FsStore,
    commit: crate::metadata::Commit,
    reader: crate::crypto::CommitReader,
    ancestor_keys: Vec<void_crypto::ContentKey>,
}

impl CommitFiles {
    fn load(ctx: &VoidContext, commit_cid: &VoidCid) -> Result<Self> {
        let store = ctx.open_store()?;
        let (commit, reader) = ctx.load_commit(&store, commit_cid)?;
        let ancestor_keys =
            crate::crypto::collect_ancestor_content_keys_vault(&ctx.crypto.vault, &store, &commit);
        Ok(Self { store, commit, reader, ancestor_keys })
    }

    fn read_file(&self, ctx: &VoidContext, path: &str) -> Option<Vec<u8>> {
        ctx.read_file_from_commit(&self.store, &self.commit, &self.reader, &self.ancestor_keys, path)
            .ok()
            .map(|fc| fc.into())
    }
}

/// Reads a file from the workspace.
fn read_file_from_workspace(workspace: &Path, path: &str) -> Option<Vec<u8>> {
    let full = workspace.join(path);
    fs::read(&full).ok()
}

/// Reads a file from the staged blob store.
fn read_file_from_staged(
    void_dir: &Path,
    staged_key: &SecretKey,
    content_hash: &ContentHash,
) -> Option<Vec<u8>> {
    read_staged_blob(void_dir, staged_key, content_hash).ok()
}

// ---------------------------------------------------------------------------
// Public entry points — one per diff mode
// ---------------------------------------------------------------------------

/// Content diff for index vs workspace (unstaged changes).
///
/// Old content: staged blob (by content hash from index).
/// New content: workspace file on disk.
pub fn content_diff_index(
    tree_diff: &TreeDiff,
    index: &WorkspaceIndex,
    workspace: &Path,
    void_dir: &Path,
    staged_key: &SecretKey,
) -> Result<Vec<ContentDiff>> {
    // Build index lookup: path -> content_hash
    let index_map: std::collections::HashMap<&str, ContentHash> = index
        .iter()
        .map(|e| (e.path.as_str(), e.content_hash))
        .collect();

    let diffs = tree_diff
        .files
        .iter()
        .map(|file| {
            let old_path = match &file.kind {
                DiffKind::Renamed { from, .. } => from.as_str(),
                _ => file.path.as_str(),
            };

            let old_content = index_map
                .get(old_path)
                .and_then(|hash| read_file_from_staged(void_dir, staged_key, hash));

            let new_content = match &file.kind {
                DiffKind::Deleted => None,
                _ => read_file_from_workspace(workspace, &file.path),
            };

            diff_single_file(
                &file.path,
                file.kind.clone(),
                old_content.as_deref(),
                new_content.as_deref(),
            )
        })
        .collect();

    Ok(diffs)
}

/// Content diff for commit vs workspace (working tree changes).
///
/// Old content: committed file via manifest.
/// New content: workspace file on disk.
pub fn content_diff_working(
    tree_diff: &TreeDiff,
    ctx: &VoidContext,
    commit_cid: &VoidCid,
    workspace: &Path,
) -> Result<Vec<ContentDiff>> {
    let files = CommitFiles::load(ctx, commit_cid)?;

    let diffs = tree_diff
        .files
        .iter()
        .map(|file| {
            let old_path = match &file.kind {
                DiffKind::Renamed { from, .. } => from.as_str(),
                _ => file.path.as_str(),
            };

            let old_content = files.read_file(ctx, old_path);

            let new_content = match &file.kind {
                DiffKind::Deleted => None,
                _ => read_file_from_workspace(workspace, &file.path),
            };

            diff_single_file(
                &file.path,
                file.kind.clone(),
                old_content.as_deref(),
                new_content.as_deref(),
            )
        })
        .collect();

    Ok(diffs)
}

/// Content diff between two commits.
///
/// Old content: old commit's files via manifest.
/// New content: new commit's files via manifest.
pub fn content_diff_commits(
    tree_diff: &TreeDiff,
    ctx: &VoidContext,
    old_cid: &VoidCid,
    new_cid: &VoidCid,
) -> Result<Vec<ContentDiff>> {
    let old_files = CommitFiles::load(ctx, old_cid)?;
    let new_files = CommitFiles::load(ctx, new_cid)?;

    let diffs = tree_diff
        .files
        .iter()
        .map(|file| {
            let old_path = match &file.kind {
                DiffKind::Renamed { from, .. } => from.as_str(),
                _ => file.path.as_str(),
            };

            let old_content = old_files.read_file(ctx, old_path);

            let new_content = match &file.kind {
                DiffKind::Deleted => None,
                _ => new_files.read_file(ctx, &file.path),
            };

            diff_single_file(
                &file.path,
                file.kind.clone(),
                old_content.as_deref(),
                new_content.as_deref(),
            )
        })
        .collect();

    Ok(diffs)
}

/// Content diff for staged changes (HEAD vs index).
///
/// Old content: HEAD commit's files via manifest.
/// New content: staged blobs.
pub fn content_diff_staged(
    tree_diff: &TreeDiff,
    ctx: &VoidContext,
) -> Result<Vec<ContentDiff>> {
    // Load HEAD commit for old content
    let head_commit_cid = refs::resolve_head(&ctx.paths.void_dir)?;
    let head_files = match head_commit_cid {
        Some(commit_cid) => {
            let head_cid = cid::from_bytes(commit_cid.as_bytes())?;
            Some(CommitFiles::load(ctx, &head_cid)?)
        }
        None => None,
    };

    let staged_key = ctx.crypto.vault.staged_key()?;
    let void_dir = ctx.paths.void_dir.as_std_path();

    let diffs = tree_diff
        .files
        .iter()
        .map(|file| {
            let old_path = match &file.kind {
                DiffKind::Renamed { from, .. } => from.as_str(),
                _ => file.path.as_str(),
            };

            let old_content = head_files.as_ref().and_then(|f| f.read_file(ctx, old_path));

            let new_content = match &file.kind {
                DiffKind::Deleted => None,
                _ => file
                    .new_hash
                    .as_ref()
                    .and_then(|hash| read_file_from_staged(void_dir, staged_key, hash)),
            };

            diff_single_file(
                &file.path,
                file.kind.clone(),
                old_content.as_deref(),
                new_content.as_deref(),
            )
        })
        .collect();

    Ok(diffs)
}

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

    #[test]
    fn binary_detection_null_byte() {
        assert!(is_binary(b"hello\x00world"));
        assert!(!is_binary(b"hello world"));
        assert!(!is_binary(b""));
    }

    #[test]
    fn hunk_generation_simple_add() {
        let old = "line1\nline2\nline3\n";
        let new = "line1\nline2\nnew line\nline3\n";

        let hunks = generate_hunks(old, new);
        assert_eq!(hunks.len(), 1);

        let hunk = &hunks[0];
        assert!(hunk.lines.iter().any(|l| l.tag == '+' && l.content == "new line"));
    }

    #[test]
    fn hunk_generation_simple_delete() {
        let old = "line1\nline2\nline3\n";
        let new = "line1\nline3\n";

        let hunks = generate_hunks(old, new);
        assert_eq!(hunks.len(), 1);

        let hunk = &hunks[0];
        assert!(hunk.lines.iter().any(|l| l.tag == '-' && l.content == "line2"));
    }

    #[test]
    fn hunk_generation_modify() {
        let old = "aaa\nbbb\nccc\n";
        let new = "aaa\nBBB\nccc\n";

        let hunks = generate_hunks(old, new);
        assert_eq!(hunks.len(), 1);

        let hunk = &hunks[0];
        assert!(hunk.lines.iter().any(|l| l.tag == '-' && l.content == "bbb"));
        assert!(hunk.lines.iter().any(|l| l.tag == '+' && l.content == "BBB"));
    }

    #[test]
    fn diff_single_file_binary_detected() {
        let old = b"hello\x00binary";
        let new = b"changed\x00binary";

        let result = diff_single_file("test.bin", DiffKind::Modified, Some(old), Some(new));
        assert!(result.binary);
        assert!(result.hunks.is_empty());
    }

    #[test]
    fn diff_single_file_too_large() {
        let big = vec![b'x'; MAX_DIFF_SIZE + 1];

        let result = diff_single_file("big.txt", DiffKind::Modified, Some(&big), Some(b"small"));
        assert!(result.too_large);
        assert!(result.hunks.is_empty());
    }

    #[test]
    fn diff_single_file_added() {
        let new = b"line1\nline2\n";

        let result = diff_single_file("new.txt", DiffKind::Added, None, Some(new));
        assert!(!result.binary);
        assert!(!result.too_large);
        assert_eq!(result.hunks.len(), 1);
        assert!(result.hunks[0].lines.iter().all(|l| l.tag == '+'));
    }

    #[test]
    fn diff_single_file_deleted() {
        let old = b"line1\nline2\n";

        let result = diff_single_file("old.txt", DiffKind::Deleted, Some(old), None);
        assert_eq!(result.hunks.len(), 1);
        assert!(result.hunks[0].lines.iter().all(|l| l.tag == '-'));
    }

    #[test]
    fn empty_file_diff() {
        let hunks = generate_hunks("", "");
        assert!(hunks.is_empty());
    }

    #[test]
    fn non_utf8_treated_as_binary() {
        let old = &[0xFF, 0xFE, 0x41, 0x42]; // not valid UTF-8, no null bytes
        let new = b"hello";

        let result = diff_single_file("test.dat", DiffKind::Modified, Some(old), Some(new));
        assert!(result.binary);
    }
}