package com.fzm.mall.server.front.repository;

import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * springboot 2.0
 *
 * @author tdz
 * @date 2021/02/22 11:26
 */
@Component
public class RedisRepository {
    @Resource
    StringRedisTemplate stringRedisTemplate;
    @Resource
    RedisTemplate<String, Object> redisTemplate;

    /**
     * 设置字符串缓存
     */
    public void setStr(String key, String val, long time, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key, val, time, timeUnit);
    }

    /**
     * 获取字符串
     */
    public String getStr(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 删除字符串
     */
    public void delStr(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 是否存在字符串
     */
    public Boolean existStr(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 设置对象
     */
    public void setObj(String key, Object val, long time, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, val, time, timeUnit);
    }

    /**
     * 获取对象
     */
    public Object getObj(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除对象
     */
    public void delObj(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 是否存在对象
     */
    public Boolean existObj(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 设置集合
     */
    public void setSet(String key, String... val) {
        stringRedisTemplate.opsForSet().add(key, val);
    }

    /**
     * 获取集合
     */
    public Set<String> getSet(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    /**
     * 删除集合
     */
    public void delSet(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 集合中是否存在指定值
     */
    public Boolean existSet(String key, String val) {
        return stringRedisTemplate.opsForSet().isMember(key, val);
    }

    /**
     * 通过前缀获取redis中的keys
     *
     * @param prefixStr 前缀
     * @return keys
     */
    public Set<String> getKeys(String prefixStr) {
        return stringRedisTemplate.keys(prefixStr);
    }

    /**
     * 批量获取字符串
     *
     * @param keys keys
     * @return 获取到的字符串
     */
    public List<String> multiGetStr(Set<String> keys) {
        return stringRedisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 批量删除
     *
     * @param keys 需要批量删除的key
     * @return 删除结果
     */
    public void multiDeleteStr(Set<String> keys) {
        stringRedisTemplate.delete(keys);
    }

    /**
     * 批量删除某个前缀的key
     *
     * @param prefix 前缀
     */
    public void multiDeleteStrByPrefix(String prefix) {
        Set<String> keys = stringRedisTemplate.keys(prefix + "*");
        if (CollectionUtils.isEmpty(keys)) {
            return;
        }
        keys.forEach(this::delStr);
    }

    /**
     * 批量设置字符串缓存
     *
     * @param map 字符串map
     */
    public void multiSetStr(Map<String, String> map) {
        stringRedisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 设置hash中的字符串
     *
     * @param hashName hash的名字
     * @param key      key
     * @param value    value
     */
    public void hashSetStr(String hashName, String key, String value) {
        redisTemplate.opsForHash().put(hashName, key, value);
    }

    /**
     * 批量设置hash中的字符串
     *
     * @param hashName hash的名字
     * @param kvMap    键值对
     */
    public void hashMultiSetStr(String hashName, Map<String, String> kvMap) {
        redisTemplate.opsForHash().putAll(hashName, kvMap);
    }

    /**
     * 获取hash中指定key的value
     *
     * @param hashName hash的名字
     * @param key      key值
     * @return value
     */
    public String hashGetStr(String hashName, String key) {
        return (String) redisTemplate.opsForHash().get(hashName, key);
    }

    /**
     * 获取hash中全部的value
     *
     * @param hashName hash的名字
     * @return valueList
     */
    public List<Object> hashMultiGetValue(String hashName) {
        Set<Object> keys = redisTemplate.opsForHash().keys(hashName);
        if (keys.isEmpty()) {
            return new ArrayList<>();
        }
        return redisTemplate.opsForHash().multiGet(hashName, keys);
    }

    /**
     * 删除hash中的key-value
     *
     * @param hashName hash的名字
     * @param key      key值
     */
    public void hashDeleteStr(String hashName, String key) {
        redisTemplate.opsForHash().delete(hashName, key);
    }

    /**
     * 删除整个hash
     *
     * @param hashName hash的名字
     */
    public void hashDelete(String hashName) {
        redisTemplate.delete(hashName);
    }

    /**
     * 获得hash的全部的键值对
     *
     * @param hashName hash的名字
     * @return 键值对
     */
    public Map<Object, Object> hashGetAllStr(String hashName) {
        return redisTemplate.opsForHash().entries(hashName);
    }
}
