smart-tree 8.0.0

//! Integration of MEM8 with Smart Tree
//! Provides cognitive memory capabilities for directory analysis

use anyhow::Result;
use std::path::Path;
use std::sync::{Arc, RwLock};

use crate::mem8::{
    consciousness::ConsciousnessEngine,
    format::{CompressedWave, M8Writer},
    reactive::{ReactiveLayer, ReactiveMemory, ReactivePattern, ReactiveResponse, SensorInput},
    wave::{FrequencyBand, MemoryWave, WaveGrid},
};

/// MEM8 integration for Smart Tree
pub struct SmartTreeMem8 {
    /// Wave grid for storing directory memories
    wave_grid: Arc<RwLock<WaveGrid>>,
    /// Reactive memory system
    reactive_memory: Arc<RwLock<ReactiveMemory>>,
    /// Consciousness engine
    consciousness: Arc<ConsciousnessEngine>,
    /// Current directory depth for z-axis mapping
    current_depth: u16,
}

impl Default for SmartTreeMem8 {
    fn default() -> Self {
        Self::new()
    }
}

impl SmartTreeMem8 {
    /// Create a new MEM8 instance for Smart Tree
    pub fn new() -> Self {
        #[cfg(not(test))]
        let wave_grid = Arc::new(RwLock::new(WaveGrid::new()));

        #[cfg(test)]
        let wave_grid = Arc::new(RwLock::new(WaveGrid::new_test()));

        let reactive_memory = Arc::new(RwLock::new(ReactiveMemory::new(wave_grid.clone())));
        let consciousness = Arc::new(ConsciousnessEngine::new(wave_grid.clone()));

        Self {
            wave_grid,
            reactive_memory,
            consciousness,
            current_depth: 0,
        }
    }

    /// Store a directory entry as a wave memory
    pub fn store_directory_memory(
        &mut self,
        path: &Path,
        metadata: DirectoryMetadata,
    ) -> Result<()> {
        // Map directory path to spatial coordinates
        let (x, y) = self.path_to_coordinates(path);

        // Create memory wave based on directory characteristics
        let wave = self.create_directory_wave(&metadata);

        // Store in grid
        self.wave_grid
            .write()
            .unwrap()
            .store(x, y, self.current_depth, wave);

        // Update depth for next entry
        self.current_depth = if self.current_depth == 65535 {
            0
        } else {
            self.current_depth + 1
        };

        Ok(())
    }

    /// Convert directory path to grid coordinates
    fn path_to_coordinates(&self, path: &Path) -> (u8, u8) {
        // Hash path components to distribute across grid
        let path_str = path.to_string_lossy();
        let hash = self.simple_hash(&path_str);

        let x = (hash & 0xFF) as u8;
        let y = ((hash >> 8) & 0xFF) as u8;

        (x, y)
    }

    /// Simple hash function for path distribution
    pub fn simple_hash(&self, s: &str) -> u64 {
        let mut hash = 5381u64;
        for byte in s.bytes() {
            hash = ((hash << 5).wrapping_add(hash)).wrapping_add(byte as u64);
        }
        hash
    }

    /// Create a wave from directory metadata
    fn create_directory_wave(&self, metadata: &DirectoryMetadata) -> MemoryWave {
        // Determine frequency based on content type
        let frequency = match metadata.primary_type {
            ContentType::Code => FrequencyBand::Technical.frequency(0.5),
            ContentType::Documentation => FrequencyBand::Conversational.frequency(0.5),
            ContentType::Configuration => FrequencyBand::DeepStructural.frequency(0.5),
            ContentType::Data => FrequencyBand::Implementation.frequency(0.5),
            ContentType::Media => FrequencyBand::Abstract.frequency(0.5),
        };

        // Amplitude based on importance/size
        let amplitude =
            (metadata.importance * 0.7 + metadata.normalized_size * 0.3).clamp(0.1, 1.0);

        let mut wave = MemoryWave::new(frequency, amplitude);

        // Set emotional context based on directory health
        wave.valence = match metadata.health {
            DirectoryHealth::Healthy => 0.5,
            DirectoryHealth::Warning => -0.2,
            DirectoryHealth::Critical => -0.8,
        };

        // Arousal based on activity level
        wave.arousal = metadata.activity_level;

        // Decay based on last modified time
        if metadata.days_since_modified > 365 {
            wave.decay_tau = Some(std::time::Duration::from_secs(86400)); // 1 day
        } else if metadata.days_since_modified > 30 {
            wave.decay_tau = Some(std::time::Duration::from_secs(604800)); // 1 week
        } else {
            wave.decay_tau = None; // No decay for recent files
        }

        wave
    }

