xbp 0.3.5

//! Comprehensive logging system for XBP
//!
//! This module provides structured logging to /var/log/xbp/ with automatic
//! log rotation, different log levels, and command-specific log files.

use chrono::{DateTime, Local};
use serde::{Deserialize, Serialize};
use std::fs::{self, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};


/// Log levels for different types of operations
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogLevel {
    Info,
    Warning,
    Error,
    Debug,
    Success,
}

impl LogLevel {
    fn to_string(&self) -> &'static str {
        match self {
            LogLevel::Info => "INFO",
            LogLevel::Warning => "WARN",
            LogLevel::Error => "ERROR",
            LogLevel::Debug => "DEBUG",
            LogLevel::Success => "SUCCESS",
        }
    }

    fn color_code(&self) -> &'static str {
        match self {
            LogLevel::Info => "\x1b[94m",      // Blue
            LogLevel::Warning => "\x1b[93m",   // Yellow
            LogLevel::Error => "\x1b[91m",     // Red
            LogLevel::Debug => "\x1b[90m",     // Gray
            LogLevel::Success => "\x1b[92m",   // Green
        }
    }
}

/// Structured log entry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogEntry {
    pub timestamp: DateTime<Local>,
    pub level: LogLevel,
    pub command: String,
    pub message: String,
    pub details: Option<String>,
    pub duration_ms: Option<u64>,
}

/// Logger instance for XBP operations
pub struct XbpLogger {
    log_dir: PathBuf,
    debug_enabled: bool,
}

impl XbpLogger {
    /// Create a new XBP logger instance
    pub async fn new(debug: bool) -> Result<Self, String> {
        let log_dir = PathBuf::from("/var/log/xbp");
        
        // Create log directory with proper permissions
        Self::ensure_log_directory(&log_dir).await?;
        
        let logger = XbpLogger {
            log_dir,
            debug_enabled: debug,
        };

        // Log the logger initialization directly to avoid recursion
        logger.write_log(LogLevel::Info, "system", "XBP Logger initialized", None, None).await?;
        
        Ok(logger)
    }

    /// Ensure the log directory exists with proper permissions
    async fn ensure_log_directory(log_dir: &Path) -> Result<(), String> {
        if !log_dir.exists() {
            // Try to create the directory
            if let Err(e) = fs::create_dir_all(log_dir) {
                // If we can't create in /var/log/xbp, fall back to user directory
                let fallback_dir = dirs::home_dir()
                    .unwrap_or_else(|| PathBuf::from("."))
                    .join(".xbp")
                    .join("logs");
                
                fs::create_dir_all(&fallback_dir)
                    .map_err(|e| format!("Failed to create log directory: {}", e))?;
                
                println!("\x1b[93mWarning: Could not create /var/log/xbp ({}), using {}\x1b[0m", 
                         e, fallback_dir.display());
                return Ok(());
            }
        }

        // Set proper permissions (readable/writable by owner, readable by group)
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            let permissions = std::fs::Permissions::from_mode(0o755);
            fs::set_permissions(log_dir, permissions)
                .map_err(|e| format!("Failed to set log directory permissions: {}", e))?;
        }

