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

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

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

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

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

    pub async fn smove<V: ToRedisArgs + Send + Sync>(
        &self,
        source: &str,
        destination: &str,
        member: V,
    ) -> CacheResult<bool> {
        let mut cmd = Cmd::new();
        cmd.arg("SMOVE").arg(source).arg(destination).arg(member);
        self.exec(&cmd).await
    }

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

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

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

    pub async fn sinter<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
        &self,
        keys: K,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.sinter(keys).await.map_err(CacheError::from)
    }

    pub async fn sunion<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
        &self,
        keys: K,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.sunion(keys).await.map_err(CacheError::from)
    }

    pub async fn sdiff<T: FromRedisValue + Send, K: ToRedisArgs + Send + Sync>(
        &self,
        keys: K,
    ) -> CacheResult<Vec<T>> {
        let mut conn = self.conn().clone();
        conn.sdiff(keys).await.map_err(CacheError::from)
    }

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

    pub async fn spop_many<T: FromRedisValue + Send>(
        &self,
        key: &str,
        count: usize,
    ) -> CacheResult<Vec<T>> {
        let mut cmd = Cmd::new();
        cmd.arg("SPOP").arg(key).arg(count);
        self.exec(&cmd).await
    }
}