    /// Query memories about a specific path pattern
    pub fn query_path_memories(&self, pattern: &str) -> Vec<PathMemory> {
        let grid = self.wave_grid.read().unwrap();
        let mut memories = Vec::new();

        // Sample grid looking for relevant memories
        for x in 0..=255u8 {
            for y in 0..=255u8 {
                // Check recent layers (last 1000)
                for z in (self.current_depth.saturating_sub(1000)..self.current_depth).step_by(10) {
                    if let Some(wave) = grid.get(x, y, z) {
                        if wave.calculate_decay() > 0.1 {
                            // This is an active memory
                            memories.push(PathMemory {
                                coordinates: (x, y, z),
                                wave: wave.clone(),
                                relevance: self.calculate_relevance(wave, pattern),
                            });
                        }
                    }
                }
            }
        }

        // Sort by relevance
        memories.sort_by(|a, b| b.relevance.partial_cmp(&a.relevance).unwrap());
        memories.truncate(20); // Top 20 results

        memories
    }

    /// Calculate relevance score for a memory
    fn calculate_relevance(&self, wave: &MemoryWave, pattern: &str) -> f32 {
        // Simple relevance based on frequency band matching
        let pattern_freq = if pattern.contains("src") || pattern.contains("lib") {
            FrequencyBand::Technical.frequency(0.5)
        } else if pattern.contains("doc") || pattern.contains("README") {
            FrequencyBand::Conversational.frequency(0.5)
        } else if pattern.contains("config") || pattern.contains("toml") {
            FrequencyBand::DeepStructural.frequency(0.5)
        } else {
            FrequencyBand::Implementation.frequency(0.5)
        };

        // Frequency similarity
        let freq_diff = (wave.frequency - pattern_freq).abs() / 1000.0;
        let freq_score = 1.0 - freq_diff.clamp(0.0, 1.0);

        // Combine with amplitude and decay
        freq_score * wave.amplitude * wave.calculate_decay()
    }

    /// Register reactive patterns for directory events
    pub fn register_directory_patterns(&mut self) {
        // Pattern for large directories
        let large_dir_pattern = ReactivePattern {
            id: "large_directory".to_string(),
            threshold: 0.7,
            weight: 1.0,
            response: Arc::new(|| ReactiveResponse {
                layer: ReactiveLayer::SubcorticalReaction,
                strength: 0.8,
                action: "Enable streaming mode for large directory".to_string(),
                latency: std::time::Duration::from_millis(30),
            }),
        };

        // Pattern for security threats
        let security_pattern = ReactivePattern {
            id: "security_threat".to_string(),
            threshold: 0.5,
            weight: 1.5,
            response: Arc::new(|| ReactiveResponse {
                layer: ReactiveLayer::HardwareReflex,
                strength: 0.95,
                action: "Block access to suspicious directory".to_string(),
                latency: std::time::Duration::from_millis(5),
            }),
        };

        // Register patterns
        let mut reactive = self.reactive_memory.write().unwrap();
        reactive.register_pattern(ReactiveLayer::SubcorticalReaction, large_dir_pattern);
        reactive.register_pattern(ReactiveLayer::HardwareReflex, security_pattern);
    }

    /// Process directory scan event through reactive system
    pub fn process_directory_event(&self, event: DirectoryEvent) -> Option<ReactiveResponse> {
        let input = match event {
            DirectoryEvent::LargeDirectory { size, .. } => SensorInput::Visual {
                intensity: (size as f32 / 1_000_000.0).clamp(0.0, 1.0),
                motion: 0.0,
                looming: size > 10_000_000,
            },
            DirectoryEvent::SecurityThreat { severity, .. } => SensorInput::Threat {
                severity,
                proximity: 1.0,
                pattern: "malicious_file".to_string(),
            },
            DirectoryEvent::RapidChange { rate, .. } => SensorInput::Visual {
                intensity: 0.5,
                motion: rate,
                looming: false,
            },
        };

        self.reactive_memory.read().unwrap().process(&input)
    }

    /// Update consciousness state
    pub fn update_consciousness(&self) {
        self.consciousness.update();
    }

