dx_forge/

auto_update.rs

//! Auto-Update System with Green Traffic Support
//!
//! Provides automatic updates for green traffic changes, version conflict detection,
//! update notifications, and rollback capability.

use anyhow::{anyhow, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use chrono::{DateTime, Utc};

use crate::version::{Version, ToolInfo, ToolRegistry};

/// Traffic level for updates (simplified version)
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum TrafficLevel {
    /// Green traffic - safe for auto-update
    Green,
    /// Yellow traffic - requires review
    Yellow,
    /// Red traffic - requires manual intervention
    Red,
}

/// Update status
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum UpdateStatus {
    /// Update available but not applied
    Available,
    /// Update is being downloaded
    Downloading,
    /// Update is being applied
    Applying,
    /// Update successfully applied
    Applied,
    /// Update failed
    Failed(String),
    /// Update requires manual intervention
    RequiresManual,
}

/// Update notification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateNotification {
    pub tool_name: String,
    pub current_version: Version,
    pub new_version: Version,
    pub traffic_level: TrafficLevel,
    pub status: UpdateStatus,
    pub timestamp: DateTime<Utc>,
    pub message: String,
}

/// Backup information for rollback
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Backup {
    pub id: String,
    pub tool_name: String,
    pub version: Version,
    pub created_at: DateTime<Utc>,
    pub backup_path: PathBuf,
}

/// Auto-update manager
pub struct AutoUpdateManager {
    registry: ToolRegistry,
    backups: HashMap<String, Vec<Backup>>,
    notifications: Vec<UpdateNotification>,
    auto_update_enabled: bool,
}

impl AutoUpdateManager {
    /// Create a new auto-update manager
    pub fn new(forge_dir: &Path) -> Result<Self> {
        let registry = ToolRegistry::new(forge_dir)?;
        
        Ok(Self {
            registry,
            backups: HashMap::new(),
            notifications: Vec::new(),
            auto_update_enabled: true,
        })
    }

    /// Enable or disable auto-updates
    pub fn set_auto_update(&mut self, enabled: bool) {
        self.auto_update_enabled = enabled;
    }

    /// Check for updates for a specific tool
    pub fn check_update(&self, tool_name: &str, latest_version: Version) -> Option<UpdateNotification> {
        if let Some(current_version) = self.registry.version(tool_name) {
            if &latest_version > current_version {
                return Some(UpdateNotification {
                    tool_name: tool_name.to_string(),
                    current_version: current_version.clone(),
                    new_version: latest_version.clone(),
                    traffic_level: self.determine_traffic_level(current_version, &latest_version),
                    status: UpdateStatus::Available,
                    timestamp: Utc::now(),
                    message: format!("Update available: {} -> {}", current_version, latest_version),
                });
            }
        }
        None
    }

    /// Determine traffic level for an update
    fn determine_traffic_level(&self, current: &Version, new: &Version) -> TrafficLevel {
        // Green: patch updates
        if current.major == new.major && current.minor == new.minor {
            return TrafficLevel::Green;
        }

        // Yellow: minor updates
        if current.major == new.major {
            return TrafficLevel::Yellow;
        }

        // Red: major updates
        TrafficLevel::Red
    }

    /// Apply update if it's a green traffic update
    pub fn process_update(&mut self, notification: &UpdateNotification) -> Result<()> {
        if !self.auto_update_enabled {
            return Ok(());
        }

        match notification.traffic_level {
            TrafficLevel::Green => {
                println!("🟢 Auto-applying green traffic update: {} {} -> {}",
                    notification.tool_name,
                    notification.current_version,
                    notification.new_version
                );
                self.apply_update(notification)?;
            },
            TrafficLevel::Yellow => {
                println!("🟡 Yellow traffic update available: {} {} -> {} (requires review)",
                    notification.tool_name,
                    notification.current_version,
                    notification.new_version
                );
                self.add_notification(notification.clone());
            },
            TrafficLevel::Red => {
                println!("🔴 Red traffic update available: {} {} -> {} (requires manual intervention)",
                    notification.tool_name,
                    notification.current_version,
                    notification.new_version
                );
                self.add_notification(notification.clone());
            },
        }

        Ok(())
    }

    /// Apply an update
    fn apply_update(&mut self, notification: &UpdateNotification) -> Result<()> {
        // Create backup before applying update
        self.create_backup(&notification.tool_name, &notification.current_version)?;

        // In a real implementation, this would download and install the update
        // For now, we'll just update the registry
        println!("  ✓ Created backup");
        println!("  ⬇ Downloading update...");
        println!("  ✓ Applying update...");

        // Update the registry (simulated)
        let _tool_info = ToolInfo {
            name: notification.tool_name.clone(),
            version: notification.new_version.clone(),
            installed_at: Utc::now(),
            source: crate::version::ToolSource::Crate {
                version: notification.new_version.to_string(),
            },
            dependencies: HashMap::new(),
        };

        // In reality, we'd update through the registry methods
        println!("  ✓ Update applied successfully");

        // Add success notification
        self.add_notification(UpdateNotification {
            status: UpdateStatus::Applied,
            timestamp: Utc::now(),
            message: format!("Successfully updated to {}", notification.new_version),
            ..notification.clone()
        });

        Ok(())
    }

