package com.fizz.business.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public class RedisUtil {

    private static RedisTemplate redis;



    @Autowired
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        redis = redisTemplate;
    }

    // ============================== Common ==============================

    /**
     * 删除多个key
     */
    public static <K> Long delete(Collection<K> keys) {
        return redis.delete(keys);
    }

    /**
     * 根据pattern获取匹配的keys
     */
    public static <K> Set<K> keys(K pattern) {
        return redis.keys(pattern);
    }

    // ============================== String ==============================

    /**
     * 设置键值对
     */
    public static <K, V> void setValue(K key, V value) {
        redis.opsForValue().set(key, value);
    }

    /**
     * 设置键值对并设置过期时间(毫秒)
     */
    public static <K, V> void setValue(K key, V value, long time) {
        redis.opsForValue().set(key, value, time, TimeUnit.MILLISECONDS);
    }

    /**
     * 获取值
     */
    public static <K, V> V getValue(K key) {
        return (V) redis.opsForValue().get(key);
    }

    /**
     * 值递增
     */
    public static <K, V> Long increment(K key) {
        return redis.opsForValue().increment(key);
    }

    /**
     * 值递减
     */
    public static <K, V> Long decrement(K key) {
        return redis.opsForValue().decrement(key);
    }

    // ============================== List ==============================

    /**
     * 左推入单个元素
     */
    public static <K, V> void leftPush(K key, V value) {
        redis.opsForList().leftPush(key, value);
    }

    /**
     * 左推入多个元素
     */
    public static <K, V> void leftPush(K key, List<V> values) {
        redis.opsForList().leftPushAll(key, values);
    }

    /**
     * 右推入单个元素
     */
    public static <K, V> void rightPush(K key, V value) {
        redis.opsForList().rightPush(key, value);
    }

    /**
     * 右推入多个元素
     */
    public static <K, V> void rightPush(K key, List<V> values) {
        redis.opsForList().rightPushAll(key, values);
    }

    /**
     * 通过索引设置列表元素
     */
    public static <K, V> void pushListByIndex(K key, V value, int index) {
        redis.opsForList().set(key, (long) index, value);
    }

    /**
     * 获取列表范围(0到-1表示全部)
     */
    public static <K, V> List<V> range(K key) {
        return redis.opsForList().range(key, 0L, -1L);
    }

    /**
     * 移除列表元素
     */
    public static <K, V> void remove(K key, long count, V value) {
        redis.opsForList().remove(key, count, value);
    }

    /**
     * 获取列表长度
     */
    public static <K> Long listSize(K key) {
        return redis.opsForList().size(key);
    }

    /**
     * 通过索引获取列表元素
     */
    public static <K, V> V getListByIndex(K key, Long index) {
        return (V) redis.opsForList().index(key, index);
    }

    // ============================== Set ==============================

    /**
     * 向集合添加多个元素
     */
    public static <K, V> void add(K key, List<V> values) {
        redis.opsForSet().add(key, values.toArray());
    }

    /**
     * 向集合添加一个或多个元素
     */
    public static <K, V> void add(K key, V... values) {
        redis.opsForSet().add(key, values);
    }

    /**
     * 获取集合所有成员
     */
    public static <K, V> Set<V> members(K key) {
        return redis.opsForSet().members(key);
    }

    /**
     * 移除集合中的多个元素
     */
    public static <K, V> void remove(K key, List<V> values) {
        redis.opsForSet().remove(key, values.toArray());
    }

    /**
     * 移除集合中的一个或多个元素
     */
    public static <K, V> void remove(K key, V... values) {
        redis.opsForSet().remove(key, values);
    }

    /**
     * 返回两个集合的差集
     */
    public static <K, V> Set<V> difference(K key1, K key2) {
        return redis.opsForSet().difference(key1, key2);
    }

    /**
     * 随机获取集合中的一个元素
     */
    public static <K, V> V randomMember(K key) {
        return (V) redis.opsForSet().randomMember(key);
    }

    /**
     * 随机弹出集合中的一个元素
     */
    public static <K, V> V pop(K key) {
        return (V) redis.opsForSet().pop(key);
    }

    // ============================== Hash ==============================

    /**
     * 设置整个Hash
     */
    public static <K, V> void putAll(K key, Map<K, V> map) {
        redis.opsForHash().putAll(key, map);
    }

    /**
     * 设置Hash中的单个字段
     */
    public static <K, V> void put(K key, K hashKey, V value) {
        redis.opsForHash().put(key, hashKey, value);
    }

    /**
     * 获取Hash中的字段值
     */
    public static <K, V> V get(K key, K hashKey) {
        return (V) redis.opsForHash().get(key, hashKey);
    }

}
