using Znyc.CloudCar.Caching;
using Znyc.CloudCar.Configuration;
using Znyc.CloudCar.IServices.CaChe;
using Znyc.CloudCar.Model.Dtos.Banner;
using Znyc.CloudCar.Model.Dtos.CardIntro;
using Znyc.CloudCar.Model.Dtos.Certification;
using Znyc.CloudCar.Model.Dtos.Dictionary;
using Znyc.CloudCar.Model.Dtos.Recharge;
using Znyc.CloudCar.Model.Dtos.User;
using Znyc.CloudCar.Model.Entities;

namespace Znyc.CloudCar.Services.Cache
{
    public class CacheService : ICacheService
    {
        private readonly IRedisOperationRepository _redisCache;

        public CacheService(
            IRedisOperationRepository redisCache)
        {
            _redisCache = redisCache;
        }

        #region Dictionary
        /// <summary>
        ///     设置数据字典缓存
        /// </summary>
        /// <param name="output"></param>
        /// <returns></returns>
        public async Task SetDictionaryAsync(List<DictionaryOutput> output)
        {
            await _redisCache.SetAsync(GlobalCacheKeyVars.DictionaryList, output);

        }

        /// <summary>
        ///     获取数据字典缓存
        /// </summary>
        /// <returns></returns>
        public async Task<List<DictionaryOutput>> GetDictionaryAsync()
        {

            return await _redisCache.GetAsync<List<DictionaryOutput>>(GlobalCacheKeyVars.DictionaryList);

        }

        /// <summary>
        ///     删除数据字典缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemoveDictionaryAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.DictionaryList);
        }
        #endregion

        #region User

        /// <summary>
        ///     设置用户缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public async Task SetUserAsync(long userId, UserOutput user)
        {
            string key = string.Format(GlobalCacheKeyVars.User, userId);
            await _redisCache.SetAsync(key, user);
        }

