package com.yohoufo.user.cache;

import com.google.common.collect.Maps;
import com.yoho.core.redis.cluster.annotation.Redis;
import com.yoho.core.redis.cluster.operations.nosync.YHRedisTemplate;
import com.yoho.core.redis.cluster.operations.nosync.YHValueOperations;
import com.yoho.core.redis.cluster.operations.nosync.YHZSetOperations;
import com.yoho.core.redis.cluster.operations.serializer.RedisKeyBuilder;
import com.yohoufo.common.cache.CacheHelper;
import com.yohoufo.common.cache.CacheKeyEnum;
import com.yohoufo.common.utils.DateUtil;
import com.yohoufo.dal.user.model.UserAuthorizeInfo;
import com.yohoufo.dal.user.model.UserFavorite;
import com.yohoufo.dal.user.model.UserFavoriteSku;
import com.yohoufo.dal.user.model.ZhiMaCert;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Created by craig.qin on 2018/9/20.
 */
@Service
public class CacheService {
    private final Logger logger = LoggerFactory.getLogger(CacheService.class);
    @Redis("gwNoSyncRedis")
    YHZSetOperations yhZSetOperations;

    @Redis("gwNoSyncRedis")
    YHRedisTemplate yhRedisTemplate;

    @Redis("gwNoSyncRedis")
    YHValueOperations yhValueOperations;