        Ok(())
    }

    /// Log an info message
    pub async fn log_info(&self, command: &str, message: &str, details: Option<&str>) -> Result<(), String> {
        self.write_log(LogLevel::Info, command, message, details, None).await
    }

    /// Log a warning message
    pub async fn log_warning(&self, command: &str, message: &str, details: Option<&str>) -> Result<(), String> {
        self.write_log(LogLevel::Warning, command, message, details, None).await
    }

    /// Log an error message
    pub async fn log_error(&self, command: &str, message: &str, details: Option<&str>) -> Result<(), String> {
        self.write_log(LogLevel::Error, command, message, details, None).await
    }

    /// Log a success message
    pub async fn log_success(&self, command: &str, message: &str, details: Option<&str>) -> Result<(), String> {
        self.write_log(LogLevel::Success, command, message, details, None).await
    }

    /// Log a debug message (only if debug is enabled)
    pub async fn log_debug(&self, command: &str, message: &str, details: Option<&str>) -> Result<(), String> {
        if self.debug_enabled {
            self.write_log(LogLevel::Debug, command, message, details, None).await
        } else {
            Ok(())
        }
    }

    /// Log a timed operation
    pub async fn log_timed(&self, level: LogLevel, command: &str, message: &str, duration_ms: u64) -> Result<(), String> {
        self.write_log(level, command, message, None, Some(duration_ms)).await
    }

    /// Write log entry to both console and file
    async fn write_log(
        &self,
        level: LogLevel,
        command: &str,
        message: &str,
        details: Option<&str>,
        duration_ms: Option<u64>,
    ) -> Result<(), String> {
        let entry = LogEntry {
            timestamp: Local::now(),
            level: level.clone(),
            command: command.to_string(),
            message: message.to_string(),
            details: details.map(|s| s.to_string()),
            duration_ms,
        };

        // Write to console
        self.write_console(&entry);

        // Write to file
        self.write_file(&entry).await?;

        Ok(())
    }

    /// Write log entry to console with colors
    fn write_console(&self, entry: &LogEntry) {
        let color = entry.level.color_code();
        let reset = "\x1b[0m";
        let timestamp = entry.timestamp.format("%H:%M:%S");
        
        let duration_str = if let Some(duration) = entry.duration_ms {
            format!(" ({:.2}ms)", duration)
        } else {
            String::new()
        };

        println!("{}[{}] [{}] {}: {}{}{}", 
                 color, 
                 timestamp, 
                 entry.level.to_string(), 
                 entry.command, 
                 entry.message,
                 duration_str,
                 reset);

        if let Some(details) = &entry.details {
            println!("  {}{}{}", color, details, reset);
        }
    }

    /// Write log entry to file
    async fn write_file(&self, entry: &LogEntry) -> Result<(), String> {
        // Create log file paths
        let date_str = entry.timestamp.format("%Y-%m-%d");
        let general_log = self.log_dir.join(format!("xbp-{}.log", date_str));
        let command_log = self.log_dir.join(format!("{}-{}.log", entry.command, date_str));

        // Prepare log line
        let duration_str = if let Some(duration) = entry.duration_ms {
            format!(" duration={}ms", duration)
        } else {
            String::new()
        };

        let details_str = if let Some(details) = &entry.details {
            format!(" details=\"{}\"", details.replace('"', "'"))
        } else {
            String::new()
        };

        let log_line = format!(
            "{} level={} command={} message=\"{}\"{}{}\n",
            entry.timestamp.format("%Y-%m-%d %H:%M:%S%.3f"),
            entry.level.to_string(),
            entry.command,
            entry.message.replace('"', "'"),
            details_str,
            duration_str
        );

        // Write to general log
        self.append_to_file(&general_log, &log_line).await?;

        // Write to command-specific log
        self.append_to_file(&command_log, &log_line).await?;

        // Rotate logs if necessary
        self.rotate_logs_if_needed(&general_log).await?;
        self.rotate_logs_if_needed(&command_log).await?;

        Ok(())
    }

    /// Append content to a log file
    async fn append_to_file(&self, file_path: &Path, content: &str) -> Result<(), String> {
        let mut file = OpenOptions::new()
            .create(true)
            .append(true)
            .open(file_path)
            .map_err(|e| format!("Failed to open log file {}: {}", file_path.display(), e))?;

        file.write_all(content.as_bytes())
            .map_err(|e| format!("Failed to write to log file: {}", e))?;

        Ok(())
    }

    /// Rotate logs if they exceed size limit (10MB)
    async fn rotate_logs_if_needed(&self, file_path: &Path) -> Result<(), String> {
        if let Ok(metadata) = fs::metadata(file_path) {
            const MAX_SIZE: u64 = 10 * 1024 * 1024; // 10MB
            
            if metadata.len() > MAX_SIZE {
                let rotated_path = file_path.with_extension(
                    format!("log.{}", Local::now().format("%H%M%S"))
                );
                
                fs::rename(file_path, &rotated_path)
                    .map_err(|e| format!("Failed to rotate log file: {}", e))?;
                
                // Log rotation directly to avoid recursion
                let entry = LogEntry {
                    timestamp: Local::now(),
                    level: LogLevel::Info,
                    command: "system".to_string(),
                    message: format!("Rotated log file to {}", rotated_path.display()),
                    details: None,
                    duration_ms: None,
                };
                self.write_console(&entry);
            }
        }
        
        Ok(())
    }

    /// Log command execution with timing
    pub async fn log_command_execution(
        &self,
        command: &str,
        cmd_args: &[&str],
        start_time: std::time::Instant,
    ) -> Result<(), String> {
        let duration = start_time.elapsed();
        let duration_ms = duration.as_millis() as u64;
        
        let full_command = format!("{} {}", command, cmd_args.join(" "));
        
        self.log_timed(
            LogLevel::Info,
            "command",
            &format!("Executed: {}", full_command),
            duration_ms,
        ).await
    }

    /// Log process output
    pub async fn log_process_output(
        &self,
        command: &str,
        process_name: &str,
        stdout: &str,
        stderr: &str,
    ) -> Result<(), String> {
        if !stdout.is_empty() {
            self.log_info(command, 
                         &format!("{} stdout", process_name), 
                         Some(stdout)).await?;
        }
        
        if !stderr.is_empty() {
            self.log_warning(command, 
                            &format!("{} stderr", process_name), 
                            Some(stderr)).await?;
        }
        
        Ok(())
    }

    /// Get log directory path
    pub fn log_dir(&self) -> &Path {
        &self.log_dir
    }

    /// List available log files
    pub async fn list_log_files(&self) -> Result<Vec<PathBuf>, String> {
        let mut files = Vec::new();
        
        let entries = fs::read_dir(&self.log_dir)
            .map_err(|e| format!("Failed to read log directory: {}", e))?;
        
        for entry in entries {
            let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
            let path = entry.path();
            
            if path.is_file() && path.extension().map_or(false, |ext| ext == "log") {
                files.push(path);
            }
        }
        
        files.sort();
        Ok(files)
    }

    /// Read recent log entries from a specific log file
    pub async fn read_recent_logs(&self, file_path: &Path, lines: usize) -> Result<Vec<String>, String> {
        let content = fs::read_to_string(file_path)
            .map_err(|e| format!("Failed to read log file: {}", e))?;
        
        let all_lines: Vec<&str> = content.lines().collect();
        let recent_lines = if all_lines.len() > lines {
            &all_lines[all_lines.len() - lines..]
        } else {
            &all_lines
        };
        
        Ok(recent_lines.iter().map(|s| s.to_string()).collect())
    }
}

/// Global logger instance
static mut LOGGER: Option<XbpLogger> = None;

/// Initialize the global logger
pub async fn init_logger(debug: bool) -> Result<(), String> {
    let logger = XbpLogger::new(debug).await?;
    
    unsafe {
        LOGGER = Some(logger);
    }
    
    Ok(())
}

/// Get the global logger instance
pub fn get_logger() -> Option<&'static XbpLogger> {
    unsafe { LOGGER.as_ref() }
}

/// Convenience macro for logging
#[macro_export]
macro_rules! xbp_log {
    (info, $command:expr, $message:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_info($command, $message, None).await;
        }
    };
    (info, $command:expr, $message:expr, $details:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_info($command, $message, Some($details)).await;
        }
    };
    (warning, $command:expr, $message:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_warning($command, $message, None).await;
        }
    };
    (error, $command:expr, $message:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_error($command, $message, None).await;
        }
    };
    (success, $command:expr, $message:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_success($command, $message, None).await;
        }
    };
    (debug, $command:expr, $message:expr) => {
        if let Some(logger) = crate::logging::get_logger() {
            let _ = logger.log_debug($command, $message, None).await;
        }
    };
}