openmemory 0.1.1

//! Configuration management for OpenMemory SDK
//!
//! This module handles loading configuration from environment variables
//! and provides a `Config` struct with all settings.

use crate::core::error::{Error, Result};
use crate::core::types::{EmbeddingKind, Tier};
use std::env;
use std::path::PathBuf;

/// Main configuration struct for OpenMemory
#[derive(Debug, Clone)]
pub struct Config {
    // === Server ===
    /// HTTP server port
    pub port: u16,
    /// Path to SQLite database file
    pub db_path: PathBuf,
    /// API key for authentication
    pub api_key: Option<String>,

    // === Rate Limiting ===
    /// Enable rate limiting
    pub rate_limit_enabled: bool,
    /// Rate limit window in milliseconds
    pub rate_limit_window_ms: u64,
    /// Max requests per window
    pub rate_limit_max_requests: u32,

    // === Compression ===
    /// Enable memory compression
    pub compression_enabled: bool,
    /// Compression algorithm
    pub compression_algorithm: CompressionAlgorithm,
    /// Minimum content length to compress
    pub compression_min_length: usize,

    // === Embeddings ===
    /// Embedding provider type
    pub embedding_kind: EmbeddingKind,
    /// Embedding mode (simple/advanced)
    pub embed_mode: String,
    /// Enable parallel embedding in advanced mode
    pub adv_embed_parallel: bool,
    /// Delay between embedding requests (ms)
    pub embed_delay_ms: u64,

    // === OpenAI ===
    /// OpenAI API key
    pub openai_key: Option<String>,
    /// OpenAI base URL
    pub openai_base_url: String,
    /// OpenAI model name
    pub openai_model: Option<String>,

    // === Google Gemini ===
    /// Gemini API key
    pub gemini_key: Option<String>,

    // === AWS ===
    /// AWS region
    pub aws_region: Option<String>,
    /// AWS access key ID
    pub aws_access_key_id: Option<String>,
    /// AWS secret access key
    pub aws_secret_access_key: Option<String>,

    // === Ollama ===
    /// Ollama server URL
    pub ollama_url: String,

    // === Local Model ===
    /// Path to local model
    pub local_model_path: Option<String>,

    // === Vector Settings ===
    /// Performance tier
    pub tier: Tier,
    /// Vector dimension
    pub vec_dim: usize,
    /// Minimum score threshold
    pub min_score: f64,
    /// Maximum vector dimension
    pub max_vector_dim: usize,
    /// Minimum vector dimension
    pub min_vector_dim: usize,

    // === Decay Settings ===
    /// Default decay lambda
    pub decay_lambda: f64,
    /// Decay interval in minutes
    pub decay_interval_minutes: u64,
    /// Decay ratio
    pub decay_ratio: f64,
    /// Sleep time between decay batches (ms)
    pub decay_sleep_ms: u64,
    /// Number of decay threads
    pub decay_threads: usize,
    /// Cold memory threshold
    pub decay_cold_threshold: f64,
    /// Reinforce memories on query
    pub decay_reinforce_on_query: bool,

    // === Segmentation & Caching ===
    /// Segment size
    pub seg_size: usize,
    /// Number of cache segments
    pub cache_segments: usize,
    /// Maximum active memories
    pub max_active: usize,

    // === Reflection ===
    /// Enable auto reflection
    pub auto_reflect: bool,
    /// Reflection interval
    pub reflect_interval: usize,
    /// Minimum memories for reflection
    pub reflect_min: usize,

    // === User Summary ===
    /// User summary update interval
    pub user_summary_interval: usize,
    /// Use summary only mode
    pub use_summary_only: bool,
    /// Maximum summary length
    pub summary_max_length: usize,
    /// Number of summary layers
    pub summary_layers: usize,

    // === Keyword ===
    /// Keyword boost factor
    pub keyword_boost: f64,
    /// Minimum keyword length
    pub keyword_min_length: usize,

