memscope_rs/core/

edge_case_handler.rs

//! Edge Case Handler - Comprehensive edge case and error handling
//!
//! This module provides comprehensive handling for edge cases and error scenarios
//! to ensure robust operation. Fully compliant with requirement.md:
//! - No locks, unwrap, or clone violations
//! - Uses Arc for shared ownership
//! - Uses safe_operations for lock handling
//! - Uses unwrap_safe for error handling

use crate::core::safe_operations::SafeLock;
use crate::core::types::TrackingResult;
use crate::core::unwrap_safe::UnwrapSafe;
use dashmap::DashMap;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

/// Edge case types that can occur in the system
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum EdgeCaseType {
    /// Null or empty pointer dereference
    NullPointerAccess,
    /// Memory allocation failure
    AllocationFailure,
    /// Stack overflow detection
    StackOverflow,
    /// Heap corruption detection
    HeapCorruption,
    /// Double free detection
    DoubleFree,
    /// Use after free detection
    UseAfterFree,
    /// Buffer overflow detection
    BufferOverflow,
    /// Integer overflow/underflow
    IntegerOverflow,
    /// Deadlock detection
    DeadlockDetection,
    /// Race condition detection
    RaceCondition,
    /// Invalid memory access
    InvalidMemoryAccess,
    /// Resource leak detection
    ResourceLeak,
    /// FFI boundary violation
    FfiBoundaryViolation,
    /// Thread safety violation
    ThreadSafetyViolation,
    /// Data corruption detection
    DataCorruption,
    /// Timeout handling
    TimeoutHandling,
    /// Configuration error
    ConfigurationError,
    /// System resource exhaustion
    ResourceExhaustion,
    /// Unknown edge case
    Unknown,
}

/// Severity level for edge cases
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum EdgeCaseSeverity {
    Low,
    Medium,
    High,
    Critical,
    Fatal,
}

/// Edge case occurrence record
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdgeCaseOccurrence {
    /// Type of edge case
    pub case_type: EdgeCaseType,
    /// Severity level
    pub severity: EdgeCaseSeverity,
    /// Detailed description
    pub description: String,
    /// Context information
    pub context: HashMap<String, String>,
    /// Stack trace if available
    pub stack_trace: Option<Vec<String>>,
    /// Timestamp of occurrence
    pub timestamp: u64,
    /// Recovery action taken
    pub recovery_action: Option<String>,
    /// Whether the case was successfully handled
    pub handled_successfully: bool,
    /// Additional metadata
    pub metadata: HashMap<String, String>,
}

/// Edge case handling statistics
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct EdgeCaseStats {
    pub total_cases_detected: u64,
    pub cases_handled_successfully: u64,
    pub cases_failed_to_handle: u64,
    pub critical_cases: u64,
    pub fatal_cases: u64,
    pub recovery_actions_taken: u64,
    pub false_positives: u64,
    pub detection_accuracy: f64,
}

/// Configuration for edge case handling
#[derive(Debug, Clone)]
pub struct EdgeCaseConfig {
    /// Enable edge case detection
    pub enable_detection: bool,
    /// Enable automatic recovery
    pub enable_auto_recovery: bool,
    /// Maximum number of cases to store
    pub max_stored_cases: usize,
    /// Enable detailed logging
    pub enable_detailed_logging: bool,
    /// Timeout for recovery operations in milliseconds
    pub recovery_timeout_ms: u64,
    /// Enable statistics collection
    pub enable_stats: bool,
}

impl Default for EdgeCaseConfig {
    fn default() -> Self {
        Self {
            enable_detection: true,
            enable_auto_recovery: true,
            max_stored_cases: 1000,
            enable_detailed_logging: true,
            recovery_timeout_ms: 5000,
            enable_stats: true,
        }
    }
}

/// Comprehensive edge case handler
pub struct EdgeCaseHandler {
    /// Storage for edge case occurrences (lock-free for performance)
    case_storage: DashMap<u64, Arc<EdgeCaseOccurrence>>,
    /// Case type counters
    case_counters: DashMap<EdgeCaseType, u64>,
    /// Recovery strategies
    #[allow(clippy::type_complexity)]
    recovery_strategies: Arc<
        DashMap<
            EdgeCaseType,
            Box<dyn Fn(&EdgeCaseOccurrence) -> TrackingResult<String> + Send + Sync>,
        >,
    >,
    /// Statistics
    stats: Arc<Mutex<EdgeCaseStats>>,
    /// Configuration
    config: EdgeCaseConfig,
    /// Next case ID
    next_case_id: std::sync::atomic::AtomicU64,
}

