ubiquity-database 0.1.1

//! Database configuration

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

/// Database configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatabaseConfig {
    /// Backend to use
    pub backend: crate::DatabaseBackend,
    
    /// SQLite configuration
    pub sqlite: SqliteConfig,
    
    /// Astra DB configuration
    #[cfg(feature = "astra")]
    pub astra: AstraConfig,
    
    /// Embedding configuration
    pub embeddings: EmbeddingConfig,
    
    /// Memory pool configuration
    pub memory_pools: MemoryPoolConfig,
}

impl Default for DatabaseConfig {
    fn default() -> Self {
        Self {
            backend: crate::DatabaseBackend::Sqlite,
            sqlite: SqliteConfig::default(),
            #[cfg(feature = "astra")]
            astra: AstraConfig::default(),
            embeddings: EmbeddingConfig::default(),
            memory_pools: MemoryPoolConfig::default(),
        }
    }
}

/// SQLite configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SqliteConfig {
    /// Database path
    pub path: PathBuf,
    
    /// Maximum connections
    pub max_connections: u32,
    
    /// Enable WAL mode
    pub wal_mode: bool,
    
    /// Memory pool directory
    pub pool_directory: PathBuf,
}

impl Default for SqliteConfig {
    fn default() -> Self {
        Self {
            path: PathBuf::from("ubiquity.db"),
            max_connections: 10,
            wal_mode: true,
            pool_directory: PathBuf::from(".ubiquity/pools"),
        }
    }
}

/// Astra DB configuration
#[cfg(feature = "astra")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AstraConfig {
    /// API endpoint
    pub endpoint: String,
    
    /// Application token
    pub token: String,
    
    /// Keyspace name
    pub keyspace: String,
    
    /// Collections configuration
    pub collections: AstraCollections,
    
    /// Streaming configuration
    pub streaming: AstraStreamingConfig,
}

#[cfg(feature = "astra")]
impl Default for AstraConfig {
    fn default() -> Self {
        Self {
            endpoint: String::new(),
            token: String::new(),
            keyspace: "ubiquity".to_string(),
            collections: AstraCollections::default(),
            streaming: AstraStreamingConfig::default(),
        }
    }
}

/// Astra collections configuration
#[cfg(feature = "astra")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AstraCollections {
    /// Consciousness states collection
    pub consciousness: String,
    
    /// Consciousness ripples collection
    pub ripples: String,
    
    /// Tasks collection
    pub tasks: String,
    
    /// Memory pool prefix for collections
    pub pool_prefix: String,
}

#[cfg(feature = "astra")]
impl Default for AstraCollections {
    fn default() -> Self {
        Self {
            consciousness: "consciousness_states".to_string(),
            ripples: "consciousness_ripples".to_string(),
            tasks: "tasks".to_string(),
            pool_prefix: "memory_pool_".to_string(),
        }
    }
}

/// Astra Streaming configuration
#[cfg(feature = "astra")]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AstraStreamingConfig {
    /// Streaming endpoint
    pub endpoint: String,
    
    /// Tenant name
    pub tenant: String,
    
    /// Namespace
    pub namespace: String,
    
    /// Topic prefix
    pub topic_prefix: String,
}

#[cfg(feature = "astra")]
impl Default for AstraStreamingConfig {
    fn default() -> Self {
        Self {
            endpoint: String::new(),
            tenant: String::new(),
            namespace: "ubiquity".to_string(),
            topic_prefix: "ubiquity_".to_string(),
        }
    }
}

/// Embedding configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingConfig {
    /// Embedding dimension
    pub dimension: usize,
    
    /// Model to use for embeddings
    pub model: String,
    
    /// Provider for vectorization
    pub provider: String,
    
    /// Cache embeddings
    pub cache_enabled: bool,
    
    /// Maximum cache size
    pub cache_size: usize,
}

impl Default for EmbeddingConfig {
    fn default() -> Self {
        Self {
            dimension: 1536,
            model: "text-embedding-3-small".to_string(),
            provider: "openai".to_string(),
            cache_enabled: true,
            cache_size: 10000,
        }
    }
}

/// Memory pool configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryPoolConfig {
    /// Number of pools (default: 7)
    pub pool_count: usize,
    
    /// Maximum pool size in MB
    pub max_pool_size_mb: usize,
    
    /// Eviction policy
    pub eviction_policy: EvictionPolicy,
    
    /// Enable compression
    pub compression: bool,
}

impl Default for MemoryPoolConfig {
    fn default() -> Self {
        Self {
            pool_count: 7,
            max_pool_size_mb: 100,
            eviction_policy: EvictionPolicy::Lru,
            compression: true,
        }
    }
}

/// Eviction policy for memory pools
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum EvictionPolicy {
    /// Least Recently Used
    Lru,
    /// Least Frequently Used
    Lfu,
    /// Time To Live
    Ttl,
    /// No eviction
    None,
}