ryo_storage/storage/

autosave.rs

//! Auto-saving transaction logger.
//!
//! Wraps `TxLogger` with automatic persistence based on `TxLogMode`.

use crate::storage::{Format, RyoStorage, StateRef, StorageResult, TxLogMode};
use crate::txlog::{MutationRecord, TxAction, TxLog, TxLogger};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

/// Transaction logger with automatic persistence.
///
/// Wraps a `TxLogger` and automatically saves to `~/.ryo/` based on the
/// configured `TxLogMode`.
///
/// # Example
///
/// ```ignore
/// use ryo_core::storage::{AutoSaveLogger, TxLogMode};
///
/// // Create with auto-save on commit
/// let logger = AutoSaveLogger::new("/my/project", 100, TxLogMode::OnCommit)?;
///
/// // Log as usual
/// logger.log_mutation("Rename", "foo -> bar", 5);
///
/// // Trigger save (e.g., called from CodingWorld::commit_changes)
/// logger.on_commit()?;
///
/// // Finish and get the log
/// let log = logger.finish()?;
/// ```
pub struct AutoSaveLogger {
    /// Underlying async logger
    inner: TxLogger,
    /// Auto-save mode
    mode: TxLogMode,
    /// Storage format
    format: Format,
    /// Storage reference (lazy-initialized)
    storage: Arc<Mutex<Option<RyoStorage>>>,
    /// Track if we've persisted already
    persisted: bool,
    /// Session ID for this logger
    session_id: Option<String>,
}

impl AutoSaveLogger {
    /// Create a new auto-save logger.
    pub fn new(
        project_path: impl Into<PathBuf>,
        file_count: usize,
        mode: TxLogMode,
    ) -> StorageResult<Self> {
        Self::with_format(project_path, file_count, mode, Format::default())
    }

    /// Create with a specific storage format.
    pub fn with_format(
        project_path: impl Into<PathBuf>,
        file_count: usize,
        mode: TxLogMode,
        format: Format,
    ) -> StorageResult<Self> {
        let inner = TxLogger::start(project_path, file_count);

        Ok(Self {
            inner,
            mode,
            format,
            storage: Arc::new(Mutex::new(None)),
            persisted: false,
            session_id: None,
        })
    }

    /// Create with explicit storage (for testing or custom paths).
    pub fn with_storage(
        project_path: impl Into<PathBuf>,
        file_count: usize,
        mode: TxLogMode,
        storage: RyoStorage,
    ) -> Self {
        let inner = TxLogger::start(project_path, file_count);

        Self {
            inner,
            mode,
            format: Format::default(),
            storage: Arc::new(Mutex::new(Some(storage))),
            persisted: false,
            session_id: None,
        }
    }

    /// Get the storage format.
    pub fn format(&self) -> Format {
        self.format
    }

    /// Get the current mode.
    pub fn mode(&self) -> TxLogMode {
        self.mode
    }

    /// Set the mode (can be changed at runtime).
    pub fn set_mode(&mut self, mode: TxLogMode) {
        self.mode = mode;
    }

    // =========================================================================
    // Delegated logging methods
    // =========================================================================

    /// Log an action.
    pub fn log(&self, action: TxAction) {
        self.inner.log(action);
    }

    /// Log a goal being set.
    pub fn log_goal(&self, query: &str, intent_type: &str, confidence: f64) {
        self.inner.log_goal(query, intent_type, confidence);
    }

