using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using StackExchange.Redis;

namespace RedisStuy
{
    /// <summary>
    /// 集合操作学习
    /// </summary>
    public class RedisSetStudy
    {
        #region 初始化
        private IDatabase redisDatabase;
        public RedisSetStudy()
        {
            redisDatabase = RedisHelper.GetRedisDatabase();
        }
        #endregion

        /// <summary>
        /// 添加单个值到集合中
        /// </summary>
        public bool SetAdd(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None)
        {
           return redisDatabase.SetAdd(key, value, flags);
        }

        /// <summary>
        /// 添加一组值到集合中
        /// </summary>
        public long SetAdd(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetAdd(key, values, flags);
        }

        /// <summary>
        ///  获取两个集合运算的结果
        /// </summary>
        /// <param name="operation">集合运算：Union 并集 Intersect交集 Difference 差集</param>
        /// <param name="first">第一个集合</param>
        /// <param name="second">第二个集合</param>
        /// <param name="flags">命令参数</param>
        /// <returns>两个集合运算(集合并，交，补)的结果</returns>
        public RedisValue[] SetCombine(SetOperation operation, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetCombine(operation, first, second, flags);
        }

        /// <summary>
        /// 获取指定集合，进行集合运算后的结果集
        /// </summary>
        /// <param name="operation">集合运算：Union 并集 Intersect交集 Difference 差集</param>
        /// <param name="keys">指定集合的一组key</param>
        /// <param name="flags">命令参数</param>
        /// <returns>指定的一组集合运算(集合并，交，补)的结果</returns>
        public RedisValue[] SetCombine(SetOperation operation, RedisKey[] keys, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetCombine(operation, keys, flags);
        }

        /// <summary>
        /// 此命令等于SetCombine，但不是返回结果集，而是将其存储在目的地中。
        /// 如果目的地已经存在，则将其覆盖。
        /// </summary>
        /// <param name="operation">集合运算：Union 并集 Intersect交集 Difference 差集</param>
        /// <param name="destination">目标集合</param>
        /// <param name="first">第一个集合</param>
        /// <param name="second">第二个集合</param>
        /// <param name="flags">命令参数</param>
        /// <returns>
        /// 结果集中的元素数目
        /// </returns>
        public long SetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, CommandFlags flags = CommandFlags.None)
        {
           return  redisDatabase.SetCombineAndStore(operation, destination, first, second, flags);
        }

        /// <summary>
        /// 此命令等于SetCombine，但不是返回结果集，而是将其存储在目的地中。
        /// 如果目的地已经存在，则将其覆盖。
        /// </summary>
        /// <param name="operation">集合运算：Union 并集 Intersect交集 Difference 差集</param>
        /// <param name="destination">目标集合</param>
        /// <param name="keys">参与集合运算的一组key</param>
        /// <param name="flags">命令参数</param>
        /// <returns>结果集中的元素数目</returns>
        public long SetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey[] keys, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetCombineAndStore(operation, destination, keys,flags);
        }

        /// <summary>
        /// 指定的值，在集合中是存在
        /// </summary>
        public bool SetContains(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetContains(key, value, flags);
        }

        /// <summary>
        /// 获取集合中元素的数量 
        /// </summary>
        public long SetLength(RedisKey key, CommandFlags flags = CommandFlags.None)
        {
           return redisDatabase.SetLength(key, flags);
        }

        /// <summary>
        /// 获取集合中所的元素
        /// </summary>
        public RedisValue[] SetMembers(RedisKey key, CommandFlags flags = CommandFlags.None)
        {
           return redisDatabase.SetMembers(key, flags);
        }

        /// <summary>
        /// 将 member 元素从 source 集合移动到 destination 集合
        /// SMOVE 是原子性操作：如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。
        /// 否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。
        /// 当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。
        /// 当 source 或 destination 不是集合类型时，返回一个错误。
        /// </summary>
        /// <param name="source">源集合</param>
        /// <param name="destination">目标集合</param>
        /// <param name="value">元素的值</param>
        /// <param name="flags">命令参数</param>
        /// <returns>
        /// 1如果元素被移动
        /// 0如果元素不是源成员，则不执行操作。
        /// </returns>
        public bool SetMove(RedisKey source, RedisKey destination, RedisValue value, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetMove(source, destination, value, flags);
        }

        /// <summary>
        /// 移除并返回集合中的一个随机元素
        /// </summary>
        public RedisValue SetPop(RedisKey key, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetPop(key, flags);
        }

        /// <summary>
        /// 获取集合中的一个随机元素
        /// </summary>
        public RedisValue SetRandomMember(RedisKey key, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetRandomMember(key, flags);
        }

        /// <summary>
        /// 随机获取集合中指定数量的元素
        /// </summary>
        public RedisValue[] SetRandomMembers(RedisKey key, long count, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetRandomMembers(key, count, flags);
        }

        /// <summary>
        /// 移除集合 key 中的一个 member 元素，不存在的 member 元素会被忽略
        /// </summary>
        public bool SetRemove(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetRemove(key, value, flags);
        }

        /// <summary>
        /// 移除集合 key 中多个 member 元素，不存在的 member 元素会被忽略
        /// </summary>
        public long SetRemove(RedisKey key, RedisValue[] values, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetRemove(key, values, flags);
        }

        /// <summary>
        /// 增量遍历集合
        /// 注意：通过光标恢复迭代，将原始枚举或枚举器转换为ISCANIN光标。
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="pattern">模式值</param>
        /// <param name="pageSize">页大小</param>
        /// <param name="cursor">cursor</param>
        /// <param name="pageOffset">页偏移量</param>
        /// <param name="flags">命令参数</param>
        /// <returns>
        ///  集合中所有元素
        /// </returns>
        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern = default(RedisValue), int pageSize = 10, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None)
        {
            return redisDatabase.SetScan(key, pattern, pageSize, cursor, pageOffset, flags);
        }

        /// <summary>
        /// 增量遍历集合
        /// 注意：通过光标恢复迭代，将原始枚举或枚举器转换为ISCANIN光标。
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="pattern">模式值</param>
        /// <param name="pageSize">页大小</param>
        /// <param name="flags">命令参数</param>
        /// <returns>
        /// 集合中所有元素
        /// </returns>
        public IEnumerable<RedisValue> SetScan(RedisKey key, RedisValue pattern, int pageSize, CommandFlags flags)
        {
            return redisDatabase.SetScan(key, pattern, pageSize, flags);
        }
    }
}