package com.chaozhanggui.admin.system.util;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.Calendar;
import java.util.Collections;
import java.util.Set;
import java.util.TreeSet;

/**
 * @ClassName RedisUtil
 * @Author wgc
 * @Date 2019/12/9 14:28
 * @Version 1.0
 * @Description redis工具类
 */
@Component
public class RedisUtil {
    // 成功标识
    private static final int REDIS_SUCCESS = 1;
    // 失败标识
    private static final int REDIS_FAILED = -1;
    @Value("${spring.redis.database}")
    private int database;


    @Autowired
    private JedisPool pool;


    /**
     * @param key
     * @param message
     * @return boolean
     * @Description: 保存StrinRedisConfigg信息
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public Integer saveMessage(String key, String message) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return REDIS_FAILED;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }

            jedis.set(key, message);
            return REDIS_SUCCESS;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return REDIS_FAILED;
    }


    /**
     * 释放分布式锁
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean releaseDistributedLock(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
            if ("true".equals(result)) {
                return true;
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return false;

    }


    /**
     * @param key
     * @param message
     * @param expire
     * @return
     * @Description: 保存String信息(生命周期单位秒)
     * @author wgc
     * @date 2018-12-19 19:49
     */
    public Integer saveMessage(String key, String message, int expire) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return REDIS_FAILED;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            jedis.set(key, message);
            jedis.expire(key, expire);

            return REDIS_SUCCESS;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return REDIS_FAILED;
    }

    /**
     * @param key
     * @param message
     * @return
     * @Description: 保存byte[]信息
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public Integer saveMessage(String key, byte[] message) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return REDIS_FAILED;
            }

            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            jedis.set(key.getBytes(), message);
            return REDIS_SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return REDIS_FAILED;
    }


    /**
     * @param key
     * @return
     * @Description: 获取String对象类型值
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public String getMessage(String key) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return null;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            // 获取jedis实例后可以对redis服务进行一系列的操作
            if (database!=0) {
                jedis.select(database);
            }
            String value = jedis.get(key);

            return value;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }
    /**
     * @param key
     * @return
     * @Description: 获取String对象类型值
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public Set<String> getAllMessage(String key) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return null;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            // 获取jedis实例后可以对redis服务进行一系列的操作
            if (database!=0) {
                jedis.select(database);
            }
            Set<String> value = jedis.keys(key);

            return value;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    /**
     * @param key
     * @return
     * @Description: 通过key删除数据
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public Integer deleteByKey(String key) {
        Jedis jedis = null;
        try {
            if (StringUtils.isEmpty(key)) {
                return REDIS_FAILED;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            jedis.del(key);
            return REDIS_SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return REDIS_FAILED;
    }
    /**
     * @param key
     * @return
     * @Description: 通过key删除数据
     * @author SLy
     * @date 2018-12-19 19:49
     */
    public TreeSet<String> keys(String key) {
        Jedis jedis = null;
        TreeSet<String> keys = new TreeSet<>();
        try {
            if (StringUtils.isEmpty(key)) {
                return null;
            }
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            keys.addAll(jedis.keys(key));
            return keys;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }


    public int getIncrementNum(String key, String message) {
        Jedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            String sss = jedis.get(key);
            if (StringUtils.isBlank(jedis.get(key))) {
                Calendar cal = Calendar.getInstance();
                cal.add(Calendar.DAY_OF_YEAR, 1);
                cal.set(Calendar.HOUR_OF_DAY, 0);
                cal.set(Calendar.SECOND, 0);
                cal.set(Calendar.MINUTE, 0);
                cal.set(Calendar.MILLISECOND, 0);
                long aa = (cal.getTimeInMillis() - System.currentTimeMillis()) / 1000;
                int time = new Long(aa).intValue();
                jedis.set(key, message);
                jedis.expire(key, time);
            }
            jedis.incr(key);
            return REDIS_SUCCESS;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }

        return REDIS_FAILED;
    }
    public int getIncrNum(String key, String message) {
        Jedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            if (message.equals("1")) {
                jedis.decr(key);
            }else {
                jedis.incr(key);
            }
            return REDIS_SUCCESS;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }

        return REDIS_FAILED;
    }

    public int getTicketNum(String key) {
        Jedis jedis = null;
        try {
            // 从jedis池中获取一个jedis实例
            jedis = pool.getResource();
            if (database!=0) {
                jedis.select(database);
            }
            jedis.incr(key);
            return REDIS_SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 释放对象池，即获取jedis实例使用后要将对象还回去
            if (jedis != null) {
                jedis.close();
            }
        }
        return REDIS_FAILED;
    }

}