    /// Log a mutation being applied (legacy API - NOT replayable).
    ///
    /// **Note**: For replayable logging, use `record_mutation()` instead.
    /// If mode is `OnMutation`, this will trigger a persist.
    pub fn log_mutation(
        &mut self,
        mutation_type: &str,
        target: &str,
        changes: usize,
    ) -> StorageResult<()> {
        self.inner.log_mutation(mutation_type, target, changes);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Record a mutation with automatic serialization (REPLAYABLE).
    ///
    /// This is the preferred method for logging mutations.
    /// If mode is `OnMutation`, this will trigger a persist.
    pub fn record_mutation<M>(&mut self, mutation: &M, changes: usize) -> StorageResult<()>
    where
        M: ryo_mutations::Mutation + ryo_mutations::ToSerializable,
    {
        self.inner.record_mutation(mutation, changes);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Record a mutation with file path (REPLAYABLE).
    ///
    /// If mode is `OnMutation`, this will trigger a persist.
    pub fn record_mutation_for_file<M>(
        &mut self,
        mutation: &M,
        changes: usize,
        file_path: impl AsRef<Path>,
    ) -> StorageResult<()>
    where
        M: ryo_mutations::Mutation + ryo_mutations::ToSerializable,
    {
        self.inner
            .record_mutation_for_file(mutation, changes, file_path);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Record a mutation with full state tracking (REPLAYABLE + VERIFIABLE).
    ///
    /// If mode is `OnMutation`, this will trigger a persist.
    pub fn record_mutation_tracked<M>(
        &mut self,
        mutation: &M,
        changes: usize,
        file_path: impl AsRef<Path>,
        pre_state: StateRef,
        post_state: StateRef,
    ) -> StorageResult<()>
    where
        M: ryo_mutations::Mutation + ryo_mutations::ToSerializable,
    {
        self.inner
            .record_mutation_tracked(mutation, changes, file_path, pre_state, post_state);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Log a mutation with data.
    pub fn log_mutation_with_data(
        &mut self,
        mutation_type: &str,
        target: &str,
        changes: usize,
        data: serde_json::Value,
    ) -> StorageResult<()> {
        self.inner
            .log_mutation_with_data(mutation_type, target, changes, data);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Log a batch of mutations.
    pub fn log_mutation_batch(
        &mut self,
        mutations: Vec<MutationRecord>,
        total_changes: usize,
    ) -> StorageResult<()> {
        self.inner.log_mutation_batch(mutations, total_changes);

        if self.mode.persist_on_mutation() {
            self.persist()?;
        }

        Ok(())
    }

    /// Log file loaded.
    pub fn log_file_loaded(&self, path: &Path, size_bytes: usize) {
        self.inner.log_file_loaded(path, size_bytes);
    }

    /// Log file modified.
    pub fn log_file_modified(&self, path: &Path, changes: usize) {
        self.inner.log_file_modified(path, changes);
    }

    /// Log file written.
    pub fn log_file_written(&self, path: &Path) {
        self.inner.log_file_written(path);
    }

    /// Log compile check result.
    pub fn log_compile_check(&self, success: bool, errors: Vec<String>) {
        self.inner.log_compile_check(success, errors);
    }

    /// Create a checkpoint.
    pub fn checkpoint(&self, name: &str) {
        self.inner.checkpoint(name);
    }

    /// Log an undo operation.
    pub fn log_undo(&self, target_id: u64) {
        self.inner.log_undo(target_id);
    }

    /// Log a redo operation.
    pub fn log_redo(&self, target_id: u64) {
        self.inner.log_redo(target_id);
    }

    /// Log a custom action.
    pub fn log_custom(&self, name: &str, data: serde_json::Value) {
        self.inner.log_custom(name, data);
    }

    // =========================================================================
    // Persistence triggers
    // =========================================================================

    /// Called when commit_changes() is invoked.
    ///
    /// If mode is `OnCommit`, this will trigger a persist.
    pub fn on_commit(&mut self) -> StorageResult<()> {
        if self.mode.persist_on_commit() {
            self.persist()?;
        }
        Ok(())
    }

    /// Explicitly persist the current log to storage.
    ///
    /// This can be called at any time, regardless of mode.
    /// Uses incremental save if session already has an ID.
    pub fn persist(&mut self) -> StorageResult<String> {
        if !self.mode.should_persist() && self.session_id.is_none() {
            // Mode is Off or Memory and we haven't started persisting
            // Skip actual persistence but return a placeholder
            return Ok(String::from("not-persisted"));
        }

        // For now, we can't get the log without finishing.
        // In a more sophisticated implementation, we'd need to:
        // 1. Send a "snapshot" message to the background thread
        // 2. Wait for it to return the current log state
        //
        // For simplicity, we'll mark that persistence is needed
        // and do the actual persistence in finish().
        self.persisted = false;

        Ok(self
            .session_id
            .clone()
            .unwrap_or_else(|| "pending".to_string()))
    }

    /// Finish logging and persist the final log.
    ///
    /// Returns the complete log and the session ID if persisted.
    pub fn finish(self) -> StorageResult<(TxLog, Option<String>)> {
        let should_persist = self.mode.should_persist();
        let storage_arc = Arc::clone(&self.storage);
        let format = self.format;

        // Now consume inner to get the log
        let log = self.inner.finish();

        // Persist if needed
        let session_id = if should_persist {
            let mut guard = storage_arc.lock().expect("autosave storage mutex poisoned");
            if guard.is_none() {
                let storage = RyoStorage::global()?.with_format(format);
                storage.ensure_init()?;
                *guard = Some(storage);
            }
            let storage = guard
                .as_mut()
                .expect("Some(storage) ensured by the is_none() init above");
            let id = storage.dump(&log)?;
            Some(id)
        } else {
            None
        };

        Ok((log, session_id))
    }

    /// Finish and return just the log (for compatibility).
    pub fn finish_log(self) -> TxLog {
        self.inner.finish()
    }

    /// Get elapsed time since session start.
    pub fn elapsed_ms(&self) -> u64 {
        self.inner.elapsed_ms()
    }
}

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

    #[test]
    fn test_autosave_off_mode() {
        let logger = AutoSaveLogger::new("/test/project", 10, TxLogMode::Off).unwrap();

        logger.log_goal("test", "test", 0.9);

        let (log, session_id) = logger.finish().unwrap();
        assert!(!log.is_empty());
        assert!(session_id.is_none());
    }

    #[test]
    fn test_autosave_memory_mode() {
        let logger = AutoSaveLogger::new("/test/project", 10, TxLogMode::Memory).unwrap();

        logger.log_goal("test", "test", 0.9);

        let (log, session_id) = logger.finish().unwrap();
        assert!(!log.is_empty());
        assert!(session_id.is_none());
    }

    #[test]
    fn test_autosave_on_commit_mode() {
        let temp = TempDir::new().unwrap();
        let storage = RyoStorage::new(temp.path().join(".ryo")).unwrap();

        let mut logger =
            AutoSaveLogger::with_storage("/test/project", 10, TxLogMode::OnCommit, storage);

        logger.log_goal("test", "test", 0.9);
        logger.on_commit().unwrap();

        let (log, session_id) = logger.finish().unwrap();
        assert!(!log.is_empty());
        assert!(session_id.is_some());
    }

    #[test]
    fn test_autosave_on_mutation_mode() {
        let temp = TempDir::new().unwrap();
        let storage = RyoStorage::new(temp.path().join(".ryo")).unwrap();

        let mut logger =
            AutoSaveLogger::with_storage("/test/project", 10, TxLogMode::OnMutation, storage);

        logger.log_mutation("Rename", "foo -> bar", 3).unwrap();

        let (log, session_id) = logger.finish().unwrap();
        assert!(!log.is_empty());
        assert!(session_id.is_some());
    }
}