    /// Create a backup for rollback
    fn create_backup(&mut self, tool_name: &str, version: &Version) -> Result<()> {
        let backup_id = uuid::Uuid::new_v4().to_string();
        let backup_path = PathBuf::from(format!(".dx/forge/backups/{}/{}", tool_name, backup_id));

        // In a real implementation, this would copy the tool files
        std::fs::create_dir_all(&backup_path)?;

        let backup = Backup {
            id: backup_id,
            tool_name: tool_name.to_string(),
            version: version.clone(),
            created_at: Utc::now(),
            backup_path,
        };

        self.backups
            .entry(tool_name.to_string())
            .or_insert_with(Vec::new)
            .push(backup);

        Ok(())
    }

    /// Rollback to a previous version
    pub fn rollback(&mut self, tool_name: &str) -> Result<()> {
        let backups = self.backups
            .get_mut(tool_name)
            .ok_or_else(|| anyhow!("No backups found for {}", tool_name))?;

        let backup = backups.pop()
            .ok_or_else(|| anyhow!("No backups available for {}", tool_name))?;

        println!("🔄 Rolling back {} to version {}", tool_name, backup.version);
        println!("  ✓ Restoring from backup: {}", backup.id);

        // In a real implementation, this would restore the files from backup
        // and update the registry
        println!("  ✓ Rollback complete");

        // Add notification
        self.add_notification(UpdateNotification {
            tool_name: tool_name.to_string(),
            current_version: backup.version.clone(),
            new_version: backup.version.clone(),
            traffic_level: TrafficLevel::Green,
            status: UpdateStatus::Applied,
            timestamp: Utc::now(),
            message: format!("Rolled back to version {}", backup.version),
        });

        Ok(())
    }

    /// Add a notification
    fn add_notification(&mut self, notification: UpdateNotification) {
        self.notifications.push(notification);

        // Keep only last 100 notifications
        if self.notifications.len() > 100 {
            self.notifications.remove(0);
        }
    }

    /// Get all notifications
    pub fn get_notifications(&self) -> &[UpdateNotification] {
        &self.notifications
    }

    /// Get pending updates
    pub fn get_pending_updates(&self) -> Vec<&UpdateNotification> {
        self.notifications
            .iter()
            .filter(|n| n.status == UpdateStatus::Available || n.status == UpdateStatus::RequiresManual)
            .collect()
    }

    /// Clear old notifications
    pub fn clear_old_notifications(&mut self, days: i64) {
        let cutoff = Utc::now() - chrono::Duration::days(days);
        self.notifications.retain(|n| n.timestamp > cutoff);
    }

    /// Detect version conflicts
    pub fn detect_conflicts(&self) -> Vec<String> {
        let mut conflicts = Vec::new();

        for tool_info in self.registry.list() {
            if let Ok(missing_deps) = self.registry.check_dependencies(&tool_info.name) {
                conflicts.extend(missing_deps);
            }
        }

        conflicts
    }

    /// Get backup history for a tool
    pub fn get_backups(&self, tool_name: &str) -> Vec<&Backup> {
        self.backups
            .get(tool_name)
            .map(|backups| backups.iter().collect())
            .unwrap_or_default()
    }

    /// Clean old backups
    pub fn clean_old_backups(&mut self, days: i64) -> Result<()> {
        let cutoff = Utc::now() - chrono::Duration::days(days);

        for backups in self.backups.values_mut() {
            backups.retain(|backup| {
                if backup.created_at < cutoff {
                    // Delete backup directory
                    let _  = std::fs::remove_dir_all(&backup.backup_path);
                    false
                } else {
                    true
                }
            });
        }

        Ok(())
    }
}

/// Update preference for notifications
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdatePreference {
    pub auto_update_green: bool,
    pub notify_yellow: bool,
    pub notify_red: bool,
    pub email_notifications: bool,
}

impl Default for UpdatePreference {
    fn default() -> Self {
        Self {
            auto_update_green: true,
            notify_yellow: true,
            notify_red: true,
            email_notifications: false,
        }
    }
}

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

    #[test]
    fn test_determine_traffic_level() {
        let manager = AutoUpdateManager {
            registry: ToolRegistry::new(Path::new(".dx/forge")).unwrap(),
            backups: HashMap::new(),
            notifications: Vec::new(),
            auto_update_enabled: true,
        };

        // Patch update (green)
        let current = Version::new(1, 2, 3);
        let new = Version::new(1, 2, 4);
        assert_eq!(manager.determine_traffic_level(&current, &new), TrafficLevel::Green);

        // Minor update (yellow)
        let new = Version::new(1, 3, 0);
        assert_eq!(manager.determine_traffic_level(&current, &new), TrafficLevel::Yellow);

        // Major update (red)
        let new = Version::new(2, 0, 0);
        assert_eq!(manager.determine_traffic_level(&current, &new), TrafficLevel::Red);
    }
}