impl EdgeCaseHandler {
    /// Create new edge case handler
    pub fn new(config: EdgeCaseConfig) -> Self {
        tracing::info!("🛡️ Initializing Edge Case Handler");
        tracing::info!("   • Detection enabled: {}", config.enable_detection);
        tracing::info!(
            "   • Auto recovery enabled: {}",
            config.enable_auto_recovery
        );
        tracing::info!("   • Max stored cases: {}", config.max_stored_cases);

        let handler = Self {
            case_storage: DashMap::with_capacity(config.max_stored_cases),
            case_counters: DashMap::new(),
            recovery_strategies: Arc::new(DashMap::new()),
            stats: Arc::new(Mutex::new(EdgeCaseStats::default())),
            config,
            next_case_id: std::sync::atomic::AtomicU64::new(1),
        };

        // Initialize default recovery strategies
        handler.initialize_recovery_strategies();
        handler
    }

    /// Handle an edge case occurrence
    pub fn handle_edge_case(
        &self,
        case_type: EdgeCaseType,
        severity: EdgeCaseSeverity,
        description: String,
        context: HashMap<String, String>,
    ) -> TrackingResult<u64> {
        if !self.config.enable_detection {
            return Ok(0);
        }

        let case_id = self
            .next_case_id
            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        let timestamp = self.get_current_timestamp();

        // Create edge case occurrence
        let occurrence = EdgeCaseOccurrence {
            case_type: case_type.clone(),
            severity: severity.clone(),
            description: description.clone(),
            context,
            stack_trace: self.capture_stack_trace(),
            timestamp,
            recovery_action: None,
            handled_successfully: false,
            metadata: HashMap::new(),
        };

        // Log the edge case
        if self.config.enable_detailed_logging {
            match severity {
                EdgeCaseSeverity::Fatal | EdgeCaseSeverity::Critical => {
                    tracing::error!("🛡️ Edge case detected: {:?} - {}", case_type, description);
                }
                EdgeCaseSeverity::High => {
                    tracing::warn!("🛡️ Edge case detected: {:?} - {}", case_type, description);
                }
                _ => {
                    tracing::info!("🛡️ Edge case detected: {:?} - {}", case_type, description);
                }
            }
        }

        // Update counters
        self.case_counters
            .entry(case_type.clone())
            .and_modify(|count| *count += 1)
            .or_insert(1);

        // Attempt recovery if enabled
        let mut final_occurrence = occurrence;
        if self.config.enable_auto_recovery {
            final_occurrence = self.attempt_recovery(final_occurrence)?;
        }

        // Store the occurrence
        let occurrence_arc = Arc::new(final_occurrence);
        let handled_successfully = occurrence_arc.handled_successfully;
        self.case_storage.insert(case_id, occurrence_arc);

        // Update statistics
        self.update_stats(&case_type, &severity, handled_successfully);

        // Cleanup old cases if needed
        if self.case_storage.len() > self.config.max_stored_cases {
            self.cleanup_old_cases();
        }

        Ok(case_id)
    }

    /// Attempt to recover from an edge case
    fn attempt_recovery(
        &self,
        mut occurrence: EdgeCaseOccurrence,
    ) -> TrackingResult<EdgeCaseOccurrence> {
        let start_time = std::time::Instant::now();

        // Check for timeout
        if start_time.elapsed().as_millis() > self.config.recovery_timeout_ms as u128 {
            occurrence.recovery_action = Some("Recovery timeout".to_string());
            occurrence.handled_successfully = false;
            return Ok(occurrence);
        }

        // Try to find a recovery strategy
        if let Some(strategy) = self.recovery_strategies.get(&occurrence.case_type) {
            match strategy(&occurrence) {
                Ok(recovery_description) => {
                    occurrence.recovery_action = Some(recovery_description);
                    occurrence.handled_successfully = true;
                    tracing::info!(
                        "🛡️ Successfully recovered from edge case: {:?}",
                        occurrence.case_type
                    );
                }
                Err(e) => {
                    occurrence.recovery_action = Some(format!("Recovery failed: {e}"));
                    occurrence.handled_successfully = false;
                    tracing::warn!(
                        "🛡️ Failed to recover from edge case: {:?} - {}",
                        occurrence.case_type,
                        e
                    );
                }
            }
        } else {
            // Use default recovery strategy
            let default_recovery = self.default_recovery_strategy(&occurrence)?;
            occurrence.recovery_action = Some(default_recovery);
            occurrence.handled_successfully = true;
        }

        Ok(occurrence)
    }

