//! Diff and patch utilities.
//!
//! Provides functionality for computing, parsing, and applying diffs
//! to files and text content.

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

use serde::{Deserialize, Serialize};

use crate::error::{CortexError, Result};
use crate::tasks::snapshot::{FileState, Snapshot};

/// A unified diff.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UnifiedDiff {
    /// File changes.
    pub files: Vec<FileDiff>,
    /// Original text (if available).
    pub original_text: Option<String>,
}

impl UnifiedDiff {
    /// Parse a unified diff string.
    pub fn parse(diff_text: &str) -> Result<Self> {
        let parser = DiffParser::new();
        parser.parse(diff_text)
    }

    /// Create an empty diff.
    pub fn empty() -> Self {
        Self {
            files: Vec::new(),
            original_text: None,
        }
    }

    /// Check if diff is empty.
    pub fn is_empty(&self) -> bool {
        self.files.is_empty()
    }

    /// Get number of files changed.
    pub fn file_count(&self) -> usize {
        self.files.len()
    }

    /// Get total lines added.
    pub fn lines_added(&self) -> usize {
        self.files.iter().map(FileDiff::lines_added).sum()
    }

    /// Get total lines removed.
    pub fn lines_removed(&self) -> usize {
        self.files.iter().map(FileDiff::lines_removed).sum()
    }

    /// Reverse the diff.
    pub fn reverse(&self) -> Self {
        Self {
            files: self.files.iter().map(FileDiff::reverse).collect(),
            original_text: None,
        }
    }

    /// Apply the diff to a directory.
    pub async fn apply(&self, root: &Path) -> Result<ApplyResult> {
        let mut result = ApplyResult::default();

        for file_diff in &self.files {
            match file_diff.apply(root).await {
                Ok(stats) => {
                    result.files_modified += 1;
                    result.lines_added += stats.lines_added;
                    result.lines_removed += stats.lines_removed;
                }
                Err(e) => {
                    result.errors.push(FileError {
                        path: file_diff.path.clone(),
                        error: e.to_string(),
                    });
                }
            }
        }

        Ok(result)
    }
}

impl fmt::Display for UnifiedDiff {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let result: Vec<String> = self.files.iter().map(|f| f.to_string()).collect();
        write!(f, "{}", result.join("\n"))
    }
}

/// A single file's diff.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileDiff {
    /// File path (new path for renames).
    pub path: PathBuf,
    /// Original path (for renames).
    pub original_path: Option<PathBuf>,
    /// File operation type.
    pub operation: FileOperation,
    /// Hunks (change blocks).
    pub hunks: Vec<Hunk>,
    /// File mode (for new files).
    pub mode: Option<u32>,
    /// Is binary file.
    pub is_binary: bool,
}

impl FileDiff {
    /// Create a new file addition diff.
    pub fn new_file(path: impl Into<PathBuf>, content: &str) -> Self {
        let lines: Vec<_> = content.lines().collect();
        let hunk = Hunk {
            old_start: 0,
            old_count: 0,
            new_start: 1,
            new_count: lines.len() as u32,
            lines: lines.iter().map(|l| DiffLine::Add(l.to_string())).collect(),
            context_before: String::new(),
            context_after: String::new(),
        };

        Self {
            path: path.into(),
            original_path: None,
            operation: FileOperation::Create,
            hunks: vec![hunk],
            mode: Some(0o644),
            is_binary: false,
        }
    }

    /// Create a file deletion diff.
    pub fn delete_file(path: impl Into<PathBuf>, content: &str) -> Self {
        let lines: Vec<_> = content.lines().collect();
        let hunk = Hunk {
            old_start: 1,
            old_count: lines.len() as u32,
            new_start: 0,
            new_count: 0,
            lines: lines
                .iter()
                .map(|l| DiffLine::Remove(l.to_string()))
                .collect(),
            context_before: String::new(),
            context_after: String::new(),
        };

        Self {
            path: path.into(),
            original_path: None,
            operation: FileOperation::Delete,
            hunks: vec![hunk],
            mode: None,
            is_binary: false,
        }
    }

    /// Get number of lines added.
    pub fn lines_added(&self) -> usize {
        self.hunks
            .iter()
            .flat_map(|h| &h.lines)
            .filter(|l| matches!(l, DiffLine::Add(_)))
            .count()
    }

