objets_metier_rs 1.0.2

//! Implémentation du cache pour factories
//!
//! Ce module fournit un cache thread-safe avec gestion automatique du TTL (Time-To-Live).

use std::collections::HashMap;
use std::hash::Hash;
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant};

type SerializedCacheStore = Arc<RwLock<HashMap<String, Vec<u8>>>>;

/// Entrée de cache avec timestamp pour gestion du TTL
#[derive(Debug, Clone)]
pub struct CacheEntry<V> {
    /// Valeur cachée
    pub value: V,
    /// Instant de création de l'entrée
    pub created_at: Instant,
}

impl<V> CacheEntry<V> {
    /// Crée une nouvelle entrée de cache
    pub fn new(value: V) -> Self {
        Self {
            value,
            created_at: Instant::now(),
        }
    }

    /// Vérifie si l'entrée a expiré
    pub fn is_expired(&self, ttl: Duration) -> bool {
        self.created_at.elapsed() > ttl
    }
}

/// Cache thread-safe avec TTL pour factories
///
/// # Type Parameters
///
/// * `K` - Type de la clé (doit implémenter Hash + Eq)
/// * `V` - Type de la valeur cachée (doit implémenter Clone)
///
/// # Exemple
///
/// ```rust,ignore
/// use objets_metier_rs::cache::FactoryCache;
/// use std::time::Duration;
///
/// let cache = FactoryCache::new(Duration::from_secs(300));
///
/// // Insertion
/// cache.insert(1, journal.clone());
///
/// // Récupération
/// if let Some(journal) = cache.get(&1) {
///     println!("Journal depuis cache: {:?}", journal);
/// }
///
/// // Invalidation
/// cache.invalidate(&1);
///
/// // Nettoyage complet
/// cache.clear();
/// ```
pub struct FactoryCache<K, V>
where
    K: Hash + Eq,
    V: Clone,
{
    /// Stockage interne thread-safe
    store: Arc<RwLock<HashMap<K, CacheEntry<V>>>>,
    /// Durée de vie des entrées (Time-To-Live)
    ttl: Duration,
}

impl<K, V> FactoryCache<K, V>
where
    K: Hash + Eq,
    V: Clone,
{
    /// Crée un nouveau cache avec le TTL spécifié
    ///
    /// # Arguments
    ///
    /// * `ttl` - Durée de vie des entrées dans le cache
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// use std::time::Duration;
    ///
    /// // Cache avec TTL de 5 minutes
    /// let cache = FactoryCache::new(Duration::from_secs(300));
    /// ```
    pub fn new(ttl: Duration) -> Self {
        Self {
            store: Arc::new(RwLock::new(HashMap::new())),
            ttl,
        }
    }

    /// Récupère une valeur depuis le cache
    ///
    /// Retourne `None` si la clé n'existe pas ou si l'entrée a expiré.
    ///
    /// # Arguments
    ///
    /// * `key` - Clé à rechercher
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// if let Some(value) = cache.get(&key) {
    ///     println!("Trouvé dans le cache!");
    /// }
    /// ```
    pub fn get(&self, key: &K) -> Option<V> {
        let store = self.store.read().ok()?;
        let entry = store.get(key)?;

        if entry.is_expired(self.ttl) {
            drop(store);
            // L'entrée a expiré, la supprimer
            self.invalidate(key);
            None
        } else {
            Some(entry.value.clone())
        }
    }

    /// Insère une valeur dans le cache
    ///
    /// Si une entrée existe déjà pour cette clé, elle est remplacée.
    ///
    /// # Arguments
    ///
    /// * `key` - Clé d'insertion
    /// * `value` - Valeur à cacher
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// cache.insert(1, journal);
    /// ```
    pub fn insert(&self, key: K, value: V) {
        if let Ok(mut store) = self.store.write() {
            store.insert(key, CacheEntry::new(value));
        }
    }

    /// Invalide (supprime) une entrée du cache
    ///
    /// # Arguments
    ///
    /// * `key` - Clé à invalider
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// cache.invalidate(&1);
    /// ```
    pub fn invalidate(&self, key: &K) {
        if let Ok(mut store) = self.store.write() {
            store.remove(key);
        }
    }

    /// Vide complètement le cache
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// cache.clear();
    /// ```
    pub fn clear(&self) {
        if let Ok(mut store) = self.store.write() {
            store.clear();
        }
    }

    /// Nettoie les entrées expirées du cache
    ///
    /// Utile pour libérer de la mémoire périodiquement.
    ///
    /// # Returns
    ///
    /// Le nombre d'entrées supprimées
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// let removed = cache.cleanup_expired();
    /// println!("Entrées expirées supprimées: {}", removed);
    /// ```
    pub fn cleanup_expired(&self) -> usize {
        if let Ok(mut store) = self.store.write() {
            let initial_len = store.len();
            store.retain(|_, entry| !entry.is_expired(self.ttl));
            initial_len - store.len()
        } else {
            0
        }
    }

    /// Retourne le nombre d'entrées dans le cache
    ///
    /// # Exemple
    ///
    /// ```rust,ignore
    /// println!("Entrées en cache: {}", cache.len());
    /// ```
    pub fn len(&self) -> usize {
        self.store.read().map(|s| s.len()).unwrap_or(0)
    }

    /// Vérifie si le cache est vide
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Retourne les statistiques du cache
    ///
    /// # Returns
    ///
    /// `(total_entries, expired_entries)`
    pub fn stats(&self) -> (usize, usize) {
        if let Ok(store) = self.store.read() {
            let total = store.len();
            let expired = store.values().filter(|e| e.is_expired(self.ttl)).count();
            (total, expired)
        } else {
            (0, 0)
        }
    }
}

