config_lib/

enterprise.rs

use crate::{Error, Result, Value};
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, RwLock};
use std::path::Path;

/// Enterprise-grade configuration manager with caching and access control
#[derive(Debug)]
pub struct EnterpriseConfig {
    /// In-memory cache for ultra-fast access
    cache: Arc<RwLock<BTreeMap<String, Value>>>,
    /// Default values for missing keys
    defaults: Arc<RwLock<BTreeMap<String, Value>>>,
    /// Original file path for save operations
    file_path: Option<String>,
    /// Format type for serialization
    format: String,
    /// Access control flag
    read_only: bool,
}

/// Configuration manager for multiple instances
#[derive(Debug, Default)]
pub struct ConfigManager {
    /// Named configuration instances
    configs: Arc<RwLock<HashMap<String, EnterpriseConfig>>>,
}

impl EnterpriseConfig {
    /// Create new config with defaults
    #[inline(always)]
    pub fn new() -> Self {
        Self {
            cache: Arc::new(RwLock::new(BTreeMap::new())),
            defaults: Arc::new(RwLock::new(BTreeMap::new())),
            file_path: None,
            format: "conf".to_string(),
            read_only: false,
        }
    }
    
    /// Load configuration from file with caching
    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
        let path_str = path.as_ref().to_string_lossy().to_string();
        let content = std::fs::read_to_string(&path)?;
        
        // Detect format from extension
        let format = Self::detect_format(&path_str);
        let value = Self::parse_content(&content, &format)?;
        
        let mut config = Self::new();
        config.file_path = Some(path_str);
        config.format = format;
        
        // Cache the parsed data
        if let Value::Table(table) = value {
            *config.cache.write().unwrap() = table;
        }
        