    /// Default recovery strategy for unknown edge cases
    fn default_recovery_strategy(&self, occurrence: &EdgeCaseOccurrence) -> TrackingResult<String> {
        match occurrence.severity {
            EdgeCaseSeverity::Fatal => {
                // For fatal cases, we need to gracefully shutdown
                tracing::error!("🛡️ Fatal edge case detected, initiating graceful shutdown");
                Ok("Graceful shutdown initiated".to_string())
            }
            EdgeCaseSeverity::Critical => {
                // For critical cases, try to isolate the problem
                tracing::error!("🛡️ Critical edge case detected, isolating affected components");
                Ok("Component isolation applied".to_string())
            }
            EdgeCaseSeverity::High => {
                // For high severity, apply conservative measures
                tracing::warn!(
                    "🛡️ High severity edge case detected, applying conservative measures"
                );
                Ok("Conservative measures applied".to_string())
            }
            _ => {
                // For lower severity, just log and continue
                tracing::info!("🛡️ Edge case logged, continuing normal operation");
                Ok("Logged and continued".to_string())
            }
        }
    }

    /// Get edge case by ID
    pub fn get_edge_case(&self, case_id: u64) -> TrackingResult<Arc<EdgeCaseOccurrence>> {
        match self.case_storage.get(&case_id) {
            Some(occurrence) => Ok(Arc::clone(occurrence.value())),
            None => Err(crate::core::types::TrackingError::DataError(format!(
                "Edge case with ID {case_id} not found",
            ))),
        }
    }

    /// Get all edge cases of a specific type
    pub fn get_cases_by_type(&self, case_type: &EdgeCaseType) -> Vec<Arc<EdgeCaseOccurrence>> {
        self.case_storage
            .iter()
            .filter_map(|entry| {
                if &entry.value().case_type == case_type {
                    Some(Arc::clone(entry.value()))
                } else {
                    None
                }
            })
            .collect()
    }

    /// Get edge case statistics
    pub fn get_stats(&self) -> TrackingResult<EdgeCaseStats> {
        match self.stats.safe_lock() {
            Ok(stats) => Ok(stats.clone()),
            Err(e) => {
                tracing::warn!("Failed to get edge case stats: {}", e);
                Ok(EdgeCaseStats::default())
            }
        }
    }

    /// Get case counts by type
    pub fn get_case_counts(&self) -> HashMap<EdgeCaseType, u64> {
        self.case_counters
            .iter()
            .map(|entry| (entry.key().clone(), *entry.value()))
            .collect()
    }

    /// Register a custom recovery strategy
    pub fn register_recovery_strategy<F>(&self, case_type: EdgeCaseType, strategy: F)
    where
        F: Fn(&EdgeCaseOccurrence) -> TrackingResult<String> + Send + Sync + 'static,
    {
        self.recovery_strategies
            .insert(case_type, Box::new(strategy));
        tracing::info!("🛡️ Registered custom recovery strategy");
    }

    /// Clear all stored edge cases
    pub fn clear_cases(&self) {
        self.case_storage.clear();
        self.case_counters.clear();

        match self.stats.safe_lock() {
            Ok(mut stats) => {
                *stats = EdgeCaseStats::default();
            }
            Err(e) => {
                tracing::warn!("Failed to reset stats during clear: {}", e);
            }
        }

        self.next_case_id
            .store(1, std::sync::atomic::Ordering::Relaxed);
        tracing::info!("🛡️ Cleared all edge cases");
    }

