//! This module provides the functionality to cache the aggregated results fetched and aggregated
//! from the upstream search engines in a json format.

use error_stack::Report;
use mini_moka::sync::Cache as MokaCache;
use std::time::Duration;
use tokio::sync::Mutex;

use crate::results::aggregation_models::SearchResults;

use super::{error::PoolError, redis_cacher::RedisCache};

/// Different implementations for caching, currently it is possible to cache in-memory or in Redis.
#[derive(Clone)]
pub enum Cache {
    /// Encapsulates the Redis based cache
    Redis(RedisCache),
    /// Contains the in-memory cache.
    InMemory(MokaCache<String, SearchResults>),
}

impl Cache {
    /// Creates a new cache, which wraps the given RedisCache.
    pub fn new(redis_cache: RedisCache) -> Self {
        Cache::Redis(redis_cache)
    }

    /// Creates an in-memory cache
    pub fn new_in_memory() -> Self {
        let cache = MokaCache::builder()
            .max_capacity(1000)
            .time_to_live(Duration::from_secs(60))
            .build();
        Cache::InMemory(cache)
    }

    /// A function which fetches the cached json results as json string.
    ///
    /// # Arguments
    ///
    /// * `url` - It takes an url as a string.
    pub async fn cached_json(&mut self, url: &str) -> Result<SearchResults, Report<PoolError>> {
        match self {
            Cache::Redis(redis_cache) => {
                let json = redis_cache.cached_json(url).await?;
                Ok(serde_json::from_str::<SearchResults>(&json)
                    .map_err(|_| PoolError::SerializationError)?)
            }
            Cache::InMemory(in_memory) => match in_memory.get(&url.to_string()) {
                Some(res) => Ok(res),
                None => Err(Report::new(PoolError::MissingValue)),
            },
        }
    }

    /// A function which caches the results by using the `url` as the key and
    /// `json results` as the value and stores it in the cache
    ///
    /// # Arguments
    ///
    /// * `json_results` - It takes the json results string as an argument.
    /// * `url` - It takes the url as a String.
    pub async fn cache_results(
        &mut self,
        search_results: SearchResults,
        url: &str,
    ) -> Result<(), Report<PoolError>> {
        match self {
            Cache::Redis(redis_cache) => {
                let json = serde_json::to_string(&search_results)
                    .map_err(|_| PoolError::SerializationError)?;
                redis_cache.cache_results(&json, url).await
            }
            Cache::InMemory(cache) => {
                cache.insert(url.to_string(), search_results);
                Ok(())
            }
        }
    }
}

/// A structure to efficiently share the cache between threads - as it is protected by a Mutex.
pub struct SharedCache {
    cache: Mutex<Cache>,
}

impl SharedCache {
    /// Creates a new SharedCache from a Cache implementation
    pub fn new(cache: Cache) -> Self {
        Self {
            cache: Mutex::new(cache),
        }
    }

    /// A function which retrieves the cached SearchResulsts from the internal cache.
    pub async fn cached_json(&self, url: &str) -> Result<SearchResults, Report<PoolError>> {
        let mut mut_cache = self.cache.lock().await;
        mut_cache.cached_json(url).await
    }

    /// A function which caches the results by using the `url` as the key and
    /// `SearchResults` as the value.
    pub async fn cache_results(
        &self,
        search_results: SearchResults,
        url: &str,
    ) -> Result<(), Report<PoolError>> {
        let mut mut_cache = self.cache.lock().await;
        mut_cache.cache_results(search_results, url).await
    }
}