    /// Export memories to .m8 format
    pub fn export_memories<W: std::io::Write>(&self, writer: W) -> Result<()> {
        let mut m8_writer = M8Writer::new(writer);
        let grid = self.wave_grid.read().unwrap();

        // Collect all active memories
        let mut compressed_waves = Vec::new();
        let mut id = 0;

        for x in 0..=255u8 {
            for y in 0..=255u8 {
                for z in 0..100u16 {
                    // Sample first 100 layers
                    if let Some(wave) = grid.get(x, y, z) {
                        if wave.calculate_decay() > 0.01 {
                            compressed_waves.push(CompressedWave::from_wave(wave, id));
                            id += 1;
                        }
                    }
                }
            }
        }

        m8_writer.add_wave_memory(&compressed_waves)?;
        m8_writer.finish()?;

        Ok(())
    }

    /// Get count of active memories
    pub fn active_memory_count(&self) -> usize {
        self.wave_grid.read().unwrap().active_memory_count()
    }

    /// Store wave at specific coordinates (public helper method)
    pub fn store_wave_at_coordinates(
        &mut self,
        x: u8,
        y: u8,
        z: u16,
        wave: MemoryWave,
    ) -> Result<()> {
        self.wave_grid.write().unwrap().store(x, y, z, wave);
        Ok(())
    }

    /// Helper to convert string to coordinates
    pub fn string_to_coordinates(&self, s: &str) -> (u8, u8) {
        let hash = self.simple_hash(s);
        ((hash & 0xFF) as u8, ((hash >> 8) & 0xFF) as u8)
    }
}

/// Directory metadata for memory creation
#[derive(Debug)]
pub struct DirectoryMetadata {
    pub primary_type: ContentType,
    pub importance: f32,      // 0.0 to 1.0
    pub normalized_size: f32, // 0.0 to 1.0
    pub health: DirectoryHealth,
    pub activity_level: f32, // 0.0 to 1.0
    pub days_since_modified: u32,
}

#[derive(Debug)]
pub enum ContentType {
    Code,
    Documentation,
    Configuration,
    Data,
    Media,
}

#[derive(Debug)]
pub enum DirectoryHealth {
    Healthy,
    Warning,
    Critical,
}

/// A memory associated with a path
#[derive(Debug)]
pub struct PathMemory {
    pub coordinates: (u8, u8, u16),
    pub wave: Arc<MemoryWave>,
    pub relevance: f32,
}

/// Directory events for reactive processing
#[derive(Debug)]
pub enum DirectoryEvent {
    LargeDirectory { path: String, size: u64 },
    SecurityThreat { path: String, severity: f32 },
    RapidChange { path: String, rate: f32 },
}

/// Example usage in Smart Tree
pub fn integrate_with_smart_tree() -> Result<()> {
    let mut mem8 = SmartTreeMem8::new();

    // Register reactive patterns
    mem8.register_directory_patterns();

    // Store a directory memory
    let metadata = DirectoryMetadata {
        primary_type: ContentType::Code,
        importance: 0.8,
        normalized_size: 0.6,
        health: DirectoryHealth::Healthy,
        activity_level: 0.7,
        days_since_modified: 5,
    };

    mem8.store_directory_memory(Path::new("src/lib.rs"), metadata)?;

    // Query memories
    let memories = mem8.query_path_memories("src");
    println!("Found {} memories related to 'src'", memories.len());

    // Process an event
    let event = DirectoryEvent::LargeDirectory {
        path: "node_modules".to_string(),
        size: 50_000_000,
    };

    if let Some(response) = mem8.process_directory_event(event) {
        println!(
            "Reactive response: {} ({}ms)",
            response.action,
            response.latency.as_millis()
        );
    }

    // Update consciousness
    mem8.update_consciousness();

    // Export to .m8 file
    let mut buffer = Vec::new();
    mem8.export_memories(&mut buffer)?;
    println!("Exported {} bytes of memories", buffer.len());

    Ok(())
}

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

    #[test]
    #[ignore = "Consciousness update or memory export may hang"]
    fn test_smart_tree_integration() {
        // Skip in CI as consciousness update or memory export may hang
        if std::env::var("CI").is_ok() || std::env::var("GITHUB_ACTIONS").is_ok() {
            println!("Skipping smart tree integration test in CI environment");
            return;
        }
        integrate_with_smart_tree().unwrap();
    }

    #[test]
    fn test_path_to_coordinates() {
        let mem8 = SmartTreeMem8::new();
        let (x1, y1) = mem8.path_to_coordinates(Path::new("src/main.rs"));
        let (x2, y2) = mem8.path_to_coordinates(Path::new("src/lib.rs"));

        // Different paths should map to different coordinates (usually)
        assert!(x1 != x2 || y1 != y2);
    }
}