        Ok(config)
    }
    
    /// Load configuration from string with caching
    pub fn from_string(content: &str, format: Option<&str>) -> Result<Self> {
        let format = format.unwrap_or("conf").to_string();
        let value = Self::parse_content(content, &format)?;
        
        let mut config = Self::new();
        config.format = format;
        
        // Cache the parsed data
        if let Value::Table(table) = value {
            *config.cache.write().unwrap() = table;
        }
        
        Ok(config)
    }
    
    /// Get value with default fallback - enterprise API
    #[inline(always)]
    pub fn get(&self, key: &str) -> Option<&Value> {
        // First check cache
        let cache = self.cache.read().unwrap();
        if let Some(value) = self.get_nested(&cache, key) {
            // SAFETY: This is safe because we're extending the lifetime
            // The cache is behind an Arc<RwLock> so it won't be dropped
            return Some(unsafe { std::mem::transmute(value) });
        }
        
        // Then check defaults
        let defaults = self.defaults.read().unwrap();
        if let Some(value) = self.get_nested(&defaults, key) {
            return Some(unsafe { std::mem::transmute(value) });
        }
        
        None
    }
    
    /// Get a value or return a default (ZERO-COPY optimized)
    pub fn get_or<T>(&self, key: &str, default: T) -> T
    where
        T: From<Value> + Clone,
    {
        if let Some(value) = self.get(key) {
            // ENTERPRISE: Avoid clone where possible - this still needs clone for T::from
            // TODO: Consider implementing From<&Value> trait bounds for zero-copy
            T::from(value.clone())
        } else {
            default
        }
    }
    
    /// Get with default value from defaults table
    #[inline(always)]
    pub fn get_or_default(&self, key: &str) -> Option<Value> {
        if let Some(value) = self.get(key) {
            Some(value.clone())
        } else {
            // Check defaults
            let defaults = self.defaults.read().unwrap();
            self.get_nested(&defaults, key).cloned()
        }
    }
    
    /// Check if key exists (enterprise API)
    #[inline(always)]
    pub fn exists(&self, key: &str) -> bool {
        let cache = self.cache.read().unwrap();
        self.get_nested(&cache, key).is_some() || {
            let defaults = self.defaults.read().unwrap();
            self.get_nested(&defaults, key).is_some()
        }
    }
    
    /// Set value (enterprise API) 
    pub fn set(&mut self, key: &str, value: Value) -> Result<()> {
        if self.read_only {
            return Err(Error::validation("Configuration is read-only"));
        }
        
        let mut cache = self.cache.write().unwrap();
        self.set_nested(&mut cache, key, value);
        Ok(())
    }
    
    /// Set default value for key
    pub fn set_default(&mut self, key: &str, value: Value) {
        let mut defaults = self.defaults.write().unwrap();
        self.set_nested(&mut defaults, key, value);
    }
    
    /// Save configuration to file (format-preserving when possible)
    pub fn save(&self) -> Result<()> {
        if let Some(ref path) = self.file_path {
            let cache = self.cache.read().unwrap();
            let content = self.serialize_to_format(&cache, &self.format)?;
            std::fs::write(path, content)?;
            Ok(())
        } else {
            Err(Error::general("No file path specified for save"))
        }
    }
    
    /// Save to specific file
    pub fn save_to<P: AsRef<Path>>(&self, path: P) -> Result<()> {
        let path_str = path.as_ref().to_string_lossy();
        let format = Self::detect_format(&path_str);
        let cache = self.cache.read().unwrap();
        let content = self.serialize_to_format(&cache, &format)?;
        std::fs::write(path, content)?;
        Ok(())
    }
    
    /// Get all keys (for debugging/inspection)
    pub fn keys(&self) -> Vec<String> {
        let cache = self.cache.read().unwrap();
        self.collect_keys(&cache, "")
    }
    
    /// Make config read-only for security
    pub fn make_read_only(&mut self) {
        self.read_only = true;
    }
    
    /// Clear cache (enterprise operation)
    pub fn clear(&mut self) -> Result<()> {
        if self.read_only {
            return Err(Error::general("Configuration is read-only"));
        }
        
        let mut cache = self.cache.write().unwrap();
        cache.clear();
        Ok(())
    }
    
    /// Merge another config into this one
    pub fn merge(&mut self, other: &EnterpriseConfig) -> Result<()> {
        if self.read_only {
            return Err(Error::general("Configuration is read-only"));
        }
        // ENTERPRISE: Optimized cache merge - minimize clones
        let other_cache = other.cache.read().unwrap();
        let mut self_cache = self.cache.write().unwrap();
        
        // ZERO-COPY: Use Arc/Rc for values to avoid cloning large data structures
        for (key, value) in other_cache.iter() {
            // Note: Key must be cloned for ownership, Value clone is still needed
            // TODO: Consider Arc<Value> for cache storage to eliminate value clones
            self_cache.insert(key.clone(), value.clone());
        }
        
        Ok(())
    }
    
    // --- PRIVATE HELPERS ---
    
    /// Detect format from file extension
    fn detect_format(path: &str) -> String {
        if path.ends_with(".json") {
            "json".to_string()
        } else if path.ends_with(".toml") {
            "toml".to_string()
        } else if path.ends_with(".noml") {
            "noml".to_string()
        } else {
            "conf".to_string()
        }
    }
    
    /// Parse content based on format
    fn parse_content(content: &str, format: &str) -> Result<Value> {
        match format {
            "conf" => {
                // Use the regular conf parser for now
                crate::parsers::conf::parse(content)
            }
            #[cfg(feature = "json")]
            "json" => {
                let parsed: serde_json::Value = serde_json::from_str(content)
                    .map_err(|e| Error::general(format!("JSON parse error: {}", e)))?;
                crate::parsers::json_parser::from_json_value(parsed)
            }
            #[cfg(feature = "toml")]
            "toml" => {
                crate::parsers::toml_parser::parse(content)
            }
            #[cfg(feature = "noml")]
            "noml" => {
                crate::parsers::noml_parser::parse(content)
            }
            _ => Err(Error::general(format!("Unsupported format: {}", format))),
        }
    }
    
    /// Get nested value using dot notation (zero-copy when possible)
    #[inline(always)]
    fn get_nested<'a>(&self, table: &'a BTreeMap<String, Value>, key: &str) -> Option<&'a Value> {
        if !key.contains('.') {
            return table.get(key);
        }
        
        let parts: Vec<&str> = key.split('.').collect();
        let mut current = table.get(parts[0])?;
        
        for part in &parts[1..] {
            match current {
                Value::Table(nested_table) => {
                    current = nested_table.get(*part)?;
                }
                _ => return None,
            }
        }
        
        Some(current)
    }
    
    /// Set nested value using dot notation
    fn set_nested(&self, table: &mut BTreeMap<String, Value>, key: &str, value: Value) {
        if !key.contains('.') {
            table.insert(key.to_string(), value);
            return;
        }
        
        let parts: Vec<&str> = key.split('.').collect();
        
        // Recursive helper function to avoid borrow checker issues
        fn set_recursive(
            table: &mut BTreeMap<String, Value>,
            parts: &[&str],
            value: Value,
        ) {
            if parts.len() == 1 {
                table.insert(parts[0].to_string(), value);
                return;
            }
            
            let key = parts[0].to_string();
            let remaining = &parts[1..];
            
            // Ensure the key exists and is a table
            if !table.contains_key(&key) {
                table.insert(key.clone(), Value::table(BTreeMap::new()));
            }
            
            let entry = table.get_mut(&key).unwrap();
            if !entry.is_table() {
                *entry = Value::table(BTreeMap::new());
            }
            
            if let Value::Table(nested_table) = entry {
                set_recursive(nested_table, remaining, value);
            }
        }
        
        set_recursive(table, &parts, value);
    }
    
    /// Collect all keys recursively
    fn collect_keys(&self, table: &BTreeMap<String, Value>, prefix: &str) -> Vec<String> {
        let mut keys = Vec::new();
        
        for (key, value) in table {
            let full_key = if prefix.is_empty() {
                key.clone()
            } else {
                format!("{}.{}", prefix, key)
            };
            
            keys.push(full_key.clone());
            
            if let Value::Table(nested_table) = value {
                keys.extend(self.collect_keys(nested_table, &full_key));
            }
        }
        
        keys
    }
    
    /// Serialize to specific format
    fn serialize_to_format(&self, table: &BTreeMap<String, Value>, format: &str) -> Result<String> {
        match format {
            "conf" => {
                // Basic CONF serialization (you can enhance this)
                let mut output = String::new();
                for (key, value) in table {
                    output.push_str(&format!("{} = {}\n", key, self.value_to_string(value)));
                }
                Ok(output)
            }
            #[cfg(feature = "json")]
            "json" => {
                let json_value = crate::parsers::json_parser::to_json_value(
                    &Value::table(table.clone())
                )?;
                serde_json::to_string_pretty(&json_value)
                    .map_err(|e| Error::general(format!("JSON serialize error: {}", e)))
            }
            _ => Err(Error::general(format!("Serialization not supported for format: {}", format))),
        }
    }
    
    /// Convert value to string representation
    fn value_to_string(&self, value: &Value) -> String {
        match value {
            Value::String(s) => format!("\"{}\"", s),
            Value::Integer(i) => i.to_string(),
            Value::Float(f) => f.to_string(),
            Value::Bool(b) => b.to_string(),
            Value::Null => "null".to_string(),
            Value::Array(arr) => {
                let items: Vec<String> = arr.iter().map(|v| self.value_to_string(v)).collect();
                items.join(" ")
            }
            Value::Table(_) => "[Table]".to_string(), // Simplified for now
        }
    }
}