    /// Get number of lines removed.
    pub fn lines_removed(&self) -> usize {
        self.hunks
            .iter()
            .flat_map(|h| &h.lines)
            .filter(|l| matches!(l, DiffLine::Remove(_)))
            .count()
    }

    /// Reverse this file diff.
    pub fn reverse(&self) -> Self {
        Self {
            path: self
                .original_path
                .clone()
                .unwrap_or_else(|| self.path.clone()),
            original_path: Some(self.path.clone()),
            operation: match self.operation {
                FileOperation::Create => FileOperation::Delete,
                FileOperation::Delete => FileOperation::Create,
                FileOperation::Modify => FileOperation::Modify,
                FileOperation::Rename => FileOperation::Rename,
            },
            hunks: self.hunks.iter().map(Hunk::reverse).collect(),
            mode: self.mode,
            is_binary: self.is_binary,
        }
    }

    /// Apply this file diff.
    pub async fn apply(&self, root: &Path) -> Result<ApplyStats> {
        let file_path = root.join(&self.path);

        match self.operation {
            FileOperation::Create => {
                // Ensure parent exists
                if let Some(parent) = file_path.parent() {
                    tokio::fs::create_dir_all(parent)
                        .await
                        .map_err(CortexError::Io)?;
                }

                let content = self.reconstruct_new_content();
                tokio::fs::write(&file_path, &content)
                    .await
                    .map_err(CortexError::Io)?;

                Ok(ApplyStats {
                    lines_added: self.lines_added(),
                    lines_removed: 0,
                })
            }
            FileOperation::Delete => {
                if file_path.exists() {
                    tokio::fs::remove_file(&file_path)
                        .await
                        .map_err(CortexError::Io)?;
                }
                Ok(ApplyStats {
                    lines_added: 0,
                    lines_removed: self.lines_removed(),
                })
            }
            FileOperation::Modify => {
                let content = tokio::fs::read_to_string(&file_path)
                    .await
                    .map_err(CortexError::Io)?;

                let new_content = self.apply_to_content(&content)?;
                tokio::fs::write(&file_path, &new_content)
                    .await
                    .map_err(CortexError::Io)?;

                Ok(ApplyStats {
                    lines_added: self.lines_added(),
                    lines_removed: self.lines_removed(),
                })
            }
            FileOperation::Rename => {
                if let Some(ref orig) = self.original_path {
                    let orig_path = root.join(orig);
                    if orig_path.exists() {
                        tokio::fs::rename(&orig_path, &file_path)
                            .await
                            .map_err(CortexError::Io)?;
                    }
                }
                Ok(ApplyStats::default())
            }
        }
    }

    /// Reconstruct new file content from additions.
    fn reconstruct_new_content(&self) -> String {
        self.hunks
            .iter()
            .flat_map(|h| &h.lines)
            .filter_map(|l| match l {
                DiffLine::Add(s) | DiffLine::Context(s) => Some(s.as_str()),
                DiffLine::Remove(_) => None,
            })
            .collect::<Vec<_>>()
            .join("\n")
    }

    /// Apply hunks to existing content.
    fn apply_to_content(&self, content: &str) -> Result<String> {
        let mut lines: Vec<String> = content
            .lines()
            .map(std::string::ToString::to_string)
            .collect();
        let mut offset: i64 = 0;

        for hunk in &self.hunks {
            let start = (hunk.old_start as i64 - 1 + offset) as usize;
            let end = start + hunk.old_count as usize;

            // Verify context matches
            // For now, just apply the changes
            let mut new_lines = Vec::new();
            for line in &hunk.lines {
                match line {
                    DiffLine::Context(s) | DiffLine::Add(s) => {
                        new_lines.push(s.clone());
                    }
                    DiffLine::Remove(_) => {}
                }
            }

            // Replace range
            if end <= lines.len() {
                lines.splice(start..end, new_lines.clone());
            } else {
                // Append if past end
                lines.extend(new_lines);
            }

            // Update offset
            offset += hunk.new_count as i64 - hunk.old_count as i64;
        }

        Ok(lines.join("\n"))
    }
}

