magellan 3.3.6

//! Execution log for tracking Magellan runs
//!
//! Records every CLI command execution with execution_id, timestamps,
//! arguments, and outcome. Provides audit trail for correlating outputs.

use anyhow::Result;
use rusqlite::{params, OptionalExtension};
use std::path::Path;
use std::sync::{Arc, Mutex};

/// Execution log entry
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ExecutionRecord {
    pub id: i64,
    pub execution_id: String,
    pub tool_version: String,
    pub args: String, // JSON array
    pub root: Option<String>,
    pub db_path: String,
    pub started_at: i64,
    pub finished_at: Option<i64>,
    pub duration_ms: Option<i64>,
    pub outcome: String, // "success", "error", "partial"
    pub error_message: Option<String>,
    pub files_indexed: i64,
    pub symbols_indexed: i64,
    pub references_indexed: i64,
}

/// Backend storage for ExecutionLog
enum ExecutionLogBackend {
    /// SQLite database path (opens new connection per operation)
    Sqlite(std::path::PathBuf),
    /// Shared connection from CodeGraph (avoids opening new connections)
    Shared(Arc<Mutex<rusqlite::Connection>>),
    /// SideTables abstraction (V3 backend)
    SideTables(Arc<dyn super::side_tables::SideTables>),
}

/// Execution log storage
///
/// Uses either:
/// - SQLite connection to database file (legacy)
/// - Shared connection from CodeGraph
/// - SideTables trait abstraction (V3 backend)
pub struct ExecutionLog {
    backend: ExecutionLogBackend,
}

impl ExecutionLog {
    /// Create a new ExecutionLog with the given database path.
    pub fn new(db_path: &Path) -> Self {
        Self {
            backend: ExecutionLogBackend::Sqlite(db_path.to_path_buf()),
        }
    }

    /// Create an ExecutionLog using a shared connection.
    ///
    /// This eliminates redundant connection opens by reusing CodeGraph's side_conn.
    pub fn with_connection(conn: Arc<Mutex<rusqlite::Connection>>) -> Self {
        let log = Self {
            backend: ExecutionLogBackend::Shared(conn),
        };
        if let Err(e) = log.ensure_schema() {
            eprintln!("Warning: Failed to ensure ExecutionLog schema: {}", e);
        }
        log
    }

    /// Create an ExecutionLog using the SideTables abstraction.
    ///
    /// This constructor is used for V3 backend where we want to avoid SQLite
    /// entirely for side tables.
    pub fn with_side_tables(side_tables: Arc<dyn super::side_tables::SideTables>) -> Self {
        Self {
            backend: ExecutionLogBackend::SideTables(side_tables),
        }
    }

    /// Create an in-memory ExecutionLog for testing/stub usage.
    ///
    /// Uses a temporary file so that new connections can access the same data.
    pub fn in_memory() -> Self {
        let temp_dir = std::env::temp_dir();
        let unique_id = format!(
            "{}_{}",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        );
        let db_path = temp_dir.join(format!("magellan_execution_log_stub_{}.db", unique_id));

        let log = Self {
            backend: ExecutionLogBackend::Sqlite(db_path),
        };

        // Ensure schema exists
        if let Err(e) = log.ensure_schema() {
            eprintln!("Warning: Failed to ensure ExecutionLog schema: {}", e);
        }

        log
    }

    /// Get a connection to the database (SQLite backend only).
    ///
    /// Returns an error when using Shared or SideTables backends.
    pub fn connect(&self) -> Result<rusqlite::Connection, rusqlite::Error> {
        match &self.backend {
            ExecutionLogBackend::Sqlite(path) => rusqlite::Connection::open(path),
            ExecutionLogBackend::Shared(_) => Err(rusqlite::Error::InvalidParameterName(
                "Direct SQLite connection not available for shared backend".to_string(),
            )),
            ExecutionLogBackend::SideTables(_) => Err(rusqlite::Error::InvalidParameterName(
                "SQLite connection not available for SideTables backend".to_string(),
            )),
        }
    }