    // === Miscellaneous ===
    /// Maximum payload size
    pub max_payload_size: usize,
    /// Operating mode
    pub mode: String,
    /// Enable regeneration
    pub regeneration_enabled: bool,
}

/// Compression algorithm options
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CompressionAlgorithm {
    Semantic,
    Syntactic,
    Aggressive,
    #[default]
    Auto,
}

impl CompressionAlgorithm {
    pub fn from_str(s: &str) -> Self {
        match s.to_lowercase().as_str() {
            "semantic" => CompressionAlgorithm::Semantic,
            "syntactic" => CompressionAlgorithm::Syntactic,
            "aggressive" => CompressionAlgorithm::Aggressive,
            _ => CompressionAlgorithm::Auto,
        }
    }
}

impl Default for Config {
    fn default() -> Self {
        let tier = Tier::default();
        let tier_dim = tier.default_dimension();

        Self {
            // Server
            port: 8080,
            db_path: PathBuf::from("./data/openmemory.sqlite"),
            api_key: None,

            // Rate Limiting
            rate_limit_enabled: false,
            rate_limit_window_ms: 60000,
            rate_limit_max_requests: 100,

            // Compression
            compression_enabled: false,
            compression_algorithm: CompressionAlgorithm::Auto,
            compression_min_length: 100,

            // Embeddings
            embedding_kind: EmbeddingKind::Synthetic,
            embed_mode: "simple".to_string(),
            adv_embed_parallel: false,
            embed_delay_ms: 200,

            // OpenAI
            openai_key: None,
            openai_base_url: "https://api.openai.com/v1".to_string(),
            openai_model: None,

            // Gemini
            gemini_key: None,

            // AWS
            aws_region: None,
            aws_access_key_id: None,
            aws_secret_access_key: None,

            // Ollama
            ollama_url: "http://localhost:11434".to_string(),

            // Local Model
            local_model_path: None,

            // Vector Settings
            tier,
            vec_dim: tier_dim,
            min_score: 0.3,
            max_vector_dim: tier_dim,
            min_vector_dim: 64,

            // Decay Settings
            decay_lambda: 0.02,
            decay_interval_minutes: 1440,
            decay_ratio: 0.03,
            decay_sleep_ms: 200,
            decay_threads: 3,
            decay_cold_threshold: 0.25,
            decay_reinforce_on_query: true,

            // Segmentation & Caching
            seg_size: 10000,
            cache_segments: 3,
            max_active: 64,

            // Reflection
            auto_reflect: false,
            reflect_interval: 10,
            reflect_min: 20,

            // User Summary
            user_summary_interval: 30,
            use_summary_only: true,
            summary_max_length: 200,
            summary_layers: 3,

            // Keyword
            keyword_boost: 2.5,
            keyword_min_length: 3,

            // Miscellaneous
            max_payload_size: 1_000_000,
            mode: "standard".to_string(),
            regeneration_enabled: true,
        }
    }
}

impl Config {
    /// Create a new Config with default values
    pub fn new() -> Self {
        Self::default()
    }