    ///////  相关的key构造
    public static RedisKeyBuilder getProductFavoriteRedisKeyBuilder(Integer uid){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getCacheKey()).appendVar(uid);
    }

    public static RedisKeyBuilder getAuthorizeInfoRedisKeyBuilder(Integer uid){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.AUTHORIZE_INFO_KEY.getCacheKey()).appendVar(uid);
    }


    public static RedisKeyBuilder getZhiMaCertRedisKeyBuilder(Integer uid){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.ZHI_MA_CERT_KEY.getCacheKey()).appendVar(uid);
    }

    private static RedisKeyBuilder getPhotoCheckRedisKeyBuilder(String dayStr,Integer uid){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.PHOTO_CHECK_COUNT_KEY.getCacheKey()).appendVarWithMH(dayStr).appendVar(uid);
    }

    ///////  相关的key构造
    public static RedisKeyBuilder getSkuFavoriteRedisKeyBuilder(Integer uid){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getCacheKey()).appendVar(uid);
    }

    ///////  相关的key构造
    public static RedisKeyBuilder getSkuFavoriteFlagRedisKeyBuilder(Integer uid, Integer storageId){
        return RedisKeyBuilder.newInstance().appendFixed(CacheKeyEnum.USER_SKU_FAVORITE_FLAG_KEY.getCacheKey()).appendVarWithMH(uid).appendVar(storageId);
    }

    /**************************************************************************
     *     商品收藏相关
     *************************************************************************/

    /**
     * 查询某用户是否已收藏某商品 (如果存在则将失效时间延期)
     * @param productId
     * @param uid
     * @return
     */
    public boolean isExistUserProductFavoriteByProductId(Integer uid, Integer productId, boolean isExtendExpire) {
        if(isExtendExpire){
            try{
                yhRedisTemplate.longExpire(getProductFavoriteRedisKeyBuilder(uid), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getDefaultExpireTime(), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getTimeUnit());
            }catch(Exception e){
                logger.warn("yhRedisTemplate.longExpire failed!!! e is: {}", e);
            }
        }
        try{
            Double result = yhZSetOperations.score(getProductFavoriteRedisKeyBuilder(uid), "" + productId);
            return result == null ? false : true;
        }catch(Exception e){
            logger.warn("yhZSetOperations.score failed!!! e is: {}", e);
        }
        return false;
    }


    /**
     * 是否存在该key (如果存在则将失效时间延期)
     * @param userId
     * @return
     */
    public boolean hasUserFavoriteProductKey(Integer userId, boolean isExtendExpire) {
        if(isExtendExpire){
            try{
                yhRedisTemplate.longExpire(getProductFavoriteRedisKeyBuilder(userId), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getDefaultExpireTime(), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getTimeUnit());
            }catch(Exception e){
                logger.warn("yhRedisTemplate.longExpire failed!!! e is: {}", e);
            }
        }

        return yhRedisTemplate.hasKey(getProductFavoriteRedisKeyBuilder(userId));
    }

    /**
     * 批量收藏
     * @param favoriteList
     * @param uid
     * @return
     */
    public void batchSetFavoriteProduct(Integer uid, List<UserFavorite> favoriteList) {

        if (CollectionUtils.isNotEmpty(favoriteList)) {
            Set<ZSetOperations.TypedTuple<String>> typedTuples = new HashSet<ZSetOperations.TypedTuple<String>>();
            for (UserFavorite item : favoriteList) {
                ZSetOperations.TypedTuple<String> typedTuple = new DefaultTypedTuple("" + item.getProductId(),Double.valueOf("" + item.getCreateTime()));
                typedTuples.add(typedTuple);
            }

            try{
                yhZSetOperations.add(getProductFavoriteRedisKeyBuilder(uid), typedTuples);
            }catch(Exception e){
                logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
            }
        }

        //增加一个不存在的id，防止大量的key为空的情况
        try{
            yhZSetOperations.add(getProductFavoriteRedisKeyBuilder(uid), "0",0);
            yhRedisTemplate.longExpire(getProductFavoriteRedisKeyBuilder(uid), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getDefaultExpireTime(), CacheKeyEnum.USER_PRODUCT_FAVORITE_ZSET_KEY.getTimeUnit());
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }

    /**
     * 增加一条收藏数据
     * @param userId
     * @return
     */
    public void addFavoriteProductKey(Integer userId,Integer productId,long now) {
        try{
            yhZSetOperations.add(getProductFavoriteRedisKeyBuilder(userId), "" + productId, now);
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }

    public void removeUserFavoriteProduct(Integer uid, Integer productId) {
        try{
            yhZSetOperations.remove(getProductFavoriteRedisKeyBuilder(uid), "" + productId);
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }


    public long queryUserProductFavoriteCount(Integer uid) {
        try{
            Long count = yhZSetOperations.size(getProductFavoriteRedisKeyBuilder(uid));
            return null == count ? 0 : count;
        }catch(Exception e){
            logger.warn("yhZSetOperations.size failed!!! e is: {}", e);
        }
        return 0;
    }

    public long queryUserSkuFavoriteCount(Integer uid) {
        try{
            Long count = yhZSetOperations.size(getSkuFavoriteRedisKeyBuilder(uid));
            return null == count ? 0 : count;
        }catch(Exception e){
            logger.warn("yhZSetOperations.size failed!!! e is: {}", e);
        }
        return 0;
    }

    /**
     *获取用户收藏列表id
     */
    public Set<String> queryAllProductFavoriteByUid(Integer uid, int startIndex, int endIndex) {
        Set<String> set = yhZSetOperations.reverseRange(getProductFavoriteRedisKeyBuilder(uid), startIndex, endIndex);
        return set;
    }

    /**************************************************************************
     *     实名认证相关
     *************************************************************************/
    public UserAuthorizeInfo getUserAuthorizeInfo(Integer uid){
        return get(getAuthorizeInfoRedisKeyBuilder(uid),UserAuthorizeInfo.class);
    }

    public void setUserAuthorizeInfo(UserAuthorizeInfo authorizeInfo){
        set(getAuthorizeInfoRedisKeyBuilder(authorizeInfo.getUid()),authorizeInfo,CacheKeyEnum.AUTHORIZE_INFO_KEY.getDefaultExpireTime(),CacheKeyEnum.AUTHORIZE_INFO_KEY.getTimeUnit());
    }

    public void delUserAuthorizeInfo(Integer uid){
        yhRedisTemplate.delete(getAuthorizeInfoRedisKeyBuilder(uid));
    }


    /**************************************************************************
     *     芝麻认证相关
     *************************************************************************/
    public ZhiMaCert getZhiMaCert(Integer uid){
        return get(getZhiMaCertRedisKeyBuilder(uid),ZhiMaCert.class);
    }

    public void setZhiMaCert(ZhiMaCert zhiMaCert){
        set(getZhiMaCertRedisKeyBuilder(zhiMaCert.getUid()),zhiMaCert,CacheKeyEnum.ZHI_MA_CERT_KEY.getDefaultExpireTime(),CacheKeyEnum.ZHI_MA_CERT_KEY.getTimeUnit());
    }

    public void delZhiMaCert(Integer uid){
        yhRedisTemplate.delete(getZhiMaCertRedisKeyBuilder(uid));
    }

    public Long getPhotoCheckCount(String dayStr,Integer uid){
        RedisKeyBuilder cacheKey = getPhotoCheckRedisKeyBuilder(dayStr,uid);
        Long count = get(cacheKey,Long.class);
        return count;
    }

    public Long incrementPhotoCheckCount(String dayStr,Integer uid) {
        RedisKeyBuilder cacheKey = getPhotoCheckRedisKeyBuilder(dayStr,uid);
        return this.incrementWithExpire(cacheKey,  1L ,  CacheKeyEnum.PHOTO_CHECK_COUNT_KEY.getDefaultExpireTime(),  CacheKeyEnum.PHOTO_CHECK_COUNT_KEY.getTimeUnit()) ;
    }


    /**************************************************************************
     *     通用
     *************************************************************************/

    /**
     * 取值
     *
     * @param cacheKey
     * @param clazz
     */
    public <T> T get(RedisKeyBuilder cacheKey, Class<T> clazz) {
        logger.debug("Enter get valueOperation redis value.key is {}", cacheKey);
        try {
            String value = yhValueOperations.get(cacheKey);
            return CacheHelper.string2Value(value, clazz);
        } catch (Exception e) {
            logger.warn("Redis exception. value redis get,key {}, error msg is {}", cacheKey, e);
        }
        return null;
    }


    /**
     * 设置值
     *
     * @param cacheKey
     * @param value
     * @param timeout
     * @param unit
     * @param <T>
     */
    public <T> void set(RedisKeyBuilder cacheKey, T value, long timeout, TimeUnit unit) {
        logger.debug("Enter set valueOperation redis value.key is {},value is {}", cacheKey, value);
        try {
            String v = CacheHelper.value2String(value);
            yhValueOperations.set(cacheKey, v, timeout, unit);
        } catch (Exception e) {
            logger.warn("Redis exception. value redis set,key {},value is {}, error msg is {}", cacheKey, value, e);
        }
    }



    public Long incrementWithExpire(RedisKeyBuilder cacheKey, long delta , long timeout, TimeUnit unit) {
        logger.debug("Enter increment valueOperation redis.key is {},delta is {}", cacheKey, delta);
        try {
            Long num =  yhValueOperations.increment(cacheKey, delta);
            yhRedisTemplate.longExpire(cacheKey, timeout, unit);
            return num;
        } catch (Exception e) {
            try{
                yhRedisTemplate.longExpire(cacheKey, timeout, unit);
            }catch (Exception e1){
                logger.error("RedisValueHelper expire redis again error. with key={}", cacheKey, e1);
            }
            logger.warn("Redis exception. increment fail,key {},delta is {}, error msg is {}", cacheKey, delta, e);
        }
        return 0L;
    }

    public boolean hasUserFavoriteSkuKey(Integer userId, boolean isExtendExpire) {
        if(isExtendExpire){
            try{
                yhRedisTemplate.longExpire(getSkuFavoriteRedisKeyBuilder(userId),
                        CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getDefaultExpireTime(),
                        CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getTimeUnit());
            }catch(Exception e){
                logger.warn("yhRedisTemplate.longExpire failed!!! e is: {}", e);
            }
        }
        return yhRedisTemplate.hasKey(getSkuFavoriteRedisKeyBuilder(userId));
    }

    public void batchSetFavoriteSku(Integer uid, List<UserFavoriteSku> favoriteList) {
        if (CollectionUtils.isNotEmpty(favoriteList)) {
            Set<ZSetOperations.TypedTuple<String>> typedTuples = new HashSet<ZSetOperations.TypedTuple<String>>();
            for (UserFavoriteSku item : favoriteList) {
                ZSetOperations.TypedTuple<String> typedTuple = new DefaultTypedTuple(getSkuFacoriteValue(item.getStorageId(), item.getPrice()),
                        Double.valueOf(item.getCreateTime()));
                typedTuples.add(typedTuple);
            }
            try{
                yhZSetOperations.add(getSkuFavoriteRedisKeyBuilder(uid), typedTuples);
            }catch(Exception e){
                logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
            }
        }

        try{  //增加一个不存在的id，防止大量的key为空的情况
            yhZSetOperations.add(getSkuFavoriteRedisKeyBuilder(uid), "0", 0);
            yhRedisTemplate.longExpire(getSkuFavoriteRedisKeyBuilder(uid), CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getDefaultExpireTime(),
                    CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getTimeUnit());
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }

    public void addFavoriteSkuKey(Integer userId, Integer storageId, BigDecimal price, long now) {
        try{
            yhZSetOperations.add(getSkuFavoriteRedisKeyBuilder(userId), getSkuFacoriteValue(storageId, price), now);
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }

    /**************************************************************************
     *     商品收藏相关
     *************************************************************************/

    /**
     * 查询某用户是否已收藏某商品 (如果存在则将失效时间延期)
     * @param productId
     * @param uid
     * @return
     */
    public boolean isExistUserSkuFavoriteByProductId(Integer uid, Integer storageId, boolean isExtendExpire) {
        if(isExtendExpire){
            try{
                yhRedisTemplate.longExpire(getSkuFavoriteRedisKeyBuilder(uid),
                        CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getDefaultExpireTime(), CacheKeyEnum.USER_SKU_FAVORITE_ZSET_KEY.getTimeUnit());
            }catch(Exception e){
                logger.warn("yhRedisTemplate.isExistUserSkuFavoriteByProductId failed!!! e is: {}", e);
            }
        }
        try{
            Map<Integer, BigDecimal> skuFavoriteMap = getSkuFavoriteMap(uid);
            return skuFavoriteMap.containsKey(storageId);
        }catch(Exception e){
            logger.warn("yhZSetOperations.getSkuFavoriteMap failed!!! e is: {}", e);
        }
        return false;
    }

    /**
     * 查询uid所有的收藏记录
     * @param uid
     * @return
     */
    public Map<Integer, BigDecimal> getSkuFavoriteMap(Integer uid) {
        Set<String> range = yhZSetOperations.range(getSkuFavoriteRedisKeyBuilder(uid), 0, -1);
        if (CollectionUtils.isEmpty(range)) {
            return Maps.newHashMap();
        }
        Map<Integer, BigDecimal> result = new HashMap<>();
        range.stream().forEach(item -> {
            if (!"0".equals(item)) {
                String[] split = item.split(":");
                result.put(Integer.valueOf(split[0]), new BigDecimal(split[1]));
            }
        });
        return result;
    }

    /**
     * 查询某用户是否已收藏某商品的sku
     * @param productId
     * @param uid
     * @return
     */
    public boolean isExistUserSkuFavoriteByStorageIds(Integer uid, List<Integer> storageIds, boolean isExtendExpire) {
        try{

            Map<Integer, BigDecimal> skuFavoriteMap = getSkuFavoriteMap(uid);
            boolean result = false;
            for (Integer item : storageIds) {
                if (skuFavoriteMap.containsKey(item)) {
                    return true;
                }
            }
            return result;
        }catch(Exception e){
            logger.warn("yhZSetOperations.range failed!!! e is: {}", e);
        }
        return false;
    }

    public void removeUserFavoriteSku(Integer uid, Integer storageId) {
        Map<Integer, BigDecimal> skuFavoriteMap = getSkuFavoriteMap(uid);
        BigDecimal setKey = skuFavoriteMap.get(storageId);
        if (null == setKey) {
            return;
        }
        try{
            yhZSetOperations.remove(getSkuFavoriteRedisKeyBuilder(uid), getSkuFacoriteValue(storageId, setKey));
        }catch(Exception e){
            logger.warn("yhZSetOperations.add failed!!! e is: {}", e);
        }
    }


    /**
     *获取用户收藏列表id
     */
    public Set<String> queryAllSkuFavoriteByUid(Integer uid, int startIndex, int endIndex) {
        Set<String> set = yhZSetOperations.reverseRange(getSkuFavoriteRedisKeyBuilder(uid), startIndex, endIndex);
        return set;
    }


    public boolean setNxKey(Integer userId, Integer storageId) {
        Boolean aBoolean = yhValueOperations.setIfAbsent(getSkuFavoriteFlagRedisKeyBuilder(userId, storageId), String.valueOf(DateUtil.getCurrentTimeSecond()));
        if (aBoolean) {
            yhRedisTemplate.longExpire(getSkuFavoriteFlagRedisKeyBuilder(userId, storageId),
                    CacheKeyEnum.USER_SKU_FAVORITE_FLAG_KEY.getDefaultExpireTime(),
                    CacheKeyEnum.USER_SKU_FAVORITE_FLAG_KEY.getTimeUnit());
        }

        return aBoolean;
    }


    public void delUserSkuFavorate(Integer userId, Integer storageId){
        if (null != storageId) {
            yhRedisTemplate.delete(getSkuFavoriteFlagRedisKeyBuilder(userId, storageId));
        }
        yhRedisTemplate.delete(getSkuFavoriteRedisKeyBuilder(userId));
    }

    private String getSkuFacoriteValue(Integer storageId, BigDecimal price) {
        StringBuilder sb = new StringBuilder();
        sb.append(storageId).append(":").append(price);
        return sb.toString();
    }
}