gravityfile_ops/

undo.rs

//! Undo log for file operations.

use std::collections::VecDeque;
use std::path::PathBuf;
use std::time::SystemTime;

use serde::{Deserialize, Serialize};

/// An entry in the undo log.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UndoEntry {
    /// Unique ID for this entry.
    pub id: u64,
    /// When the operation was performed.
    pub timestamp: SystemTime,
    /// The operation that was performed.
    pub operation: UndoableOperation,
    /// Human-readable description.
    pub description: String,
}

impl UndoEntry {
    /// Create a new undo entry.
    pub fn new(id: u64, operation: UndoableOperation, description: impl Into<String>) -> Self {
        Self {
            id,
            timestamp: SystemTime::now(),
            operation,
            description: description.into(),
        }
    }
}

/// An operation that can be undone.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum UndoableOperation {
    /// Files were moved from one location to another.
    FilesMoved {
        /// List of (original_path, new_path) pairs.
        moves: Vec<(PathBuf, PathBuf)>,
    },
    /// Files were copied to a destination.
    FilesCopied {
        /// List of created files/directories.
        created: Vec<PathBuf>,
    },
    /// Files were moved to trash or permanently deleted.
    FilesDeleted {
        /// List of paths that were deleted.
        paths: Vec<PathBuf>,
    },
    /// A file or directory was renamed.
    FileRenamed {
        /// The full path with the new name (after rename).
        path: PathBuf,
        /// The full original path (before rename) — used to undo.
        // HIGH-5: store full old path instead of bare old_name string
        old_path: PathBuf,
        /// The new name (informational).
        new_name: String,
    },
    /// A file was created.
    FileCreated {
        /// Path to the created file.
        path: PathBuf,
    },
    /// A directory was created.
    DirectoryCreated {
        /// Path to the created directory.
        path: PathBuf,
    },
}

impl UndoableOperation {
    /// Get a description of how to undo this operation.
    pub fn undo_description(&self) -> String {
        match self {
            Self::FilesMoved { moves } => {
                format!("Move {} items back to original location", moves.len())
            }
            Self::FilesCopied { created } => {
                format!("Delete {} copied items", created.len())
            }
            Self::FilesDeleted { paths } => {
                format!("Deleted {} items (recover via OS trash)", paths.len())
            }
            Self::FileRenamed { old_path, .. } => {
                format!(
                    "Rename back to '{}'",
                    old_path
                        .file_name()
                        .map(|n| n.to_string_lossy().into_owned())
                        .unwrap_or_default()
                )
            }
            Self::FileCreated { .. } => "Delete the created file".to_string(),
            Self::DirectoryCreated { .. } => "Delete the created directory".to_string(),
        }
    }

    /// Check if this operation can be undone.
    pub fn can_undo(&self) -> bool {
        !matches!(self, Self::FilesDeleted { .. })
    }
}

/// Undo log with configurable maximum depth.
#[derive(Debug)]
pub struct UndoLog {
    entries: VecDeque<UndoEntry>,
    max_entries: usize,
    next_id: u64,
}

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

impl UndoLog {
    /// Create a new undo log with the specified maximum entries.
    pub fn new(max_entries: usize) -> Self {
        Self {
            entries: VecDeque::with_capacity(max_entries.min(1000)),
            max_entries,
            next_id: 0,
        }
    }

    /// Record an operation in the undo log.
    ///
    /// Returns the ID assigned to this entry.
    pub fn record(&mut self, operation: UndoableOperation, description: impl Into<String>) -> u64 {
        let id = self.next_id;
        self.next_id += 1;

        // Remove oldest entry if at capacity
        if self.entries.len() >= self.max_entries {
            self.entries.pop_front();
        }

        self.entries
            .push_back(UndoEntry::new(id, operation, description));

        id
    }

    /// Record a move operation.
    pub fn record_move(&mut self, moves: Vec<(PathBuf, PathBuf)>) -> u64 {
        let count = moves.len();
        self.record(
            UndoableOperation::FilesMoved { moves },
            format!("Moved {} items", count),
        )
    }

    /// Record a copy operation.
    pub fn record_copy(&mut self, created: Vec<PathBuf>) -> u64 {
        let count = created.len();
        self.record(
            UndoableOperation::FilesCopied { created },
            format!("Copied {} items", count),
        )
    }

