package com.ruoyi.common.third.cache;

import org.springframework.cache.Cache;
import org.springframework.lang.Nullable;
import org.springframework.util.StringUtils;

import java.time.Duration;
import java.util.List;

public class CacheUtil extends AbstractCacheOperator {
	
    /**
     * 放入的操作
     * @param
     * @desc
     * */
    /**
     * 放入缓存，如果缓存中有，覆盖掉
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * @param value 值
     * **/
    public static void put(String cacheName,Object key, @Nullable Object value) {
        Long keyExpireTime = getCache(cacheName).getKeyExpireTime(key);
        if (StringUtils.isEmpty(keyExpireTime)) {
            getCache(cacheName).put(key,value, Duration.ZERO);
        }else {
            getCache(cacheName).put(key,value, keyExpireTime);
        }
    }

    /**
     * 放入缓存，如果缓存中有，覆盖掉
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * @param value 值
     * @param seconds 有效期单位秒
     * **/
    public static void put(String cacheName,Object key, Object value, long seconds){
        getCache(cacheName).put(key,value,seconds);
    }
    /**
     * 放入缓存，存在返回之前的值，不存在放入缓存并且返回值
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * **/
    public static <T> T putIfAbsent(String cacheName, Object key, @Nullable T value) {
        Cache.ValueWrapper valueWrapper = getCache(cacheName).putIfAbsent(key, value);
        if (valueWrapper == null) {
            return value;
        }
        return (T) valueWrapper.get();
    }
    /**
     * 放入缓存，存在返回之前的值，不存在放入缓存并且返回值
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * @param seconds 有效期单位秒
     * **/
    public static <T> T putIfAbsent(String cacheName,Object key, @Nullable T value, long seconds) {
        Cache.ValueWrapper valueWrapper = getCache(cacheName).putIfAbsent(key, value, seconds);
        if (valueWrapper == null) {
            return value;
        }
        return (T) valueWrapper.get();
    }

    /***
     * 取出操作
     * */
    /**
     * 获取缓存key的值
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * @param type 值的类型
     * **/
    public static <T> T get(String cacheName,Object key, @Nullable Class<T> type) {
        T t = null;
        try {
            t = getCache(cacheName).get(key, type);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return t;
    }
    /**
     * 获取缓存key的值
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * **/
    public static <T> T get(String cacheName,Object key) {
        Cache.ValueWrapper valueWrapper = getCache(cacheName).get(key);
        if (valueWrapper == null ){
            return null;
        }
        return (T) valueWrapper.get();
    }
    /***
     * 判断缓存中是否存在某个key
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * */
    public static boolean containKey(String cacheName,Object key){
        if (StringUtils.isEmpty(key))
            return false;
        return getCache(cacheName).containKey(key);
    }

    /**
     * 模糊获取缓存的keys
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * **/
    public static List<String> getKeysLeftLike(String cacheName, String key) {
        if(StringUtils.isEmpty(key))
            return null;
        key = "*"+ key;
        return getCache(cacheName).getKeys(key);
    }
    /**
     * 模糊获取缓存的keys
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * **/
    public static List<String> getKeysRightLike(String cacheName, String key) {
        if(StringUtils.isEmpty(key))
            return null;
        key = key + "*";
        return getCache(cacheName).getKeys(key);
    }
    /**
     * 模糊获取缓存的keys
     * @param cacheName 缓存名称
     * @param key 模糊匹配key
     * **/
    public static List<String> getKeysLike(String cacheName, String key) {
        if(StringUtils.isEmpty(key))
            return null;
        key = "*" + key + "*";
        return getCache(cacheName).getKeys(key);
    }
    /**
     * 模糊获取缓存的keys
     * @param cacheName 缓存名称
     * @param key 模糊匹配key 自定义表达式
     * **/
    public static List<String> getKeys(String cacheName, String key) {
        if(StringUtils.isEmpty(key))
            return null;
        return getCache(cacheName).getKeys(key);
    }

    public static List<String> scanKeys(String cacheName, String key) {
        if(StringUtils.isEmpty(key))
            return null;
        return getCache(cacheName).getKeys(key);
    }
    /**
     * 删除key
     * @param cacheName 缓存名称
     * @param key 缓存key
     * **/
    public static void evict(String cacheName,Object key){
        getCache(cacheName).evict(key);
    }
    /**
     * 模糊匹配删除key
     * @param cacheName 缓存名称
     * @param key 缓存key
     * */
    public static void evictKeysLike(String cacheName,String key){
        if(StringUtils.isEmpty(key))
            return ;
        key = "*" +key +"*";
        getCache(cacheName).evictKeys(key);
    }
    /**
     * 模糊匹配删除key
     * @param cacheName 缓存名称
     * @param key 缓存key
     * */
    public static void evictKeysLeftLike(String cacheName,String key){
        if(StringUtils.isEmpty(key))
            return ;
        key = "*" +key ;
        getCache(cacheName).evictKeys(key);
    }
    /**
     * 模糊匹配删除key
     * @param cacheName 缓存名称
     * @param key 缓存key
     * */
    public static void evictKeysRightLike(String cacheName,String key){
        if(StringUtils.isEmpty(key))
            return ;
        key = key +"*";
        getCache(cacheName).evictKeys(key);
    }
    /**
     * zp 增加了获取key剩余时长的
     * **/
    public static Long getKeyExpireTime(String cacheName,String key){
        return getCache(cacheName).getKeyExpireTime(key);
    }

}
