using ServiceStack.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace CarLocalMeter
{
    public class RedisListService
    {
        private RedisClient _client;

        public RedisListService()
        {
            _client = new RedisClient(AppConfigCache.redisIp, AppConfigCache.redisPort);
        }

        #region
        #region Queue队列（先进先出）

        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="value">入队的值</param>
        /// <param name="timeout">过期时间 秒</param>
        public void EnqueueItemOnList(string listId, string value, int timeout = 0)
        {
            _client.EnqueueItemOnList(listId, value);
            if (timeout > 0)
                _client.ExpireEntryIn(listId, TimeSpan.FromSeconds(timeout));
            //也可以设置某个时间过去，比如下面的方式
            //_client.ExpireEntryAt(listId,DateTime.Now.AddDays(7));
        }

        /// <summary>
        /// 出队
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <returns>出队的值</returns>
        public string DequeueItemFromList(string listId)
        {
            return _client.DequeueItemFromList(listId);
        }

        /// <summary>
        /// 出队（阻塞）
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="timeOut">阻塞时间（超时时间）</param>
        /// <returns>出队的值</returns>
        public string BlockingDequeueItemFromList(string listId, TimeSpan? timeOut)
        {
            return _client.BlockingDequeueItemFromList(listId, timeOut);
        }

        /// <summary>
        /// 从多个list中出队（阻塞）
        /// </summary>
        /// <param name="listIds">集合Id</param>
        /// <param name="timeOut">阻塞时间（超时时间）</param>
        /// <returns>返回出队的 listId & Item</returns>
        public ItemRef BlockingDequeueItemFromLists(string[] listIds, TimeSpan? timeOut)
        {
            return _client.BlockingDequeueItemFromLists(listIds, timeOut);
        }

        #endregion Queue队列（先进先出）

        #region Stack栈（后进先出）

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="value">入栈的值</param>
        public void PushItemToList(string listId, string value)
        {
            _client.PushItemToList(listId, value);
        }

        /// <summary>
        /// 入栈，并设置过期时间
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="value">入栈的值</param>
        /// <param name="expireAt">过期时间</param>
        public void PushItemToList(string listId, string value, DateTime expireAt)
        {
            _client.PushItemToList(listId, value);
            _client.ExpireEntryAt(listId, expireAt);
        }

        /// <summary>
        /// 入栈，并设置过期时间
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="value">入栈的值</param>
        /// <param name="expireIn">过期时间</param>
        public void PushItemToList(string listId, string value, TimeSpan expireIn)
        {
            _client.PushItemToList(listId, value);
            _client.ExpireEntryIn(listId, expireIn);
        }

        /// <summary>
        /// 出栈
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <returns>出栈的值</returns>
        public string PopItemFromList(string listId)
        {
            return _client.PopItemFromList(listId);
        }

        /// <summary>
        /// 出栈（阻塞）
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="timeOut">阻塞时间（超时时间）</param>
        /// <returns>出栈的值</returns>
        public string BlockingPopItemFromList(string listId, TimeSpan? timeOut)
        {
            return _client.BlockingPopItemFromList(listId, timeOut);
        }

        /// <summary>
        /// 从多个list中出栈一个值（阻塞）
        /// </summary>
        /// <param name="listIds">集合Id</param>
        /// <param name="timeOut">阻塞时间（超时时间）</param>
        /// <returns>返回出栈的 listId & Item</returns>
        public ItemRef BlockingPopItemFromLists(string[] listIds, TimeSpan? timeOut)
        {
            return _client.BlockingPopItemFromLists(listIds, timeOut);
        }

        /// <summary>
        /// 从fromListId集合出栈并入栈到toListId集合
        /// </summary>
        /// <param name="fromListId">出栈集合Id</param>
        /// <param name="toListId">入栈集合Id</param>
        /// <returns>返回移动的值</returns>
        public string PopAndPushItemBetweenLists(string fromListId, string toListId)
        {
            return _client.PopAndPushItemBetweenLists(fromListId, toListId);
        }

        /// <summary>
        /// 从fromListId集合出栈并入栈到toListId集合（阻塞）
        /// </summary>
        /// <param name="fromListId">出栈集合Id</param>
        /// <param name="toListId">入栈集合Id</param>
        /// <param name="timeOut">阻塞时间（超时时间）</param>
        /// <returns>返回移动的值</returns>
        public string BlockingPopAndPushItemBetweenLists(string fromListId, string toListId, TimeSpan? timeOut)
        {
            return _client.BlockingPopAndPushItemBetweenLists(fromListId, toListId, timeOut);
        }

        #endregion Stack栈（后进先出）

        #region 赋值

        /// <summary>
        /// 向list头部添加value值
        /// </summary>
        public void PrependItemToList(string listId, string value)
        {
            _client.PrependItemToList(listId, value);
        }

        /// <summary>
        /// 向list头部添加value值，并设置过期时间
        /// </summary>    
        public void PrependItemToList(string listId, string value, DateTime expireAt)
        {
            _client.PrependItemToList(listId, value);
            _client.ExpireEntryAt(listId, expireAt);
        }

        /// <summary>
        /// 向list头部添加value值，并设置过期时间
        /// </summary>        
        public void PrependItemToList(string listId, string value, TimeSpan expireIn)
        {
            _client.PrependItemToList(listId, value);
            _client.ExpireEntryIn(listId, expireIn);
        }

        /// <summary>
        /// 向list中添加value值
        /// </summary>     
        public void AddItemToList(string listId, string value)
        {
            _client.AddItemToList(listId, value);
        }

        /// <summary>
        /// 向list中添加value值，并设置过期时间
        /// </summary>  
        public void AddItemToList(string listId, string value, DateTime expireAt)
        {
            _client.AddItemToList(listId, value);
            _client.ExpireEntryAt(listId, expireAt);
        }

        /// <summary>
        /// 向list中添加value值，并设置过期时间
        /// </summary>  
        public void AddItemToList(string listId, string value, TimeSpan expireIn)
        {
            _client.AddItemToList(listId, value);
            _client.ExpireEntryIn(listId, expireIn);
        }

        /// <summary>
        /// 向list中添加多个value值
        /// </summary>  
        public void AddRangeToList(string listId, List<string> values)
        {
            _client.AddRangeToList(listId, values);
        }

        /// <summary>
        /// 向list中添加多个value值，并设置过期时间
        /// </summary>  
        public void AddRangeToList(string listId, List<string> values, DateTime expireAt)
        {
            _client.AddRangeToList(listId, values);
            _client.ExpireEntryAt(listId, expireAt);
        }

        /// <summary>
        /// 向list中添加多个value值，并设置过期时间
        /// </summary>  
        public void AddRangeToList(string listId, List<string> values, TimeSpan expireIn)
        {
            _client.AddRangeToList(listId, values);
            _client.ExpireEntryIn(listId, expireIn);
        }

        #endregion 赋值

        #region 获取值

        /// <summary>
        /// 获取指定list中包含的数据数量
        /// </summary>  
        public long GetListCount(string listId)
        {
            return _client.GetListCount(listId);
        }

        /// <summary>
        /// 获取指定list中包含的所有数据集合
        /// </summary>  
        public List<string> GetAllItemsFromList(string listId)
        {
            return _client.GetAllItemsFromList(listId);
        }

        /// <summary>
        /// 获取指定list中下标从startingFrom到endingAt的值集合
        /// </summary>  
        public List<string> GetRangeFromList(string listId, int startingFrom, int endingAt)
        {
            return _client.GetRangeFromList(listId, startingFrom, endingAt);
        }

        #endregion 获取值

        #region 删除

        /// <summary>
        /// 移除指定list中，listId/value，与参数相同的值，并返回移除的数量
        /// </summary>  
        public long RemoveItemFromList(string listId, string value)
        {
            return _client.RemoveItemFromList(listId, value);
        }

        /// <summary>
        /// 从指定list的尾部移除一个数据，并返回移除的数据
        /// </summary>  
        public string RemoveEndFromList(string listId)
        {
            return _client.RemoveEndFromList(listId);
        }

        /// <summary>
        /// 从指定list的头部移除一个数据，并返回移除的数据
        /// </summary>  
        public string RemoveStartFromList(string listId)
        {
            return _client.RemoveStartFromList(listId);
        }

        #endregion 删除

        #region 其它

        /// <summary>
        /// 清理数据，保持list长度
        /// </summary>
        /// <param name="listId">集合Id</param>
        /// <param name="keepStartingFrom">保留起点</param>
        /// <param name="keepEndingAt">保留终点</param>
        public void TrimList(string listId, int keepStartingFrom, int keepEndingAt)
        {
            _client.TrimList(listId, keepStartingFrom, keepEndingAt);
        }

        #endregion 其它

        #region 发布订阅

        /// <summary>
        /// 发布
        /// </summary>
        /// <param name="channel">频道</param>
        /// <param name="message">消息</param>
        public void Publish(string channel, string message)
        {
            _client.PublishMessage(channel, message);
        }

        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="channel">频道</param>
        /// <param name="actionOnMessage"></param>
        public void Subscribe(string channel, Action<string, string, IRedisSubscription> actionOnMessage)
        {
            var subscription = _client.CreateSubscription();
            subscription.OnSubscribe = c =>
            {
                Console.WriteLine($"订阅频道{c}");
                Console.WriteLine();
            };
            //取消订阅
            subscription.OnUnSubscribe = c =>
            {
                Console.WriteLine($"取消订阅 {c}");
                Console.WriteLine();
            };
            subscription.OnMessage += (c, s) =>
            {
                actionOnMessage(c, s, subscription);
            };
            Console.WriteLine($"开始启动监听 {channel}");
            subscription.SubscribeToChannels(channel); //blocking
        }

        /// <summary>
        /// 取消订阅
        /// </summary>
        /// <param name="channel">频道</param>
        public void UnSubscribeFromChannels(string channel)
        {
            var subscription = _client.CreateSubscription();
            subscription.UnSubscribeFromChannels(channel);
        }

        #endregion 发布订阅
        #endregion
    }
}