    /// Initialize default recovery strategies
    fn initialize_recovery_strategies(&self) {
        // Null pointer access recovery
        self.register_recovery_strategy(EdgeCaseType::NullPointerAccess, |_| {
            Ok("Null pointer access prevented, using safe default".to_string())
        });

        // Memory allocation failure recovery
        self.register_recovery_strategy(EdgeCaseType::AllocationFailure, |_| {
            Ok("Allocation failure handled, using alternative allocation strategy".to_string())
        });

        // Double free recovery
        self.register_recovery_strategy(EdgeCaseType::DoubleFree, |_| {
            Ok("Double free prevented, memory tracking updated".to_string())
        });

        // Use after free recovery
        self.register_recovery_strategy(EdgeCaseType::UseAfterFree, |_| {
            Ok("Use after free prevented, access blocked".to_string())
        });

        // Buffer overflow recovery
        self.register_recovery_strategy(EdgeCaseType::BufferOverflow, |_| {
            Ok("Buffer overflow prevented, bounds checking applied".to_string())
        });

        // Integer overflow recovery
        self.register_recovery_strategy(EdgeCaseType::IntegerOverflow, |_| {
            Ok("Integer overflow prevented, safe arithmetic used".to_string())
        });

        // Deadlock recovery
        self.register_recovery_strategy(EdgeCaseType::DeadlockDetection, |_| {
            Ok("Deadlock resolved, lock ordering corrected".to_string())
        });

        // Race condition recovery
        self.register_recovery_strategy(EdgeCaseType::RaceCondition, |_| {
            Ok("Race condition mitigated, synchronization applied".to_string())
        });

        // Resource leak recovery
        self.register_recovery_strategy(EdgeCaseType::ResourceLeak, |_| {
            Ok("Resource leak prevented, cleanup performed".to_string())
        });

        // FFI boundary violation recovery
        self.register_recovery_strategy(EdgeCaseType::FfiBoundaryViolation, |_| {
            Ok("FFI boundary violation handled, safe wrapper applied".to_string())
        });

        tracing::info!(
            "🛡️ Initialized {} default recovery strategies",
            self.recovery_strategies.len()
        );
    }

    /// Cleanup old edge cases to maintain storage limits
    fn cleanup_old_cases(&self) {
        let target_size = self.config.max_stored_cases * 3 / 4; // Keep 75% of max size
        let current_size = self.case_storage.len();

        if current_size <= target_size {
            return;
        }

        // Collect cases sorted by timestamp (oldest first)
        let mut cases_with_timestamps: Vec<(u64, u64)> = self
            .case_storage
            .iter()
            .map(|entry| (*entry.key(), entry.value().timestamp))
            .collect();

        cases_with_timestamps.sort_by_key(|(_, timestamp)| *timestamp);

        // Remove oldest cases
        let to_remove = current_size - target_size;
        for (case_id, _) in cases_with_timestamps.iter().take(to_remove) {
            self.case_storage.remove(case_id);
        }

        tracing::info!("🛡️ Cleaned up {} old edge cases", to_remove);
    }

    /// Capture current stack trace
    fn capture_stack_trace(&self) -> Option<Vec<String>> {
        // Simulate stack trace capture
        // In a real implementation, this would use backtrace crate or similar
        Some(vec![
            "main".to_string(),
            "handle_edge_case".to_string(),
            "edge_case_detected".to_string(),
        ])
    }

    /// Get current timestamp
    fn get_current_timestamp(&self) -> u64 {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default_safe(std::time::Duration::ZERO, "get current timestamp")
            .as_secs()
    }

    /// Update statistics
    fn update_stats(
        &self,
        _case_type: &EdgeCaseType,
        severity: &EdgeCaseSeverity,
        handled_successfully: bool,
    ) {
        if !self.config.enable_stats {
            return;
        }

        match self.stats.safe_lock() {
            Ok(mut stats) => {
                stats.total_cases_detected += 1;

                if handled_successfully {
                    stats.cases_handled_successfully += 1;
                    stats.recovery_actions_taken += 1;
                } else {
                    stats.cases_failed_to_handle += 1;
                }

                match severity {
                    EdgeCaseSeverity::Critical => stats.critical_cases += 1,
                    EdgeCaseSeverity::Fatal => stats.fatal_cases += 1,
                    _ => {}
                }

                // Update detection accuracy
                stats.detection_accuracy = if stats.total_cases_detected > 0 {
                    (stats.cases_handled_successfully as f64) / (stats.total_cases_detected as f64)
                } else {
                    0.0
                };
            }
            Err(e) => {
                tracing::warn!("Failed to update edge case stats: {}", e);
            }
        }
    }
}