impl fmt::Display for FileDiff {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // Header
        let old_path = self.original_path.as_ref().unwrap_or(&self.path);
        writeln!(f, "--- a/{}", old_path.display())?;
        writeln!(f, "+++ b/{}", self.path.display())?;

        // Hunks
        for hunk in &self.hunks {
            write!(f, "{hunk}")?;
        }

        Ok(())
    }
}

/// File operation type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FileOperation {
    /// Create new file.
    Create,
    /// Delete file.
    Delete,
    /// Modify file.
    Modify,
    /// Rename file.
    Rename,
}

/// A hunk (contiguous change block).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Hunk {
    /// Old file start line.
    pub old_start: u32,
    /// Old file line count.
    pub old_count: u32,
    /// New file start line.
    pub new_start: u32,
    /// New file line count.
    pub new_count: u32,
    /// Lines in the hunk.
    pub lines: Vec<DiffLine>,
    /// Context before (for display).
    pub context_before: String,
    /// Context after (for display).
    pub context_after: String,
}

impl Hunk {
    /// Create a new empty hunk.
    pub fn new(old_start: u32, new_start: u32) -> Self {
        Self {
            old_start,
            old_count: 0,
            new_start,
            new_count: 0,
            lines: Vec::new(),
            context_before: String::new(),
            context_after: String::new(),
        }
    }

    /// Add a context line.
    pub fn add_context(&mut self, line: impl Into<String>) {
        self.lines.push(DiffLine::Context(line.into()));
        self.old_count += 1;
        self.new_count += 1;
    }

    /// Add an addition line.
    pub fn add_addition(&mut self, line: impl Into<String>) {
        self.lines.push(DiffLine::Add(line.into()));
        self.new_count += 1;
    }

    /// Add a removal line.
    pub fn add_removal(&mut self, line: impl Into<String>) {
        self.lines.push(DiffLine::Remove(line.into()));
        self.old_count += 1;
    }

    /// Reverse this hunk.
    pub fn reverse(&self) -> Self {
        Self {
            old_start: self.new_start,
            old_count: self.new_count,
            new_start: self.old_start,
            new_count: self.old_count,
            lines: self.lines.iter().map(DiffLine::reverse).collect(),
            context_before: self.context_after.clone(),
            context_after: self.context_before.clone(),
        }
    }
}

impl fmt::Display for Hunk {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(
            f,
            "@@ -{},{} +{},{} @@",
            self.old_start, self.old_count, self.new_start, self.new_count
        )?;

        for line in &self.lines {
            writeln!(f, "{line}")?;
        }

        Ok(())
    }
}

/// A single diff line.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum DiffLine {
    /// Context line (unchanged).
    Context(String),
    /// Added line.
    Add(String),
    /// Removed line.
    Remove(String),
}

impl DiffLine {
    /// Get the line content.
    pub fn content(&self) -> &str {
        match self {
            Self::Context(s) | Self::Add(s) | Self::Remove(s) => s,
        }
    }

    /// Check if this is an addition.
    pub fn is_add(&self) -> bool {
        matches!(self, Self::Add(_))
    }

    /// Check if this is a removal.
    pub fn is_remove(&self) -> bool {
        matches!(self, Self::Remove(_))
    }

    /// Check if this is context.
    pub fn is_context(&self) -> bool {
        matches!(self, Self::Context(_))
    }

    /// Reverse this diff line.
    pub fn reverse(&self) -> Self {
        match self {
            Self::Context(s) => Self::Context(s.clone()),
            Self::Add(s) => Self::Remove(s.clone()),
            Self::Remove(s) => Self::Add(s.clone()),
        }
    }
}

impl fmt::Display for DiffLine {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Context(s) => write!(f, " {s}"),
            Self::Add(s) => write!(f, "+{s}"),
            Self::Remove(s) => write!(f, "-{s}"),
        }
    }
}

/// Diff parser.
#[allow(dead_code)]
pub struct DiffParser {
    /// Context lines to include.
    context_lines: usize,
}

impl DiffParser {
    /// Create a new parser.
    pub fn new() -> Self {
        Self { context_lines: 3 }
    }

