use std::time::Duration;

use serde::Serialize;
use serde::de::DeserializeOwned;

use crate::error::{CacheError, CacheResult};
use crate::kv::Cache;

impl Cache {
    pub async fn get_json<T: DeserializeOwned>(&self, key: &str) -> CacheResult<Option<T>> {
        match self.get_bytes(key).await? {
            Some(bytes) => Ok(Some(decode(key, &bytes)?)),
            None => Ok(None),
        }
    }

    pub async fn set_json_ex<T: Serialize>(
        &self,
        key: &str,
        value: &T,
        ttl: Duration,
    ) -> CacheResult<()> {
        self.set_ex(key, encode(key, value)?, ttl).await
    }
}

pub(crate) fn encode<T: Serialize>(key: &str, value: &T) -> CacheResult<Vec<u8>> {
    serde_json::to_vec(value).map_err(|error| CacheError::encode(key, error))
}

pub(crate) fn decode<T: DeserializeOwned>(key: &str, bytes: &[u8]) -> CacheResult<T> {
    serde_json::from_slice(bytes).map_err(|error| CacheError::decode(key, error))
}