module Database.Redis.Set
    ( setAdd, setAddB
    , setRemove, setRemoveB
    , setPop
    , setMove
    , setCardinality
    , setIsMember, setIsMemberB
    , setIntersect
    , setIntersectStore
    , setUnion
    , setUnionStore
    , setDiff
    , setDiffStore
    , setMembers, setMembersB
    , setRandMember, setRandMemberB
    ) where


import           System.IO

import           Database.Redis.Internal


------------------------------------------------------------------------------
-- | SADD
setAdd :: Handle
       -> String  -- ^ key
       -> String  -- ^ value
       -> IO (Maybe RedisReply)
setAdd h key value = request h $ map toUTF8 ["SADD", key, value]


-- | SADD
setAddB :: Handle
        -> ByteString  -- ^ key
        -> ByteString  -- ^ value
        -> IO (Maybe RedisReply)
setAddB h key value = request h [toUTF8 "SADD", key, value]


------------------------------------------------------------------------------
-- | SREM
setRemove :: Handle
          -> String  -- ^ key
          -> String  -- ^ value
          -> IO (Maybe RedisReply)
setRemove h key value = request h $ map toUTF8 ["SREM", key, value]


-- | SREM
setRemoveB :: Handle
           -> ByteString  -- ^ key
           -> ByteString  -- ^ value
           -> IO (Maybe RedisReply)
setRemoveB h key value = request h [toUTF8 "SREM", key, value]


------------------------------------------------------------------------------
-- | SPOP
setPop :: Handle
       -> String  -- ^ key
       -> IO (Maybe RedisReply)
setPop h key = request h $ map toUTF8 ["SPOP", key]


------------------------------------------------------------------------------
-- | SMOVE
setMove :: Handle
        -> String  -- ^ source key
        -> String  -- ^ destination key
        -> String  -- ^ member
        -> IO (Maybe RedisReply)
setMove h s d m = request h $ map toUTF8 ["SMOVE", s, d, m]


------------------------------------------------------------------------------
-- | SCARD
setCardinality :: Handle
               -> String  -- ^ key
               -> IO (Maybe RedisReply)
setCardinality h key = request h $ map toUTF8 ["SCARD", key]


------------------------------------------------------------------------------
-- | SISMEMBER
setIsMember :: Handle
            -> String  -- ^ key
            -> String  -- ^ value
            -> IO (Maybe RedisReply)
setIsMember h key value = request h $ map toUTF8 ["SISMEMBER", key, value]


-- | SISMEMBER
setIsMemberB :: Handle
             -> ByteString  -- ^ key
             -> ByteString  -- ^ value
             -> IO (Maybe RedisReply)
setIsMemberB h key value = request h [toUTF8 "SISMEMBER", key, value]


------------------------------------------------------------------------------
-- | SINTER
setIntersect :: Handle
             -> [String]        -- ^ keys for sets to intersect
             -> IO (Maybe RedisReply)
setIntersect h keys = request h $ map toUTF8 $ "SINTER":keys


------------------------------------------------------------------------------
-- | SINTERSTORE
setIntersectStore :: Handle
                  -> String          -- ^ destination key
                  -> [String]        -- ^ keys for sets to intersect
                  -> IO (Maybe RedisReply)
setIntersectStore h dest keys = request h $ map toUTF8 $ "SINTER":dest:keys


------------------------------------------------------------------------------
-- | SUNION
setUnion :: Handle
         -> [String]        -- ^ set keys to union
         -> IO (Maybe RedisReply)
setUnion h keys = request h $ map toUTF8 $ "SUNION":keys


------------------------------------------------------------------------------
-- | SUNIONSTORE
setUnionStore :: Handle
              -> String          -- ^ destination key
              -> [String]        -- ^ set keys to union
              -> IO (Maybe RedisReply)
setUnionStore h dest keys = request h $ map toUTF8 $ "SUNIONSTORE":dest:keys


------------------------------------------------------------------------------
-- | SDIFF
setDiff :: Handle
        -> [String]        -- ^ keys for sets to union
        -> IO (Maybe RedisReply)
setDiff h keys = request h $ map toUTF8 $ "SDIFF":keys


------------------------------------------------------------------------------
-- | SDIFFSTORE
setDiffStore :: Handle
             -> String          -- ^ destination key
             -> [String]        -- ^ keys for sets to diff
             -> IO (Maybe RedisReply)
setDiffStore h dest keys = request h $ map toUTF8 $ "SDIFFSTORE":dest:keys


------------------------------------------------------------------------------
-- | SMEMBERS
setMembers :: Handle
           -> String -- ^ key
           -> IO (Maybe RedisReply)
setMembers h key = request h $ map toUTF8 ["SMEMBERS", key]


-- | SMEMBERS
setMembersB :: Handle
            -> ByteString -- ^ key
            -> IO (Maybe RedisReply)
setMembersB h key = request h [toUTF8 "SMEMBERS", key]


------------------------------------------------------------------------------
-- | SRANDMEMBER
setRandMember :: Handle
              -> String  -- ^ key
              -> IO (Maybe RedisReply)
setRandMember h key = request h $ map toUTF8 ["SRANDMEMBER", key]


-- | SRANDMEMBER
setRandMemberB :: Handle
               -> ByteString  -- ^ key
               -> IO (Maybe RedisReply)
setRandMemberB h key = request h [toUTF8 "SRANDMEMBER", key]