    /// Load configuration from environment variables
    ///
    /// Reads from .env file if present, then overlays with actual env vars.
    pub fn from_env() -> Result<Self> {
        // Try to load .env file (ignore errors if not found)
        let _ = dotenvy::dotenv();

        let mut config = Self::default();

        // Helper functions
        let get_str = |key: &str| env::var(key).ok();
        let get_num = |key: &str, default: u64| -> u64 {
            env::var(key)
                .ok()
                .and_then(|v| v.parse().ok())
                .unwrap_or(default)
        };
        let get_bool = |key: &str| env::var(key).ok().map(|v| v == "true").unwrap_or(false);
        let get_bool_default_true = |key: &str| {
            env::var(key)
                .ok()
                .map(|v| v != "false")
                .unwrap_or(true)
        };

        // Parse tier first as it affects other defaults
        if let Some(tier_str) = get_str("OM_TIER") {
            config.tier = match tier_str.to_lowercase().as_str() {
                "fast" => Tier::Fast,
                "smart" => Tier::Smart,
                "deep" => Tier::Deep,
                "hybrid" => Tier::Hybrid,
                _ => {
                    log::warn!("[OpenMemory] Invalid OM_TIER '{}', using default", tier_str);
                    Tier::default()
                }
            };
        }

        // Update tier-dependent defaults
        let tier_dims = config.tier.default_dimension();
        let tier_cache = match config.tier {
            Tier::Fast => 2,
            Tier::Smart => 3,
            Tier::Deep => 5,
            Tier::Hybrid => 3,
        };
        let tier_max_active = match config.tier {
            Tier::Fast => 32,
            Tier::Smart => 64,
            Tier::Deep => 128,
            Tier::Hybrid => 64,
        };

        // Server
        config.port = get_num("OM_PORT", 8080) as u16;
        if let Some(path) = get_str("OM_DB_PATH") {
            config.db_path = PathBuf::from(path);
        }
        config.api_key = get_str("OM_API_KEY");

        // Rate Limiting
        config.rate_limit_enabled = get_bool("OM_RATE_LIMIT_ENABLED");
        config.rate_limit_window_ms = get_num("OM_RATE_LIMIT_WINDOW_MS", 60000);
        config.rate_limit_max_requests = get_num("OM_RATE_LIMIT_MAX_REQUESTS", 100) as u32;

        // Compression
        config.compression_enabled = get_bool("OM_COMPRESSION_ENABLED");
        config.compression_algorithm = get_str("OM_COMPRESSION_ALGORITHM")
            .map(|s| CompressionAlgorithm::from_str(&s))
            .unwrap_or(CompressionAlgorithm::Auto);
        config.compression_min_length = get_num("OM_COMPRESSION_MIN_LENGTH", 100) as usize;

        // Embeddings
        config.embedding_kind = get_str("OM_EMBEDDINGS")
            .map(|s| match s.to_lowercase().as_str() {
                "openai" => EmbeddingKind::OpenAI,
                "gemini" => EmbeddingKind::Gemini,
                "ollama" => EmbeddingKind::Ollama,
                "bedrock" => EmbeddingKind::Bedrock,
                _ => EmbeddingKind::Synthetic,
            })
            .unwrap_or(EmbeddingKind::Synthetic);
        config.embed_mode = get_str("OM_EMBED_MODE").unwrap_or_else(|| "simple".to_string());
        config.adv_embed_parallel = get_bool("OM_ADV_EMBED_PARALLEL");
        config.embed_delay_ms = get_num("OM_EMBED_DELAY_MS", 200);

        // OpenAI
        config.openai_key = get_str("OPENAI_API_KEY").or_else(|| get_str("OM_OPENAI_API_KEY"));
        config.openai_base_url = get_str("OM_OPENAI_BASE_URL")
            .unwrap_or_else(|| "https://api.openai.com/v1".to_string());
        config.openai_model = get_str("OM_OPENAI_MODEL");

        // Gemini
        config.gemini_key = get_str("GEMINI_API_KEY").or_else(|| get_str("OM_GEMINI_API_KEY"));

        // AWS
        config.aws_region = get_str("AWS_REGION");
        config.aws_access_key_id = get_str("AWS_ACCESS_KEY_ID");
        config.aws_secret_access_key = get_str("AWS_SECRET_ACCESS_KEY");

        // Ollama
        config.ollama_url = get_str("OLLAMA_URL")
            .or_else(|| get_str("OM_OLLAMA_URL"))
            .unwrap_or_else(|| "http://localhost:11434".to_string());

        // Local Model
        config.local_model_path =
            get_str("LOCAL_MODEL_PATH").or_else(|| get_str("OM_LOCAL_MODEL_PATH"));

        // Vector Settings
        config.vec_dim = get_num("OM_VEC_DIM", tier_dims as u64) as usize;
        config.min_score = get_str("OM_MIN_SCORE")
            .and_then(|v| v.parse().ok())
            .unwrap_or(0.3);
        config.max_vector_dim = get_num("OM_MAX_VECTOR_DIM", tier_dims as u64) as usize;
        config.min_vector_dim = get_num("OM_MIN_VECTOR_DIM", 64) as usize;

        // Decay Settings
        config.decay_lambda = get_str("OM_DECAY_LAMBDA")
            .and_then(|v| v.parse().ok())
            .unwrap_or(0.02);
        config.decay_interval_minutes = get_num("OM_DECAY_INTERVAL_MINUTES", 1440);
        config.decay_ratio = get_str("OM_DECAY_RATIO")
            .and_then(|v| v.parse().ok())
            .unwrap_or(0.03);
        config.decay_sleep_ms = get_num("OM_DECAY_SLEEP_MS", 200);
        config.decay_threads = get_num("OM_DECAY_THREADS", 3) as usize;
        config.decay_cold_threshold = get_str("OM_DECAY_COLD_THRESHOLD")
            .and_then(|v| v.parse().ok())
            .unwrap_or(0.25);
        config.decay_reinforce_on_query = get_bool_default_true("OM_DECAY_REINFORCE_ON_QUERY");

        // Segmentation & Caching
        config.seg_size = get_num("OM_SEG_SIZE", 10000) as usize;
        config.cache_segments = get_num("OM_CACHE_SEGMENTS", tier_cache as u64) as usize;
        config.max_active = get_num("OM_MAX_ACTIVE", tier_max_active as u64) as usize;

        // Reflection
        config.auto_reflect = get_bool("OM_AUTO_REFLECT");
        config.reflect_interval = get_num("OM_REFLECT_INTERVAL", 10) as usize;
        config.reflect_min = get_num("OM_REFLECT_MIN_MEMORIES", 20) as usize;

        // User Summary
        config.user_summary_interval = get_num("OM_USER_SUMMARY_INTERVAL", 30) as usize;
        config.use_summary_only = get_bool_default_true("OM_USE_SUMMARY_ONLY");
        config.summary_max_length = get_num("OM_SUMMARY_MAX_LENGTH", 200) as usize;
        config.summary_layers = get_num("OM_SUMMARY_LAYERS", 3) as usize;

        // Keyword
        config.keyword_boost = get_str("OM_KEYWORD_BOOST")
            .and_then(|v| v.parse().ok())
            .unwrap_or(2.5);
        config.keyword_min_length = get_num("OM_KEYWORD_MIN_LENGTH", 3) as usize;

        // Miscellaneous
        config.max_payload_size = get_num("OM_MAX_PAYLOAD_SIZE", 1_000_000) as usize;
        config.mode = get_str("OM_MODE")
            .map(|s| s.to_lowercase())
            .unwrap_or_else(|| "standard".to_string());
        config.regeneration_enabled = get_bool_default_true("OM_REGENERATION_ENABLED");

        Ok(config)
    }