    /// Parse a unified diff.
    pub fn parse(&self, diff_text: &str) -> Result<UnifiedDiff> {
        let mut files = Vec::new();
        let mut current_file: Option<FileDiff> = None;
        let mut current_hunk: Option<Hunk> = None;

        for line in diff_text.lines() {
            if line.starts_with("---") {
                // Start of new file
                if let Some(mut file) = current_file.take() {
                    if let Some(hunk) = current_hunk.take() {
                        file.hunks.push(hunk);
                    }
                    files.push(file);
                }

                let path = line
                    .strip_prefix("--- ")
                    .and_then(|s| s.strip_prefix("a/"))
                    .unwrap_or(&line[4..]);

                current_file = Some(FileDiff {
                    path: PathBuf::from(path),
                    original_path: Some(PathBuf::from(path)),
                    operation: FileOperation::Modify,
                    hunks: Vec::new(),
                    mode: None,
                    is_binary: false,
                });
            } else if line.starts_with("+++") {
                if let Some(ref mut file) = current_file {
                    let path = line
                        .strip_prefix("+++ ")
                        .and_then(|s| s.strip_prefix("b/"))
                        .unwrap_or(&line[4..]);
                    file.path = PathBuf::from(path);

                    // Detect operation
                    if path == "/dev/null" {
                        file.operation = FileOperation::Delete;
                    } else if file.original_path.as_ref().map(|p| p.to_string_lossy())
                        == Some("/dev/null".into())
                    {
                        file.operation = FileOperation::Create;
                    }
                }
            } else if line.starts_with("@@") {
                // New hunk
                if let Some(ref mut file) = current_file {
                    if let Some(hunk) = current_hunk.take() {
                        file.hunks.push(hunk);
                    }

                    if let Some(hunk) = self.parse_hunk_header(line) {
                        current_hunk = Some(hunk);
                    }
                }
            } else if let Some(ref mut hunk) = current_hunk {
                // Hunk content
                if let Some(rest) = line.strip_prefix('+') {
                    hunk.add_addition(rest);
                } else if let Some(rest) = line.strip_prefix('-') {
                    hunk.add_removal(rest);
                } else if let Some(rest) = line.strip_prefix(' ') {
                    hunk.add_context(rest);
                } else if line.is_empty() {
                    hunk.add_context("");
                }
            }
        }

        // Don't forget the last file
        if let Some(mut file) = current_file {
            if let Some(hunk) = current_hunk {
                file.hunks.push(hunk);
            }
            files.push(file);
        }

        Ok(UnifiedDiff {
            files,
            original_text: Some(diff_text.to_string()),
        })
    }

    /// Parse a hunk header line.
    fn parse_hunk_header(&self, line: &str) -> Option<Hunk> {
        // Format: @@ -old_start,old_count +new_start,new_count @@
        let parts: Vec<_> = line.split_whitespace().collect();
        if parts.len() < 3 {
            return None;
        }

        let old_range = parts.get(1)?;
        let new_range = parts.get(2)?;

        let (old_start, old_count) = self.parse_range(old_range.strip_prefix('-')?)?;
        let (new_start, new_count) = self.parse_range(new_range.strip_prefix('+')?)?;

        Some(Hunk {
            old_start,
            old_count,
            new_start,
            new_count,
            lines: Vec::new(),
            context_before: String::new(),
            context_after: String::new(),
        })
    }

    /// Parse a range like "1,5" or "1".
    fn parse_range(&self, s: &str) -> Option<(u32, u32)> {
        if let Some((start, count)) = s.split_once(',') {
            Some((start.parse().ok()?, count.parse().ok()?))
        } else {
            let start: u32 = s.parse().ok()?;
            Some((start, 1))
        }
    }
}

impl Default for DiffParser {
    fn default() -> Self {
        Self::new()
    }
}