        /// <summary>
        ///     删除用户缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task RemoveUserAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.User, userId);
            await _redisCache.DelAsync(key);
        }

        /// <summary>
        ///     获取用户缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<UserOutput> GetUserAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.User, userId);
            return await _redisCache.GetAsync<UserOutput>(key);
        }

        #endregion User

        #region PageView

        /// <summary>
        ///     同步浏览量缓存
        /// </summary>
        /// <param name="scoreMembers"></param>
        /// <returns></returns>
        public async Task<bool> SetPageViewAsync(string member, double score)
        {
            return await _redisCache.ZAddAsync(GlobalCacheKeyVars.PageView, member, score);
        }

        /// <summary>
        ///     浏览量自增
        /// </summary>
        /// <param name="productId"></param>
        /// <returns></returns>
        public async Task<double> SetIncrPageViewAsync(long productId)
        {
            return await _redisCache.ZIncrByAsync(GlobalCacheKeyVars.PageView, productId.ToString());
        }

        /// <summary>
        ///     删除浏览量缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemovePageViewAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.PageView);
        }

        /// <summary>
        ///     获取浏览量缓存
        /// </summary>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<IDictionary<string, double>> GetPageViewAsync()
        {
            return await _redisCache.ZRevRangeWithScoresAsync(GlobalCacheKeyVars.PageView);
        }

        /// <summary>
        ///     获取浏览量总条数缓存
        /// </summary>
        /// <returns></returns>
        public async Task<long> GetPageViewCountAsync()
        {
            return await _redisCache.ZCardAsync(GlobalCacheKeyVars.PageView);
        }

        #endregion PageView

        #region Browse
        /// <summary>
        ///     获取浏览记录总条数缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<long> GetBrowseCountAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.BrowseList, userId);
            return await _redisCache.ZCardAsync(key);
        }

        /// <summary>
        ///     设置浏览记录缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="member"></param>
        /// <param name="score"></param>
        /// <returns></returns>
        public async Task<bool> SetBrowseAsync(long userId, string member, double score)
        {
            string key = string.Format(GlobalCacheKeyVars.BrowseList, userId);
            return await _redisCache.ZAddAsync(key, member, score);
        }

        /// <summary>
        /// 获取浏览记录缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        public async Task<IDictionary<string, double>> GetBrowseAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.BrowseList, userId);
            return await _redisCache.ZRevRangeWithScoresAsync(key);
        }
        #endregion

        #region 实名认证

        /// <summary>
        ///     设置实名认证缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="certificationOutput"></param>
        /// <returns></returns>
        public async Task SetCertificationAsync(long userId, CertificationOutput certificationOutput)
        {
            string key = string.Format(GlobalCacheKeyVars.Certification, userId);
            await _redisCache.SetAsync(key, certificationOutput);

        }

        /// <summary>
        ///     删除实名认证缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task RemoveCertificationAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.Certification, userId);
            await _redisCache.DelAsync(key);

        }

        /// <summary>
        ///     获取实名认证缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<CertificationOutput> GetCertificationAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.Certification, userId);
            return await _redisCache.GetAsync<CertificationOutput>(key);

        }

        #endregion Certification

        #region UnreadMessage

        /// <summary>
        ///     同步未读信息缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="list"></param>
        /// <returns></returns>
        public async Task SetUnreadMessageAsync(long userId, IDictionary<string, object> list)
        {
            string key = string.Format(GlobalCacheKeyVars.UnreadMessage, userId);
            foreach (var item in list)
            {
                await _redisCache.HSetAsync(key, item.Key, item.Value);
            }
        }

        /// <summary>
        ///     修改未读信息缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="filed"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task UpdateUnreadMessageAsync(long userId, string filed, string value)
        {
            string key = string.Format(GlobalCacheKeyVars.UnreadMessage, userId);
            await _redisCache.HSetAsync(key, filed, value);
        }

        /// <summary>
        ///     删除未读信息缓存
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task RemoveUnreadMessageAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.UnreadMessage, userId);
            await _redisCache.DelAsync(key);
        }

        /// <summary>
        ///     获取未读信息缓存
        /// </summary>
        /// <returns></returns>
        public async Task<IDictionary<string, object>> GetUnreadMessageAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.UnreadMessage, userId);
            return await _redisCache.HGetAllAsync(key);
        }

        #endregion UnreadMessage

        #region  用户注册信息滚动提示

        /// <summary>
        ///     设置注册用户list
        /// </summary>
        /// <param name="scoreMembers"></param>
        /// <returns></returns>
        public async Task SetRegistUserListAsync(string member, double score)
        {
            await _redisCache.ZAddAsync(GlobalCacheKeyVars.RegisteredUserlist, member, score);
        }

        /// <summary>
        ///     获取注册用户list
        /// </summary>
        /// <returns></returns>
        public async Task<List<string>> GetRegistUserListAsync(long start, long stop)
        {
            return await _redisCache.ZRemRangeByRankAsync(GlobalCacheKeyVars.RegisteredUserlist, start, stop);
        }
        #endregion

        #region Banner

        /// <summary>
        ///     设置广告缓存
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public async Task SetBannerListAsync(List<BannerListOutput> list)
        {
            await _redisCache.SetAsync(GlobalCacheKeyVars.BannerList, list, TimeSpan.FromDays(31));
        }

        /// <summary>
        ///     获取广告缓存
        /// </summary>
        /// <returns></returns>
        public async Task<List<BannerListOutput>> GetBannerListAsync()
        {
            return await _redisCache.GetAsync<List<BannerListOutput>>(GlobalCacheKeyVars.BannerList);
        }

        /// <summary>
        ///     删除广告缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemoveBannerListAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.BannerList);
        }
        #endregion

        #region Recharge充值活动

        /// <summary>
        ///     设置充值活动缓存
        /// </summary>
        /// <param name="output"></param>
        /// <returns></returns>
        public async Task SetRechargeAsync(RechargeOutput output)
        {
            await _redisCache.SetAsync(GlobalCacheKeyVars.RechargeList, output);
        }

        /// <summary>
        ///     获取充值活动缓存
        /// </summary>
        /// <returns></returns>
        public async Task<RechargeOutput> GetRechargeAsync()
        {
            return await _redisCache.GetAsync<RechargeOutput>(GlobalCacheKeyVars.RechargeList);
        }

        /// <summary>
        ///     删除充值活动缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemoveRechargeAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.RechargeList);

        }

        #endregion ProductInfo

        #region 优惠卡信息

        /// <summary>
        ///     设置优惠卡信息缓存
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public async Task SetCardIntroListAsync(List<CardIntroOutput> list)
        {
            await _redisCache.SetAsync(GlobalCacheKeyVars.CardIntroList, list, TimeSpan.FromDays(31));
        }

        /// <summary>
        ///     获取优惠卡信息缓存
        /// </summary>
        /// <returns></returns>
        public async Task<List<CardIntroOutput>> GetCardIntroListAsync()
        {
            return await _redisCache.GetAsync<List<CardIntroOutput>>(GlobalCacheKeyVars.CardIntroList);
        }

        /// <summary>
        ///     删除优惠卡信息缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemoveCardIntroListAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.CardIntroList);
        }
        #endregion


        #region 用户修改次数

        /// <summary>
        ///     同步用户修改次数缓存
        /// </summary>
        /// <param name="scoreMembers"></param>
        /// <returns></returns>
        public async Task<bool> SetUserUpdateCountAsync(string member, double score)
        {
            return await _redisCache.ZAddAsync(GlobalCacheKeyVars.UserUpdateCount, member, score);
        }

        /// <summary>
        ///     用户修改次数自增
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<double> SetIncrUserUpdateCountAsync(long userId)
        {
            return await _redisCache.ZIncrByAsync(GlobalCacheKeyVars.UserUpdateCount, userId.ToString());
        }

        /// <summary>
        ///     删除用户修改次数缓存
        /// </summary>
        /// <returns></returns>
        public async Task RemoveUserUpdateCountAsync()
        {
            await _redisCache.DelAsync(GlobalCacheKeyVars.UserUpdateCount);
        }

        /// <summary>
        ///     获取用户修改次数缓存
        /// </summary>
        /// <returns></returns>
        public async Task<IDictionary<string, double>> GetUserUpdateCountAsync()
        {
            return await _redisCache.ZRevRangeWithScoresAsync(GlobalCacheKeyVars.UserUpdateCount);
        }
        #endregion UserUpdateCount


        #region   设备管理

        public async Task SetEquipmentAsync(EquipmentEntity equipment, long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.UserEquipment, userId);
            await _redisCache.SetAsync(key, equipment);
        }


        public async Task<EquipmentEntity> GetEquipmentAsync(long userId)
        {
            string key = string.Format(GlobalCacheKeyVars.UserEquipment, userId);
            return await _redisCache.GetAsync<EquipmentEntity>(key);
        }

        #endregion
    }
}