    /// Create config with a specific database path
    pub fn with_db_path(mut self, path: impl Into<PathBuf>) -> Self {
        self.db_path = path.into();
        self
    }

    /// Create config with a specific tier
    pub fn with_tier(mut self, tier: Tier) -> Self {
        self.tier = tier;
        self.vec_dim = tier.default_dimension();
        self.max_vector_dim = tier.default_dimension();
        self
    }

    /// Create config with a specific embedding kind
    pub fn with_embedding_kind(mut self, kind: EmbeddingKind) -> Self {
        self.embedding_kind = kind;
        self
    }

    /// Create config for in-memory database (useful for testing)
    pub fn in_memory() -> Self {
        Self::default().with_db_path(":memory:")
    }

    /// Validate the configuration
    pub fn validate(&self) -> Result<()> {
        // Check embedding provider requirements
        match self.embedding_kind {
            EmbeddingKind::OpenAI => {
                if self.openai_key.is_none() {
                    return Err(Error::config(
                        "OpenAI embeddings require OPENAI_API_KEY or OM_OPENAI_API_KEY",
                    ));
                }
            }
            EmbeddingKind::Gemini => {
                if self.gemini_key.is_none() {
                    return Err(Error::config(
                        "Gemini embeddings require GEMINI_API_KEY or OM_GEMINI_API_KEY",
                    ));
                }
            }
            EmbeddingKind::Bedrock => {
                if self.aws_region.is_none()
                    || self.aws_access_key_id.is_none()
                    || self.aws_secret_access_key.is_none()
                {
                    return Err(Error::config(
                        "Bedrock embeddings require AWS_REGION, AWS_ACCESS_KEY_ID, and AWS_SECRET_ACCESS_KEY",
                    ));
                }
            }
            _ => {}
        }

        // Validate vector dimensions
        if self.vec_dim < self.min_vector_dim || self.vec_dim > self.max_vector_dim {
            return Err(Error::config(format!(
                "vec_dim {} must be between {} and {}",
                self.vec_dim, self.min_vector_dim, self.max_vector_dim
            )));
        }

        Ok(())
    }
}