/// Compute diff between two strings.
pub fn diff(old: &str, new: &str) -> UnifiedDiff {
    use similar::{ChangeTag, TextDiff};

    let text_diff = TextDiff::from_lines(old, new);
    let mut hunks = Vec::new();
    let mut current_hunk: Option<Hunk> = None;
    let mut old_line = 1u32;
    let mut new_line = 1u32;

    for change in text_diff.iter_all_changes() {
        let tag = change.tag();
        let content = change.value().trim_end_matches('\n');

        match tag {
            ChangeTag::Equal => {
                if let Some(ref mut hunk) = current_hunk {
                    hunk.add_context(content);
                }
                old_line += 1;
                new_line += 1;
            }
            ChangeTag::Delete => {
                if current_hunk.is_none() {
                    current_hunk = Some(Hunk::new(old_line, new_line));
                }
                if let Some(ref mut hunk) = current_hunk {
                    hunk.add_removal(content);
                }
                old_line += 1;
            }
            ChangeTag::Insert => {
                if current_hunk.is_none() {
                    current_hunk = Some(Hunk::new(old_line, new_line));
                }
                if let Some(ref mut hunk) = current_hunk {
                    hunk.add_addition(content);
                }
                new_line += 1;
            }
        }

        // Finalize hunk if we have enough trailing context
        if tag == ChangeTag::Equal
            && let Some(ref hunk) = current_hunk
        {
            let context_count = hunk
                .lines
                .iter()
                .rev()
                .take_while(|l| l.is_context())
                .count();

            if context_count >= 3 {
                hunks.push(current_hunk.take().unwrap());
            }
        }
    }

    // Push remaining hunk
    if let Some(hunk) = current_hunk {
        hunks.push(hunk);
    }

    let file = FileDiff {
        path: PathBuf::from("file"),
        original_path: None,
        operation: FileOperation::Modify,
        hunks,
        mode: None,
        is_binary: false,
    };

    UnifiedDiff {
        files: if file.hunks.is_empty() {
            Vec::new()
        } else {
            vec![file]
        },
        original_text: None,
    }
}

/// Compute diff between two files.
pub async fn diff_files(old_path: &Path, new_path: &Path) -> Result<UnifiedDiff> {
    let old_content = tokio::fs::read_to_string(old_path)
        .await
        .map_err(CortexError::Io)?;
    let new_content = tokio::fs::read_to_string(new_path)
        .await
        .map_err(CortexError::Io)?;

    let mut result = diff(&old_content, &new_content);

    if let Some(ref mut file) = result.files.first_mut() {
        file.path = new_path.to_path_buf();
        file.original_path = Some(old_path.to_path_buf());
    }

    Ok(result)
}

/// Compute diff between two snapshots.
pub fn diff_snapshots(old: &Snapshot, new: &Snapshot) -> UnifiedDiff {
    let mut files = Vec::new();

    // Find all paths in both snapshots
    let mut all_paths: std::collections::HashSet<&PathBuf> =
        old.files.keys().chain(new.files.keys()).collect();

    let mut sorted_paths: Vec<_> = all_paths.drain().collect();
    sorted_paths.sort();

    for path in sorted_paths {
        let old_state = old.files.get(path);
        let new_state = new.files.get(path);

        match (old_state, new_state) {
            (
                Some(FileState::Exists {
                    content: old_content,
                    ..
                }),
                Some(FileState::Exists {
                    content: new_content,
                    ..
                }),
            ) => {
                if old_content != new_content {
                    let old_str = String::from_utf8_lossy(old_content);
                    let new_str = String::from_utf8_lossy(new_content);
                    let mut d = diff(&old_str, &new_str);
                    if let Some(mut file_diff) = d.files.pop() {
                        file_diff.path = path.clone();
                        file_diff.original_path = Some(path.clone());
                        file_diff.operation = FileOperation::Modify;
                        files.push(file_diff);
                    }
                }
            }
            (None | Some(FileState::NotExists), Some(FileState::Exists { content, .. })) => {
                // Created
                let content_str = String::from_utf8_lossy(content);
                files.push(FileDiff::new_file(path, &content_str));
            }
            (Some(FileState::Exists { content, .. }), None | Some(FileState::NotExists)) => {
                // Deleted
                let content_str = String::from_utf8_lossy(content);
                files.push(FileDiff::delete_file(path, &content_str));
            }
            _ => {}
        }
    }

    UnifiedDiff {
        files,
        original_text: None,
    }
}

/// Apply result.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ApplyResult {
    /// Files modified.
    pub files_modified: usize,
    /// Lines added.
    pub lines_added: usize,
    /// Lines removed.
    pub lines_removed: usize,
    /// Errors encountered.
    pub errors: Vec<FileError>,
}

impl ApplyResult {
    /// Check if apply was successful.
    pub fn is_success(&self) -> bool {
        self.errors.is_empty()
    }
}

