package com.younike.common.redis;

import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.poi.ss.formula.functions.T;
import org.redisson.api.RList;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

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

/**
 * Redis工具类
 *
 * @author chenpengfei
 */
@Component
@Log4j2
public class RedisUtils {

    @Resource
    private RedissonClient redissonClient;


    /**
     * 返回哈希表中，所有的字段和值。
     *
     * @return 以列表形式返回哈希表的字段及字段值。 若 key 不存在，返回空列表。
     *
     **/
    public Map<String, String> hgetall(String key) {
        RMap<String, String> index = redissonClient.getMap(key);
        return index.readAllMap();
    }

    /**
     * 用于查看哈希表的指定字段是否存在。
     *
     * @return 如果哈希表含有给定字段，返回 true 。
     * 如果哈希表不含有给定字段，或 key 不存在，返回 false 。
     *
     **/
    public boolean hexists(String key, String mapKey) {
        RMap<String, String> map = redissonClient.getMap(key);
        return map.containsKey(mapKey);
    }

    /**
     * 于返回哈希表中指定字段的值。
     *
     * @return 返回给定字段的值。如果给定的字段或 key 不存在时，返回 nil 。
     *
     **/
    public String hget(String key, String value) {
        RMap<String, String> map = redissonClient.getMap(key);
        return map.get(value);
    }

    public void hset(String key, String field, String value) {
        RMap<String, String> map = redissonClient.getMap(key);
        map.put(field, value);
    }

    public void hdel(String key, String... fields) {
        RMap<String, String> map = redissonClient.getMap(key);
        map.fastRemove(fields);
    }

    /**
     * 2021-9-3 Another 设置 list（有效时间，单位：分钟）
     * @param key
     * @param list
     * @return
     */
    public boolean addAllList(String key, List<String> list, int time) {
        RList<String> rList = redissonClient.getList(key);
        rList.expire(time, TimeUnit.MINUTES);
        return rList.addAll(list);
    }



    /**
     * 2021-9-3 Another 设置 list（有效时间，单位：分钟）
     * @param key
     * @param list
     * @return
     */
    public boolean addAllHash(String key, List list, int time) {
        RList rList = redissonClient.getList(key);
        rList.expire(time, TimeUnit.MINUTES);
        return rList.addAll(list);
    }

    public RList<T> getAllHash(String key) {
        RList<T> rList = redissonClient.getList(key);

        return rList;
    }

    /**
     * 2021-9-3 Another 获取 list 容量
     * @param key
     * @return
     */
    public int getListSize(String key) {
        RList<String> rList = redissonClient.getList(key);
        return rList.size();
    }

    /**
     * 2021-9-3 Another 从指定list中 获取 前num位list
     * @param key
     * @param num
     * @return
     */
    public RList<String> getListByInterval(String key, int num) {
        RList<String> rList = redissonClient.getList(key);
        if (rList.isEmpty() || rList.size() < num) {
            return null;
        }
        return rList.subList(0, num);
    }

    /**
     * 2021-9-3 Another 从指定list中 移除 list
     * @param key
     * @param list
     * @return
     */
    public boolean removeList(String key, List<String> list) {
        RList<String> rList = redissonClient.getList(key);
        if (rList.isEmpty()) {
            return false;
        }
        return rList.removeAll(list);
    }

    /**
     * 2021-9-3 Another 设值（有效时间，单位：分钟）
     * @param keyMap
     * @param key
     * @param value
     * @param time
     * @return
     */
    public boolean put(String keyMap, String key, Object value, int time) {
        RMap<Object, Object> map = redissonClient.getMap(keyMap);
        map.expire(time, TimeUnit.MINUTES);
        Object put = map.put(key, value);
        return true;
    }

    /**
     * 2021-9-3 Another 设值（不设有效时间）
     * @param keyMap
     * @param key
     * @param value
     * @return
     */
    public boolean put(String keyMap, String key, Object value) {
        RMap<Object, Object> map = redissonClient.getMap(keyMap);
        Object put = map.put(key, value);
        return true;
    }

    /**
     * 2021-9-3 Another 取值
     * @param mapKey
     * @param key
     * @return
     */
    public Object getByMapKeyAndKey(String mapKey, Object key) {
        RMap<Object, Object> result = redissonClient.getMap(mapKey);
        if(ObjectUtils.isEmpty(result)){
            return null;
        }
        if(!result.containsKey(key)){
            return null;
        }
        return result.get(key);
    }

    /**
     * 2021-9-3 Another 取值
     * @param mapKey
     * @return
     */
    public RMap<Object, Object> getByMapKey(String mapKey) {
        RMap<Object, Object> result = redissonClient.getMap(mapKey);
        return result;
    }

    /**
     * 2021-10-8 Another 移除指定的 key
     * @param keyMap
     * @param key
     * @return
     */
    public boolean removeKey(String keyMap, String key) {
        RMap<Object, Object> map = redissonClient.getMap(keyMap);
        if(ObjectUtils.isEmpty(map)){
            return false;
        }
        map.remove(key);
        return true;
    }

}