    fn ensure_schema_sqlite(conn: &rusqlite::Connection) -> Result<(), anyhow::Error> {
        conn.execute(
            "CREATE TABLE IF NOT EXISTS execution_log (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    execution_id TEXT NOT NULL UNIQUE,
                    tool_version TEXT NOT NULL,
                    args TEXT NOT NULL,
                    root TEXT,
                    db_path TEXT NOT NULL,
                    started_at INTEGER NOT NULL,
                    finished_at INTEGER,
                    duration_ms INTEGER,
                    outcome TEXT NOT NULL,
                    error_message TEXT,
                    files_indexed INTEGER DEFAULT 0,
                    symbols_indexed INTEGER DEFAULT 0,
                    references_indexed INTEGER DEFAULT 0
                )",
            [],
        )
        .map_err(|e| anyhow::anyhow!("Failed to create execution_log table: {}", e))?;

        conn.execute(
            "CREATE INDEX IF NOT EXISTS idx_execution_log_started_at
                    ON execution_log(started_at DESC)",
            [],
        )
        .map_err(|e| anyhow::anyhow!("Failed to create started_at index: {}", e))?;

        conn.execute(
            "CREATE INDEX IF NOT EXISTS idx_execution_log_execution_id
                    ON execution_log(execution_id)",
            [],
        )
        .map_err(|e| anyhow::anyhow!("Failed to create execution_id index: {}", e))?;

        conn.execute(
            "CREATE INDEX IF NOT EXISTS idx_execution_log_outcome
                    ON execution_log(outcome)",
            [],
        )
        .map_err(|e| anyhow::anyhow!("Failed to create outcome index: {}", e))?;