impl ConfigManager {
    /// Create new config manager
    pub fn new() -> Self {
        Self::default()
    }
    
    /// Load named configuration
    pub fn load<P: AsRef<Path>>(&self, name: &str, path: P) -> Result<()> {
        let config = EnterpriseConfig::from_file(path)?;
        let mut configs = self.configs.write().unwrap();
        configs.insert(name.to_string(), config);
        Ok(())
    }
    
    /// Get named configuration
    pub fn get(&self, name: &str) -> Option<Arc<RwLock<EnterpriseConfig>>> {
        let configs = self.configs.read().unwrap();
        configs.get(name).map(|config| {
            // Return a reference wrapped in Arc for thread safety
            Arc::new(RwLock::new(EnterpriseConfig {
                cache: config.cache.clone(),
                defaults: config.defaults.clone(),
                file_path: config.file_path.clone(),
                format: config.format.clone(),
                read_only: config.read_only,
            }))
        })
    }
    
    /// List all configuration names
    pub fn list(&self) -> Vec<String> {
        let configs = self.configs.read().unwrap();
        configs.keys().cloned().collect()
    }
    
    /// Remove named configuration
    pub fn remove(&self, name: &str) -> bool {
        let mut configs = self.configs.write().unwrap();
        configs.remove(name).is_some()
    }
}