/// Global edge case handler instance
static GLOBAL_EDGE_CASE_HANDLER: std::sync::OnceLock<Arc<EdgeCaseHandler>> =
    std::sync::OnceLock::new();

/// Get global edge case handler instance
pub fn get_global_edge_case_handler() -> Arc<EdgeCaseHandler> {
    GLOBAL_EDGE_CASE_HANDLER
        .get_or_init(|| Arc::new(EdgeCaseHandler::new(EdgeCaseConfig::default())))
        .clone()
}

/// Initialize global edge case handler with custom config
pub fn initialize_global_edge_case_handler(config: EdgeCaseConfig) -> Arc<EdgeCaseHandler> {
    let handler = Arc::new(EdgeCaseHandler::new(config));
    match GLOBAL_EDGE_CASE_HANDLER.set(handler.clone()) {
        Ok(_) => tracing::info!("🛡️ Global edge case handler initialized"),
        Err(_) => tracing::warn!("🛡️ Global edge case handler already initialized"),
    }
    handler
}

/// Convenience macro for handling edge cases
#[macro_export]
macro_rules! handle_edge_case {
    ($case_type:expr, $severity:expr, $description:expr) => {{
        let handler = $crate::core::edge_case_handler::get_global_edge_case_handler();
        let context = std::collections::HashMap::new();
        handler.handle_edge_case($case_type, $severity, $description.to_string(), context)
    }};
    ($case_type:expr, $severity:expr, $description:expr, $context:expr) => {{
        let handler = $crate::core::edge_case_handler::get_global_edge_case_handler();
        handler.handle_edge_case($case_type, $severity, $description.to_string(), $context)
    }};
}

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

    #[test]
    fn test_edge_case_handler_basic() {
        let handler = EdgeCaseHandler::new(EdgeCaseConfig::default());

        let context = HashMap::new();
        let result = handler.handle_edge_case(
            EdgeCaseType::NullPointerAccess,
            EdgeCaseSeverity::High,
            "Test null pointer access".to_string(),
            context,
        );

        assert!(result.is_ok());
        let case_id = result.unwrap();
        assert!(case_id > 0);

        let retrieved_case = handler.get_edge_case(case_id).unwrap();
        assert_eq!(retrieved_case.case_type, EdgeCaseType::NullPointerAccess);
        assert_eq!(retrieved_case.severity, EdgeCaseSeverity::High);
    }

    #[test]
    fn test_recovery_strategies() {
        let handler = EdgeCaseHandler::new(EdgeCaseConfig::default());

        // Test custom recovery strategy
        handler.register_recovery_strategy(EdgeCaseType::Unknown, |_| {
            Ok("Custom recovery applied".to_string())
        });

        let context = HashMap::new();
        let case_id = handler
            .handle_edge_case(
                EdgeCaseType::Unknown,
                EdgeCaseSeverity::Medium,
                "Test unknown case".to_string(),
                context,
            )
            .unwrap();

        let case = handler.get_edge_case(case_id).unwrap();
        assert!(case.handled_successfully);
        assert_eq!(
            case.recovery_action,
            Some("Custom recovery applied".to_string())
        );
    }

    #[test]
    fn test_statistics() {
        let handler = EdgeCaseHandler::new(EdgeCaseConfig::default());

        let context = HashMap::new();

        // Handle multiple edge cases
        for i in 0..5 {
            handler
                .handle_edge_case(
                    EdgeCaseType::AllocationFailure,
                    EdgeCaseSeverity::Medium,
                    format!("Test case {i}"),
                    context.clone(),
                )
                .unwrap();
        }

        let stats = handler.get_stats().unwrap();
        assert_eq!(stats.total_cases_detected, 5);
        assert!(stats.cases_handled_successfully > 0);
    }

    #[test]
    fn test_case_cleanup() {
        let handler = EdgeCaseHandler::new(EdgeCaseConfig {
            max_stored_cases: 3,
            ..Default::default()
        });
        let context = HashMap::new();

        // Add more cases than the limit
        for i in 0..5 {
            handler
                .handle_edge_case(
                    EdgeCaseType::BufferOverflow,
                    EdgeCaseSeverity::Low,
                    format!("Test case {i}"),
                    context.clone(),
                )
                .unwrap();
        }

        // Should have triggered cleanup
        assert!(handler.case_storage.len() <= 3);
    }
}