/// Builder for creating Config instances
#[derive(Default)]
pub struct ConfigBuilder {
    config: Config,
}

impl ConfigBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn db_path(mut self, path: impl Into<PathBuf>) -> Self {
        self.config.db_path = path.into();
        self
    }

    pub fn tier(mut self, tier: Tier) -> Self {
        self.config.tier = tier;
        self.config.vec_dim = tier.default_dimension();
        self.config.max_vector_dim = tier.default_dimension();
        self
    }

    pub fn embedding_kind(mut self, kind: EmbeddingKind) -> Self {
        self.config.embedding_kind = kind;
        self
    }

    pub fn openai_key(mut self, key: impl Into<String>) -> Self {
        self.config.openai_key = Some(key.into());
        self
    }

    pub fn gemini_key(mut self, key: impl Into<String>) -> Self {
        self.config.gemini_key = Some(key.into());
        self
    }

    pub fn ollama_url(mut self, url: impl Into<String>) -> Self {
        self.config.ollama_url = url.into();
        self
    }

    pub fn vec_dim(mut self, dim: usize) -> Self {
        self.config.vec_dim = dim;
        self
    }

    pub fn build(self) -> Result<Config> {
        self.config.validate()?;
        Ok(self.config)
    }

    pub fn build_unchecked(self) -> Config {
        self.config
    }
}

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

    #[test]
    fn test_default_config() {
        let config = Config::default();
        assert_eq!(config.port, 8080);
        assert_eq!(config.tier, Tier::Smart);
        assert_eq!(config.vec_dim, 384);
        assert_eq!(config.embedding_kind, EmbeddingKind::Synthetic);
    }

    #[test]
    fn test_config_builder() {
        let config = ConfigBuilder::new()
            .tier(Tier::Fast)
            .embedding_kind(EmbeddingKind::Synthetic)
            .db_path(":memory:")
            .build_unchecked();

        assert_eq!(config.tier, Tier::Fast);
        assert_eq!(config.vec_dim, 256);
    }

    #[test]
    fn test_in_memory_config() {
        let config = Config::in_memory();
        assert_eq!(config.db_path.to_str().unwrap(), ":memory:");
    }

    #[test]
    fn test_compression_algorithm_parse() {
        assert_eq!(
            CompressionAlgorithm::from_str("semantic"),
            CompressionAlgorithm::Semantic
        );
        assert_eq!(
            CompressionAlgorithm::from_str("AGGRESSIVE"),
            CompressionAlgorithm::Aggressive
        );
        assert_eq!(
            CompressionAlgorithm::from_str("unknown"),
            CompressionAlgorithm::Auto
        );
    }

    #[test]
    fn test_validation_synthetic_no_key() {
        let config = ConfigBuilder::new()
            .embedding_kind(EmbeddingKind::Synthetic)
            .build();
        assert!(config.is_ok());
    }

    #[test]
    fn test_validation_openai_no_key() {
        let config = ConfigBuilder::new()
            .embedding_kind(EmbeddingKind::OpenAI)
            .build();
        assert!(config.is_err());
    }
}