use std::future::Future;
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 get_del_json<T: DeserializeOwned>(&self, key: &str) -> CacheResult<Option<T>> {
        match self.get_del::<Vec<u8>>(key).await? {
            Some(bytes) => Ok(Some(decode(key, &bytes)?)),
            None => Ok(None),
        }
    }

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

    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 async fn set_json_default<T: Serialize>(&self, key: &str, value: &T) -> CacheResult<()> {
        self.set_default(key, encode(key, value)?).await
    }

    pub async fn set_json_nx<T: Serialize>(&self, key: &str, value: &T) -> CacheResult<bool> {
        self.set_nx(key, encode(key, value)?).await
    }

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

    pub async fn get_or_set_json<T, F, Fut>(
        &self,
        key: &str,
        ttl: Option<Duration>,
        fill: F,
    ) -> CacheResult<T>
    where
        T: Serialize + DeserializeOwned,
        F: FnOnce() -> Fut,
        Fut: Future<Output = CacheResult<T>>,
    {
        if let Some(value) = self.get_json::<T>(key).await? {
            return Ok(value);
        }
        let value = fill().await?;
        match ttl {
            Some(ttl) => self.set_json_ex(key, &value, ttl).await?,
            None => self.set_json(key, &value).await?,
        }
        Ok(value)
    }

    pub async fn mget_json<T: DeserializeOwned>(
        &self,
        keys: Vec<String>,
    ) -> CacheResult<Vec<Option<T>>> {
        let raw: Vec<Option<Vec<u8>>> = self.mget(keys.clone()).await?;
        raw.iter()
            .enumerate()
            .map(|(index, item)| match item {
                Some(bytes) => {
                    let key = keys.get(index).map(String::as_str).unwrap_or_default();
                    Ok(Some(decode(key, bytes)?))
                }
                None => Ok(None),
            })
            .collect()
    }
}

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))
}