/// Direct parsing functions for maximum performance
/// These bypass the caching layer for one-time parsing
pub mod direct {
    use super::*;
    
    /// Parse file directly to Value (no caching)
    #[inline(always)]
    pub fn parse_file<P: AsRef<Path>>(path: P) -> Result<Value> {
        let content = std::fs::read_to_string(path)?;
        parse_string(&content, None)
    }
    
    /// Parse string directly to Value (no caching)
    #[inline(always)]
    pub fn parse_string(content: &str, format: Option<&str>) -> Result<Value> {
        let format = format.unwrap_or("conf");
        EnterpriseConfig::parse_content(content, format)
    }
    
    /// Parse to array/vector for direct use
    #[inline(always)]
    pub fn parse_to_vec<T>(content: &str) -> Result<Vec<T>>
    where
        T: TryFrom<Value>,
        T::Error: std::fmt::Display,
    {
        let value = parse_string(content, None)?;
        
        match value {
            Value::Array(arr) => {
                arr.into_iter()
                    .map(|v| T::try_from(v).map_err(|e| Error::general(e.to_string())))
                    .collect()
            }
            _ => Err(Error::general("Expected array value")),
        }
    }
}

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

    #[test]
    fn test_enterprise_config_get_or() {
        let mut config = EnterpriseConfig::new();
        config.set("port", Value::integer(8080)).unwrap();
        
        // Test existing value with manual extraction
        if let Some(port_value) = config.get("port") {
            let port = port_value.as_integer().unwrap_or(3000);
            assert_eq!(port, 8080);
        }
        
        // Test default value 
        if let Some(_) = config.get("timeout") {
            panic!("Should not find timeout key");
        }
        
        // Test default behavior
        let timeout = config.get("timeout")
            .and_then(|v| v.as_integer().ok())
            .unwrap_or(30);
        assert_eq!(timeout, 30);
    }
    
    #[test]
    fn test_exists() {
        let mut config = EnterpriseConfig::new();
        config.set("debug", Value::bool(true)).unwrap();
        
        assert!(config.exists("debug"));
        assert!(!config.exists("production"));
    }
    
    #[test]
    fn test_nested_keys() {
        let mut config = EnterpriseConfig::new();
        config.set("database.host", Value::string("localhost")).unwrap();
        config.set("database.port", Value::integer(5432)).unwrap();
        
        assert_eq!(config.get("database.host").unwrap().as_string().unwrap(), "localhost");
        assert_eq!(config.get("database.port").unwrap().as_integer().unwrap(), 5432);
        assert!(config.exists("database.host"));
    }
    
    #[test]
    fn test_direct_parsing() {
        let content = "port = 8080\ndebug = true";
        let value = direct::parse_string(content, Some("conf")).unwrap();
        
        if let Value::Table(table) = value {
            assert_eq!(table.get("port").unwrap().as_integer().unwrap(), 8080);
            assert_eq!(table.get("debug").unwrap().as_bool().unwrap(), true);
        } else {
            panic!("Expected table value");
        }
    }
}