        Ok(())
    }

    pub fn ensure_schema(&self) -> Result<()> {
        match &self.backend {
            ExecutionLogBackend::Sqlite(_) => {
                let conn = self.connect()?;
                Self::ensure_schema_sqlite(&conn)
            }
            ExecutionLogBackend::Shared(conn_arc) => {
                let conn = match conn_arc.lock() {
                    Ok(guard) => guard,
                    Err(poisoned) => poisoned.into_inner(),
                };
                Self::ensure_schema_sqlite(&conn)
            }
            ExecutionLogBackend::SideTables(_) => {
                // V3 backend handles schema automatically
                Ok(())
            }
        }
    }

    fn start_execution_sqlite(
        conn: &rusqlite::Connection,
        execution_id: &str,
        tool_version: &str,
        args: &[String],
        root: Option<&str>,
        db_path: &str,
    ) -> Result<i64> {
        let args_json = serde_json::to_string(args)?;
        let started_at = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs() as i64;

        conn.execute(
            "INSERT INTO execution_log
                    (execution_id, tool_version, args, root, db_path, started_at, outcome)
                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'running')",
            params![
                execution_id,
                tool_version,
                args_json,
                root,
                db_path,
                started_at
            ],
        )
        .map_err(|e| anyhow::anyhow!("Failed to insert execution log: {}", e))?;

        Ok(conn.last_insert_rowid())
    }

    pub fn start_execution(
        &self,
        execution_id: &str,
        tool_version: &str,
        args: &[String],
        root: Option<&str>,
        db_path: &str,
    ) -> Result<i64> {
        match &self.backend {
            ExecutionLogBackend::Sqlite(_) => {
                let conn = self.connect()?;
                Self::start_execution_sqlite(&conn, execution_id, tool_version, args, root, db_path)
            }
            ExecutionLogBackend::Shared(conn_arc) => {
                let conn = match conn_arc.lock() {
                    Ok(guard) => guard,
                    Err(poisoned) => poisoned.into_inner(),
                };
                Self::start_execution_sqlite(&conn, execution_id, tool_version, args, root, db_path)
            }
            ExecutionLogBackend::SideTables(side_tables) => {
                side_tables.start_execution(execution_id, tool_version, args, root, db_path)
            }
        }
    }

    fn finish_execution_sqlite(
        conn: &rusqlite::Connection,
        execution_id: &str,
        outcome: &str,
        error_message: Option<&str>,
        files_indexed: usize,
        symbols_indexed: usize,
        references_indexed: usize,
    ) -> Result<()> {
        let now = std::time::SystemTime::now();
        let finished_at_secs = now
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs() as i64;
        let finished_at_ms = now
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_millis() as i64;

        let started_at_secs: i64 = conn
            .query_row(
                "SELECT started_at FROM execution_log WHERE execution_id = ?1",
                params![execution_id],
                |row| row.get(0),
            )
            .optional()?
            .unwrap_or(finished_at_secs);
        let started_at_ms = started_at_secs * 1000;

        let duration_ms = finished_at_ms - started_at_ms;

        conn.execute(
            "UPDATE execution_log
                    SET finished_at = ?1, outcome = ?2, error_message = ?3,
                        duration_ms = ?4, files_indexed = ?5, symbols_indexed = ?6,
                        references_indexed = ?7
                    WHERE execution_id = ?8",
            params![
                finished_at_secs,
                outcome,
                error_message,
                duration_ms,
                files_indexed as i64,
                symbols_indexed as i64,
                references_indexed as i64,
                execution_id,
            ],
        )
        .map_err(|e| anyhow::anyhow!("Failed to update execution log: {}", e))?;

        Ok(())
    }

    pub fn finish_execution(
        &self,
        execution_id: &str,
        outcome: &str,
        error_message: Option<&str>,
        files_indexed: usize,
        symbols_indexed: usize,
        references_indexed: usize,
    ) -> Result<()> {
        match &self.backend {
            ExecutionLogBackend::Sqlite(_) => {
                let conn = self.connect()?;
                Self::finish_execution_sqlite(
                    &conn,
                    execution_id,
                    outcome,
                    error_message,
                    files_indexed,
                    symbols_indexed,
                    references_indexed,
                )
            }
            ExecutionLogBackend::Shared(conn_arc) => {
                let conn = match conn_arc.lock() {
                    Ok(guard) => guard,
                    Err(poisoned) => poisoned.into_inner(),
                };
                Self::finish_execution_sqlite(
                    &conn,
                    execution_id,
                    outcome,
                    error_message,
                    files_indexed,
                    symbols_indexed,
                    references_indexed,
                )
            }
            ExecutionLogBackend::SideTables(side_tables) => side_tables.finish_execution(
                execution_id,
                outcome,
                error_message,
                files_indexed,
                symbols_indexed,
                references_indexed,
            ),
        }
    }

    fn row_to_execution_record(row: &rusqlite::Row) -> Result<ExecutionRecord, rusqlite::Error> {
        Ok(ExecutionRecord {
            id: row.get(0)?,
            execution_id: row.get(1)?,
            tool_version: row.get(2)?,
            args: row.get(3)?,
            root: row.get(4)?,
            db_path: row.get(5)?,
            started_at: row.get(6)?,
            finished_at: row.get(7)?,
            duration_ms: row.get(8)?,
            outcome: row.get(9)?,
            error_message: row.get(10)?,
            files_indexed: row.get(11)?,
            symbols_indexed: row.get(12)?,
            references_indexed: row.get(13)?,
        })
    }

    /// Get an execution record by execution_id
    pub fn get_by_execution_id(&self, execution_id: &str) -> Result<Option<ExecutionRecord>> {
        match &self.backend {
            ExecutionLogBackend::Sqlite(_) => {
                let conn = self.connect()?;
                let result = conn
                    .query_row(
                        "SELECT id, execution_id, tool_version, args, root, db_path,
                                started_at, finished_at, duration_ms, outcome, error_message,
                                files_indexed, symbols_indexed, references_indexed
                         FROM execution_log
                         WHERE execution_id = ?1",
                        params![execution_id],
                        Self::row_to_execution_record,
                    )
                    .optional()
                    .map_err(|e| anyhow::anyhow!("Failed to query execution log: {}", e))?;
                Ok(result)
            }
            ExecutionLogBackend::Shared(conn_arc) => {
                let conn = match conn_arc.lock() {
                    Ok(guard) => guard,
                    Err(poisoned) => poisoned.into_inner(),
                };
                let result = conn
                    .query_row(
                        "SELECT id, execution_id, tool_version, args, root, db_path,
                                started_at, finished_at, duration_ms, outcome, error_message,
                                files_indexed, symbols_indexed, references_indexed
                         FROM execution_log
                         WHERE execution_id = ?1",
                        params![execution_id],
                        Self::row_to_execution_record,
                    )
                    .optional()
                    .map_err(|e| anyhow::anyhow!("Failed to query execution log: {}", e))?;
                Ok(result)
            }
            ExecutionLogBackend::SideTables(side_tables) => side_tables.get_execution(execution_id),
        }
    }

    /// Get all execution records, ordered by most recent first
    pub fn list_all(&self, limit: Option<usize>) -> Result<Vec<ExecutionRecord>> {
        let limit_clause = limit.map(|l| format!(" LIMIT {}", l)).unwrap_or_default();
        let sql = format!(
            "SELECT id, execution_id, tool_version, args, root, db_path,
                    started_at, finished_at, duration_ms, outcome, error_message,
                    files_indexed, symbols_indexed, references_indexed
             FROM execution_log
             ORDER BY started_at DESC{}",
            limit_clause
        );

        match &self.backend {
            ExecutionLogBackend::Sqlite(_) => {
                let conn = self.connect()?;
                let mut stmt = conn.prepare(&sql)?;
                let records = stmt
                    .query_map([], Self::row_to_execution_record)?
                    .collect::<Result<Vec<_>, _>>()
                    .map_err(|e| anyhow::anyhow!("Failed to collect execution records: {}", e))?;
                Ok(records)
            }
            ExecutionLogBackend::Shared(conn_arc) => {
                let conn = match conn_arc.lock() {
                    Ok(guard) => guard,
                    Err(poisoned) => poisoned.into_inner(),
                };
                let mut stmt = conn.prepare(&sql)?;
                let records = stmt
                    .query_map([], Self::row_to_execution_record)?
                    .collect::<Result<Vec<_>, _>>()
                    .map_err(|e| anyhow::anyhow!("Failed to collect execution records: {}", e))?;
                Ok(records)
            }
            ExecutionLogBackend::SideTables(side_tables) => side_tables.list_executions(limit),
        }
    }
}

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

    #[test]
    fn test_execution_log_schema() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        // ensure_schema should create table without error
        log.ensure_schema().unwrap();

        // Verify table exists by querying it
        let conn = log.connect().unwrap();
        let table_exists: bool = conn
            .query_row(
                "SELECT 1 FROM sqlite_master WHERE type='table' AND name='execution_log'",
                [],
                |_| Ok(true),
            )
            .optional()
            .unwrap()
            .unwrap_or(false);

        assert!(table_exists, "execution_log table should exist");
    }

    #[test]
    fn test_execution_log_insert_and_update() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        log.ensure_schema().unwrap();

        // Start an execution
        let row_id = log
            .start_execution(
                "test-exec-001",
                "0.1.0",
                &["magellan".to_string(), "index".to_string()],
                Some("/project"),
                "/project/magellan.db",
            )
            .unwrap();

        assert!(row_id > 0, "Row ID should be positive");

        // Verify initial state
        let record = log.get_by_execution_id("test-exec-001").unwrap();
        assert!(record.is_some());
        let rec = record.unwrap();
        assert_eq!(rec.execution_id, "test-exec-001");
        assert_eq!(rec.tool_version, "0.1.0");
        assert_eq!(rec.outcome, "running");
        assert!(rec.finished_at.is_none());
        assert!(rec.duration_ms.is_none());

        // Finish the execution
        log.finish_execution("test-exec-001", "success", None, 42, 100, 50)
            .unwrap();

        // Verify updated state
        let record = log.get_by_execution_id("test-exec-001").unwrap();
        assert!(record.is_some());
        let rec = record.unwrap();
        assert_eq!(rec.outcome, "success");
        assert!(rec.finished_at.is_some());
        assert!(rec.duration_ms.is_some());
        assert_eq!(rec.files_indexed, 42);
        assert_eq!(rec.symbols_indexed, 100);
        assert_eq!(rec.references_indexed, 50);
    }

    #[test]
    fn test_execution_log_duplicate_id() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        log.ensure_schema().unwrap();

        // Start first execution
        log.start_execution("dup-exec", "0.1.0", &[], None, "/db")
            .unwrap();

        // Attempt to start second with same ID - should fail
        let result = log.start_execution("dup-exec", "0.1.0", &[], None, "/db");

        assert!(result.is_err(), "Duplicate execution_id should fail");
    }

    #[test]
    fn test_execution_outcome_values() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        log.ensure_schema().unwrap();

        // Test success outcome
        log.start_execution("exec-success", "0.1.0", &[], None, "/db")
            .unwrap();
        log.finish_execution("exec-success", "success", None, 1, 0, 0)
            .unwrap();

        let rec = log.get_by_execution_id("exec-success").unwrap().unwrap();
        assert_eq!(rec.outcome, "success");

        // Test error outcome
        log.start_execution("exec-error", "0.1.0", &[], None, "/db")
            .unwrap();
        log.finish_execution("exec-error", "error", Some("test error"), 0, 0, 0)
            .unwrap();

        let rec = log.get_by_execution_id("exec-error").unwrap().unwrap();
        assert_eq!(rec.outcome, "error");
        assert_eq!(rec.error_message, Some("test error".to_string()));

        // Test partial outcome
        log.start_execution("exec-partial", "0.1.0", &[], None, "/db")
            .unwrap();
        log.finish_execution("exec-partial", "partial", None, 5, 0, 0)
            .unwrap();

        let rec = log.get_by_execution_id("exec-partial").unwrap().unwrap();
        assert_eq!(rec.outcome, "partial");
    }

    #[test]
    fn test_list_all_executions() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        log.ensure_schema().unwrap();

        // Create multiple executions
        for i in 0..5 {
            let id = format!("exec-{:03}", i);
            log.start_execution(&id, "0.1.0", &[], None, "/db").unwrap();
            log.finish_execution(&id, "success", None, i, 0, 0).unwrap();
        }

        // List all
        let all = log.list_all(None).unwrap();
        assert_eq!(all.len(), 5);

        // List with limit
        let limited = log.list_all(Some(3)).unwrap();
        assert_eq!(limited.len(), 3);

        // Verify order (most recent first)
        // Due to timing, we just verify the IDs exist
        let ids: Vec<_> = all.iter().map(|r| r.execution_id.as_str()).collect();
        assert!(ids.contains(&"exec-000"));
        assert!(ids.contains(&"exec-004"));
    }

    #[test]
    fn test_duration_calculation() {
        let dir = tempdir().unwrap();
        let db_path = dir.path().join("test.db");
        let log = ExecutionLog::new(&db_path);

        log.ensure_schema().unwrap();

        log.start_execution("exec-duration", "0.1.0", &[], None, "/db")
            .unwrap();

        // Small delay to ensure positive duration
        std::thread::sleep(std::time::Duration::from_millis(50));

        log.finish_execution("exec-duration", "success", None, 0, 0, 0)
            .unwrap();

        let rec = log.get_by_execution_id("exec-duration").unwrap().unwrap();
        assert!(rec.duration_ms.is_some());
        let duration = rec.duration_ms.unwrap();
        assert!(
            duration >= 0,
            "Duration should be non-negative, got {}ms",
            duration
        );
        // Note: Duration can be 0 if execution finishes within the same millisecond as start
        // This is acceptable behavior - we just need to verify the duration field is populated
        assert!(
            duration < 30000,
            "Duration should be less than 30 seconds even under heavy load, got {}ms",
            duration
        );
    }
}