    /// Record a delete operation.
    pub fn record_delete(&mut self, paths: Vec<PathBuf>) -> u64 {
        let count = paths.len();
        self.record(
            UndoableOperation::FilesDeleted { paths },
            format!("Deleted {} items", count),
        )
    }

    /// Record a rename operation.
    ///
    /// `source` is the full original path before the rename.
    /// `new_name` is the new name component (used for the description).
    pub fn record_rename(&mut self, source: PathBuf, new_name: String) -> u64 {
        let parent = source.parent().unwrap_or(std::path::Path::new(""));
        let new_path = parent.join(&new_name);
        let old_name = source
            .file_name()
            .map(|n| n.to_string_lossy().into_owned())
            .unwrap_or_default();
        let description = format!("Renamed '{}' to '{}'", old_name, new_name);
        self.record(
            UndoableOperation::FileRenamed {
                path: new_path,
                old_path: source,
                new_name,
            },
            description,
        )
    }

    /// Record a file creation.
    pub fn record_create_file(&mut self, path: PathBuf) -> u64 {
        let name = path
            .file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_default();
        self.record(
            UndoableOperation::FileCreated { path },
            format!("Created file '{}'", name),
        )
    }

    /// Record a directory creation.
    pub fn record_create_directory(&mut self, path: PathBuf) -> u64 {
        let name = path
            .file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_default();
        self.record(
            UndoableOperation::DirectoryCreated { path },
            format!("Created directory '{}'", name),
        )
    }

    /// Pop the most recent undoable entry.
    ///
    /// Returns `None` if the log is empty or the back entry cannot be undone.
    /// Does NOT drain through non-undoable entries — only examines the back.
    pub fn pop(&mut self) -> Option<UndoEntry> {
        // HIGH-4: only look at the back entry; don't consume non-undoable ones
        if self.entries.back()?.operation.can_undo() {
            self.entries.pop_back()
        } else {
            None
        }
    }

    /// Peek at the most recent entry without removing it.
    pub fn peek(&self) -> Option<&UndoEntry> {
        self.entries.back()
    }

    /// Get the number of entries in the log.
    pub fn len(&self) -> usize {
        self.entries.len()
    }

    /// Check if the log is empty.
    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// Clear all entries from the log.
    pub fn clear(&mut self) {
        self.entries.clear();
    }

    /// Get an iterator over all entries (oldest first).
    pub fn iter(&self) -> impl Iterator<Item = &UndoEntry> {
        self.entries.iter()
    }
}

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

    #[test]
    fn test_undo_log_record() {
        let mut log = UndoLog::new(10);

        let id = log.record_create_file(PathBuf::from("/test/file.txt"));
        assert_eq!(id, 0);
        assert_eq!(log.len(), 1);

        let id = log.record_create_directory(PathBuf::from("/test/dir"));
        assert_eq!(id, 1);
        assert_eq!(log.len(), 2);
    }

    #[test]
    fn test_undo_log_max_entries() {
        let mut log = UndoLog::new(3);

        log.record_create_file(PathBuf::from("/test/1.txt"));
        log.record_create_file(PathBuf::from("/test/2.txt"));
        log.record_create_file(PathBuf::from("/test/3.txt"));
        assert_eq!(log.len(), 3);

        log.record_create_file(PathBuf::from("/test/4.txt"));
        assert_eq!(log.len(), 3);

        // First entry should be removed
        let entry = log.pop().unwrap();
        assert!(entry.description.contains("4.txt"));
    }

    #[test]
    fn test_undo_log_pop() {
        let mut log = UndoLog::new(10);

        log.record_create_file(PathBuf::from("/test/file.txt"));
        log.record_rename(PathBuf::from("/test/old.txt"), "new.txt".to_string());

        let entry = log.pop().unwrap();
        assert!(matches!(
            entry.operation,
            UndoableOperation::FileRenamed { .. }
        ));

        let entry = log.pop().unwrap();
        assert!(matches!(
            entry.operation,
            UndoableOperation::FileCreated { .. }
        ));

        assert!(log.pop().is_none());
    }

    #[test]
    fn test_pop_does_not_drain_non_undoable() {
        let mut log = UndoLog::new(10);
        log.record_create_file(PathBuf::from("/test/file.txt"));
        // Delete is non-undoable; push it last so it is the back entry
        log.record_delete(vec![PathBuf::from("/test/other.txt")]);

        // pop() should return None because the back entry is non-undoable
        assert!(log.pop().is_none());
        // The undoable create entry must still be present
        assert_eq!(log.len(), 2);
    }
}