use redis::{AsyncCommands, FromRedisValue, ToRedisArgs, ToSingleRedisArg};

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

impl Cache {
    pub async fn zadd<M: ToSingleRedisArg + Send + Sync, S: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        member: M,
        score: S,
    ) -> CacheResult<usize> {
        let mut conn = self.conn().clone();
        conn.zadd(key, member, score)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrem<M: ToRedisArgs + Send + Sync>(
        &self,
        key: &str,
        members: M,
    ) -> CacheResult<usize> {
        let mut conn = self.conn().clone();
        conn.zrem(key, members).await.map_err(CacheError::from)
    }

    pub async fn zscore<M: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        member: M,
    ) -> CacheResult<Option<f64>> {
        let mut conn = self.conn().clone();
        conn.zscore(key, member).await.map_err(CacheError::from)
    }

    pub async fn zincr<M: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        member: M,
        delta: f64,
    ) -> CacheResult<f64> {
        let mut conn = self.conn().clone();
        conn.zincr(key, member, delta)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zcard(&self, key: &str) -> CacheResult<usize> {
        let mut conn = self.conn().clone();
        conn.zcard(key).await.map_err(CacheError::from)
    }

    pub async fn zcount<M: ToSingleRedisArg + Send + Sync, MM: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        min: M,
        max: MM,
    ) -> CacheResult<usize> {
        let mut conn = self.conn().clone();
        conn.zcount(key, min, max).await.map_err(CacheError::from)
    }

    pub async fn zrange<T: FromRedisValue + Send>(
        &self,
        key: &str,
        start: isize,
        stop: isize,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.zrange(key, start, stop)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrange_withscores<T: FromRedisValue + Send>(
        &self,
        key: &str,
        start: isize,
        stop: isize,
    ) -> CacheResult<Vec<(T, f64)>> {
        let mut conn = self.conn().clone();
        conn.zrange_withscores(key, start, stop)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrevrange<T: FromRedisValue + Send>(
        &self,
        key: &str,
        start: isize,
        stop: isize,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.zrevrange(key, start, stop)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrevrange_withscores<T: FromRedisValue + Send>(
        &self,
        key: &str,
        start: isize,
        stop: isize,
    ) -> CacheResult<Vec<(T, f64)>> {
        let mut conn = self.conn().clone();
        conn.zrevrange_withscores(key, start, stop)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrangebyscore<
        T: FromRedisValue + Send,
        M: ToSingleRedisArg + Send + Sync,
        MM: ToSingleRedisArg + Send + Sync,
    >(
        &self,
        key: &str,
        min: M,
        max: MM,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.zrangebyscore(key, min, max)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrangebyscore_withscores<
        T: FromRedisValue + Send,
        M: ToSingleRedisArg + Send + Sync,
        MM: ToSingleRedisArg + Send + Sync,
    >(
        &self,
        key: &str,
        min: M,
        max: MM,
    ) -> CacheResult<Vec<(T, f64)>> {
        let mut conn = self.conn().clone();
        conn.zrangebyscore_withscores(key, min, max)
            .await
            .map_err(CacheError::from)
    }

    pub async fn zrank<M: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        member: M,
    ) -> CacheResult<Option<usize>> {
        let mut conn = self.conn().clone();
        conn.zrank(key, member).await.map_err(CacheError::from)
    }

    pub async fn zrevrank<M: ToSingleRedisArg + Send + Sync>(
        &self,
        key: &str,
        member: M,
    ) -> CacheResult<Option<usize>> {
        let mut conn = self.conn().clone();
        conn.zrevrank(key, member).await.map_err(CacheError::from)
    }
}