impl<K, V> Clone for FactoryCache<K, V>
where
    K: Hash + Eq,
    V: Clone,
{
    fn clone(&self) -> Self {
        Self {
            store: Arc::clone(&self.store),
            ttl: self.ttl,
        }
    }
}

/// Wrapper pour appliquer automatiquement le cache à une factory
///
/// # Type Parameters
///
/// * `F` - Type de la factory wrappée
///
/// # Exemple
///
/// ```rust,ignore
/// use objets_metier_rs::cache::{CachedFactory, FactoryCache};
/// use std::time::Duration;
///
/// let cache = FactoryCache::new(Duration::from_secs(300));
/// let cached_factory = CachedFactory::new(factory_journal, cache);
///
/// // Les lectures utiliseront le cache automatiquement
/// let journal = cached_factory.inner().read_numero(1)?;
/// ```
pub struct CachedFactory<F> {
    /// Factory originale
    factory: F,
    /// Cache partagé (peut être cloné pour partager entre factories)
    cache: Option<SerializedCacheStore>, // Cache sérialisé générique
}

impl<F> CachedFactory<F> {
    /// Crée un nouveau wrapper avec cache
    ///
    /// # Arguments
    ///
    /// * `factory` - Factory à wrapper
    pub fn new(factory: F) -> Self {
        Self {
            factory,
            cache: Some(Arc::new(RwLock::new(HashMap::new()))),
        }
    }

    /// Crée un wrapper sans cache (pass-through)
    pub fn without_cache(factory: F) -> Self {
        Self {
            factory,
            cache: None,
        }
    }

    /// Retourne une référence à la factory interne
    pub fn inner(&self) -> &F {
        &self.factory
    }

    /// Consomme le wrapper et retourne la factory originale
    pub fn into_inner(self) -> F {
        self.factory
    }

    /// Vérifie si le cache est activé
    pub fn is_cached(&self) -> bool {
        self.cache.is_some()
    }

    /// Vide le cache si présent
    pub fn clear_cache(&self) {
        if let Some(cache) = &self.cache {
            if let Ok(mut store) = cache.write() {
                store.clear();
            }
        }
    }
}

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

    #[test]
    fn test_cache_basic_operations() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_secs(1));

        // Insertion
        cache.insert(1, "value1".to_string());
        cache.insert(2, "value2".to_string());

        // Récupération
        assert_eq!(cache.get(&1), Some("value1".to_string()));
        assert_eq!(cache.get(&2), Some("value2".to_string()));
        assert_eq!(cache.get(&3), None);

        // Taille
        assert_eq!(cache.len(), 2);
        assert!(!cache.is_empty());
    }

    #[test]
    fn test_cache_expiration() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_millis(100));

        cache.insert(1, "value1".to_string());
        assert_eq!(cache.get(&1), Some("value1".to_string()));

        // Attendre l'expiration
        thread::sleep(Duration::from_millis(150));

        // L'entrée devrait avoir expiré
        assert_eq!(cache.get(&1), None);
    }

    #[test]
    fn test_cache_invalidation() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_secs(60));

        cache.insert(1, "value1".to_string());
        assert_eq!(cache.get(&1), Some("value1".to_string()));

        cache.invalidate(&1);
        assert_eq!(cache.get(&1), None);
    }

    #[test]
    fn test_cache_clear() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_secs(60));

        cache.insert(1, "value1".to_string());
        cache.insert(2, "value2".to_string());
        assert_eq!(cache.len(), 2);

        cache.clear();
        assert_eq!(cache.len(), 0);
        assert!(cache.is_empty());
    }

    #[test]
    fn test_cache_cleanup_expired() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_millis(100));

        cache.insert(1, "value1".to_string());
        cache.insert(2, "value2".to_string());
        cache.insert(3, "value3".to_string());

        thread::sleep(Duration::from_millis(150));

        let removed = cache.cleanup_expired();
        assert_eq!(removed, 3);
        assert_eq!(cache.len(), 0);
    }

    #[test]
    fn test_cache_stats() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_millis(100));

        cache.insert(1, "value1".to_string());
        cache.insert(2, "value2".to_string());

        let (total, expired) = cache.stats();
        assert_eq!(total, 2);
        assert_eq!(expired, 0);

        thread::sleep(Duration::from_millis(150));

        let (total, expired) = cache.stats();
        assert_eq!(total, 2);
        assert_eq!(expired, 2);
    }

    #[test]
    fn test_cache_thread_safety() {
        let cache: FactoryCache<i32, String> = FactoryCache::new(Duration::from_secs(60));
        let cache_clone = cache.clone();

        let handle = thread::spawn(move || {
            cache_clone.insert(1, "thread_value".to_string());
        });

        handle.join().unwrap();
        assert_eq!(cache.get(&1), Some("thread_value".to_string()));
    }

    #[test]
    fn test_cached_factory() {
        struct DummyFactory;

        let factory = DummyFactory;
        let cached = CachedFactory::new(factory);

        assert!(cached.is_cached());
        assert!(cached.inner() as *const _ == &cached.factory as *const _);

        let uncached = CachedFactory::without_cache(DummyFactory);
        assert!(!uncached.is_cached());
    }
}