/// Apply stats for a single file.
#[derive(Debug, Clone, Default)]
pub struct ApplyStats {
    /// Lines added.
    pub lines_added: usize,
    /// Lines removed.
    pub lines_removed: usize,
}

/// File error.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileError {
    /// File path.
    pub path: PathBuf,
    /// Error message.
    pub error: String,
}

/// Diff builder for creating diffs programmatically.
#[derive(Debug, Default)]
pub struct DiffBuilder {
    files: Vec<FileDiff>,
}

impl DiffBuilder {
    /// Create a new builder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Add a file creation.
    pub fn create_file(mut self, path: impl Into<PathBuf>, content: &str) -> Self {
        self.files.push(FileDiff::new_file(path, content));
        self
    }

    /// Add a file deletion.
    pub fn delete_file(mut self, path: impl Into<PathBuf>, content: &str) -> Self {
        self.files.push(FileDiff::delete_file(path, content));
        self
    }

    /// Add a file modification.
    pub fn modify_file(mut self, path: impl Into<PathBuf>, old: &str, new: &str) -> Self {
        let mut file_diff = diff(old, new);
        if let Some(mut file) = file_diff.files.pop() {
            file.path = path.into();
            self.files.push(file);
        }
        self
    }

    /// Build the unified diff.
    pub fn build(self) -> UnifiedDiff {
        UnifiedDiff {
            files: self.files,
            original_text: None,
        }
    }
}

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

    #[test]
    fn test_diff_computation() {
        let old = "line 1\nline 2\nline 3";
        let new = "line 1\nline 2 modified\nline 3\nline 4";

        let diff = diff(old, new);
        assert!(!diff.is_empty());
        assert!(diff.lines_added() > 0);
    }

    #[test]
    fn test_diff_parse() {
        let diff_text = r#"--- a/file.txt
+++ b/file.txt
@@ -1,3 +1,4 @@
 line 1
-line 2
+line 2 modified
 line 3
+line 4
"#;

        let diff = UnifiedDiff::parse(diff_text).unwrap();
        assert_eq!(diff.file_count(), 1);
        assert_eq!(diff.files[0].hunks.len(), 1);
    }

    #[test]
    fn test_hunk_display() {
        let mut hunk = Hunk::new(1, 1);
        hunk.add_context("context");
        hunk.add_removal("removed");
        hunk.add_addition("added");

        let s = hunk.to_string();
        assert!(s.contains("@@"));
        assert!(s.contains("-removed"));
        assert!(s.contains("+added"));
    }

    #[test]
    fn test_diff_builder() {
        let diff = DiffBuilder::new()
            .create_file("new.txt", "hello\nworld")
            .build();

        assert_eq!(diff.file_count(), 1);
        assert_eq!(diff.files[0].operation, FileOperation::Create);
    }

    #[test]
    fn test_diff_line() {
        let add = DiffLine::Add("test".to_string());
        assert!(add.is_add());
        assert_eq!(add.content(), "test");
        assert_eq!(format!("{}", add), "+test");
    }

    #[test]
    fn test_diff_snapshots() {
        let mut old = Snapshot::new("old", "Old state");
        old.add_file(
            "modified.txt",
            FileState::Exists {
                content: b"original content".to_vec(),
                permissions: None,
                modified: None,
            },
        );
        old.add_file(
            "deleted.txt",
            FileState::Exists {
                content: b"bye".to_vec(),
                permissions: None,
                modified: None,
            },
        );

        let mut new = Snapshot::new("new", "New state");
        new.add_file(
            "modified.txt",
            FileState::Exists {
                content: b"new content".to_vec(),
                permissions: None,
                modified: None,
            },
        );
        new.add_file(
            "created.txt",
            FileState::Exists {
                content: b"hello".to_vec(),
                permissions: None,
                modified: None,
            },
        );

        let diff = diff_snapshots(&old, &new);
        assert_eq!(diff.file_count(), 3);

        let paths: Vec<_> = diff
            .files
            .iter()
            .map(|f| f.path.to_str().unwrap())
            .collect();
        assert!(paths.contains(&"modified.txt"));
        assert!(paths.contains(&"created.txt"));
        assert!(paths.contains(&"deleted.txt"));
    }
}