package com.elab.cache.redis;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.TypeReference;
import com.elab.cache.ICacheClient;
import com.sohu.tv.builder.RedisClusterBuilder;
import org.apache.commons.lang3.StringUtils;
import redis.clients.jedis.JedisCluster;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 操作redis集群
 *
 * @author Liukx
 * @create 2017-05-17 14:06
 * @email liukx@elab-plus.com
 **/
public class RedisClusterClient extends BaseRedis implements ICacheClient {

    public RedisClusterBuilder redisBuilder;

    public RedisClusterBuilder getRedisBuilder() {
        return redisBuilder;
    }

    public void setRedisBuilder(RedisClusterBuilder redisBuilder) {
        this.redisBuilder = redisBuilder;
    }

    public JedisCluster jedisCluster;

    public void init() {
        jedisCluster = redisBuilder.build();
    }


    public void close(JedisCluster jedis) {
        try {
            jedis.close();
        } catch (RuntimeException e) {
            logger.error("关闭redis异常", e);
        }
        logger.debug(" 关闭 redis连接 db  [" + dbIndex + "]");
    }

    /**
     * 将指定的key进行递减
     *
     * @param key 键
     * @param num 减去的值
     * @return
     */
    public Long decrby(String key, long num) {
        try {
            return jedisCluster.decrBy(key, num);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, num + "");
        }
        return 0L;
    }

    /**
     * 将指定的key进行自增
     *
     * @param key 键
     * @param num 累加的值
     * @return
     */
    public Long incrby(String key, long num) {
        try {
            return jedisCluster.incrBy(key, num);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, num + "");
        }
        return 0L;
    }

    /**
     * 根据指定的key获取对象
     *
     * @param key   键 - 标识
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(String key, Class clazz) {
        String value = null;
        try {
            value = jedisCluster.get(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        if (StringUtils.isEmpty(value)) {
            return null;
        }
        T t = (T) JSON.parseObject(value, clazz);
        return t;
    }

    /**
     * 根据缓存的key获取一个集合
     *
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> List<T> getList(String key, Class clazz) {
        String value = null;
        try {
            value = jedisCluster.get(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        if (StringUtils.isEmpty(value)) {
            return null;
        }

        List<T> tempList = JSON.parseObject(value, new TypeReference<List<T>>() {
        });
        List<T> list = JSONArray.parseArray(tempList.toString(), clazz);
        return list;
    }

    /**
     * 根据key获取Map对象
     *
     * @param key   缓存的key
     * @param clazz 需要转换的对象
     * @param <T>
     * @return
     */
    public <T> Map<String, T> getMap(String key, Class clazz) {
        String value = null;
        try {
            value = jedisCluster.get(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        if (StringUtils.isEmpty(value)) {
            return null;
        }
        Map<String, T> map = JSON.parseObject(value, new TypeReference<Map<String, T>>() {
        });
        return map;
    }

    /**
     * 为指定的key设定有效时长
     *
     * @param key     键
     * @param seconds 有效时长 单位:秒
     * @return
     */
    public boolean expire(String key, int seconds) {
        Long expire = 0L;
        try {
            expire = jedisCluster.expire(key, seconds);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, seconds);
        }
        if (expire > 0) {
            return true;
        }
        return false;
    }

    /**
     * 查看当前key 还有多少有效时间
     *
     * @param key
     * @return
     */
    public Long ttl(String key) {
        Long ttl = 0L;
        try {
            ttl = jedisCluster.ttl(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        return ttl;
    }

    /**
     * 如果不存在则添加,存在则返回false
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean setNX(String key, Object value) {
        Long setex = 0L;
        try {
            setex = jedisCluster.setnx(key, value.toString());
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        // 0 表示未设置 1表示已经设置了
        if (setex > 0) {
            return true;
        }
        return false;
    }

    /**
     * 删除缓存中的数据
     *
     * @param key 键
     */
    public void delete(String key) {
        try {
            jedisCluster.del(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
    }

    /**
     * 为缓存中的数据加锁,通常用于分布式锁
     *
     * @param key     key
     * @param value   值
     * @param timeout 超时时间 单位秒
     * @return
     */
    public boolean tryLock(String key, Object value, int timeout) {
        String lockKey = "locked#" + key;
        long startTime = System.currentTimeMillis();
        int sleepTimes = 0;

        while (!setNX(lockKey, value)) {
            try {
                Thread.sleep(1);
                sleepTimes++;
                if (sleepTimes % 100 == 0) {
                    //超时判断
                    if (System.currentTimeMillis() - startTime > timeout * 1000) {
                        return false;
                    }
                }
            } catch (InterruptedException e) {
                return false;
            }
        }
        return true;
    }

    public void unLock(String key) {
        String lockKey = "locked#" + key;
        delete(lockKey);
    }

    /**
     * <p>通过key 和offset 从指定的位置开始将原先value替换</p>
     * <p>下标从0开始,offset表示从offset下标开始替换</p>
     * <p>如果替换的字符串长度过小则会这样</p>
     * <p>example:</p>
     * <p>value : bigsea@zto.cn</p>
     * <p>str : abc </p>
     * <P>从下标7开始替换  则结果为</p>
     * <p>RES : bigsea.abc.cn</p>
     *
     * @param key
     * @param value
     * @param offset 下标位置
     * @return 返回替换后  value 的长度
     */
    @Override
    public Long setRange(String key, String value, int offset) {
        Long count = 0L;
        try {
            count = jedisCluster.setrange(key, offset, value);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, value);
        }
        return count;
    }

    /**
     * <p>通过下标 和key 获取指定下标位置的 value</p>
     *
     * @param key
     * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取
     * @param endOffset
     * @return 如果没有返回null
     */
    @Override
    public String getRange(String key, int startOffset, int endOffset) {
        String data = null;
        try {
            data = jedisCluster.getrange(key, startOffset, endOffset);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        return data;
    }

    /**
     * <p>通过批量的key获取批量的value</p>
     *
     * @param keys string数组 也可以是一个key
     * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空
     */
    public List<String> mget(String... keys) {
        List<String> list = null;
        try {
            list = jedisCluster.mget(keys);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, keys);
        }
        return list;
    }

    /**
     * <p>批量的设置key:value,可以一个</p>
     * <p>example:</p>
     * <p>  obj.mset(new String[]{"key2","value1","key2","value2"})</p>
     *
     * @param keysvalues
     * @return 成功返回OK 失败 异常 返回 null
     */
    public String mset(String... keysvalues) {
        String data = null;
        try {
            data = jedisCluster.mset(keysvalues);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, keysvalues, keysvalues);
        }
        return data;
    }

    /**
     * <p>批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚</p>
     * <p>example:</p>
     * <p>  obj.msetnx(new String[]{"key2","value1","key2","value2"})</p>
     *
     * @param keysvalues
     * @return 成功返回1 失败返回0
     */
    public Long msetnx(String... keysvalues) {
        Long result = 0L;
        try {
            result = jedisCluster.msetnx(keysvalues);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, keysvalues, keysvalues);
        }
        return result;
    }

    /**
     * <p>通过key给Hash Field设置指定的值,如果key不存在,则先创建</p>
     *
     * @param key
     * @param field 字段
     * @param value
     * @return 如果存在返回0 异常返回null
     */
    public Long hset(String key, String field, String value) {
        Long count = null;
        try {
            count = jedisCluster.hset(key, field, value);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, field, value);
        }
        return count;
    }

    /**
     * <p>Sets field in the hash stored at key to value
     * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0</p>
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hsetnx(String key, String field, String value) {
        Long count = 0L;
        try {
            count = jedisCluster.hsetnx(key, field, value);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, field, value);
        }
        return count;
    }

    /**
     * <p>通过key同时设置 hash的多个field</p>
     *
     * @param key
     * @param hash
     * @return 返回OK 异常返回null
     */
    public String hmset(String key, Map<String, String> hash) {
        String result = null;
        try {
            result = jedisCluster.hmset(key, hash);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, hash);
        }
        return result;
    }

    /**
     * <p>通过key 和 field 获取指定的 value</p>
     *
     * @param key
     * @param field
     * @return 没有返回null
     */
    public String hget(String key, String field) {
        String result = null;
        try {
            result = jedisCluster.hget(key, field);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, field);
        }
        return result;
    }

    /**
     * <p>通过key 和 fields 获取指定的value 如果没有对应的value则返回null</p>
     *
     * @param key
     * @param fields 可以使 一个String 也可以是 String数组
     * @return
     */
    public List<String> hmget(String key, String... fields) {
        List<String> result = null;
        try {
            result = jedisCluster.hmget(key, fields);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, fields);
        }
        return result;
    }


    /**
     * <p>通过key向list头部添加字符串</p>
     *
     * @param key
     * @param strs 可以是一个string 也可以是string数组
     * @return 返回list的value个数
     */
    public Long lpush(String key, String... strs) {
        Long result = 0L;
        try {
            result = jedisCluster.lpush(key, strs);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, strs);
        }
        return result;
    }

    /**
     * 获取指定list
     *
     * @param key        键
     * @param startIndex 开始下标
     * @param endIndex   结束下标  -1 代表获取所有
     * @return
     */
    public List<String> lrange(String key, int startIndex, int endIndex) {
        List<String> list = null;
        try {
            list = jedisCluster.lrange(key, startIndex, endIndex);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, startIndex, endIndex);
        }
        return list;
    }


    /**
     * 获取所有list
     *
     * @param key 键
     * @return
     */
    public List<String> lrange(String key) {
        List<String> list = null;
        try {
            list = jedisCluster.lrange(key, 0, -1);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        return list;
    }

    /**
     * 设定数据到缓存中
     *
     * @param key  键
     * @param data
     * @param <T>
     */
    public <T> void set(String key, T data) {
        try {
            jedisCluster.set(key, JSON.toJSONString(data));
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
    }

    public <T> void setList(String key, List<T> list) {
        try {
            jedisCluster.set(key, JSON.toJSONString(list));
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, list);
        }
    }

    /**
     * 添加一个map的值
     *
     * @param key 键
     * @param map Map集合
     * @param <T> 泛型任意类型
     */
    public <T> void setMap(String key, Map<String, T> map) {
        try {
            jedisCluster.set(key, JSON.toJSONString(map));
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, map);
        }
    }

    /**
     * 判断指定的key是否存在
     *
     * @param key
     * @return
     */
    public boolean exsit(String key) {
        boolean flag = false;
        try {
            flag = jedisCluster.exists(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        return flag;
    }

    /**
     * 添加数据到缓存中
     *
     * @param key       键
     * @param value     值
     * @param validTime 有效时间  1秒=1000   -1 永久有效
     */
    public void set(String key, Object value, int validTime) {
        String data = null;
        try {
            data = JSON.toJSONString(value);
        } catch (Exception e) {
            data = value.toString();
        }
        try {
            jedisCluster.set(key, data);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCachePutError(e, this, key, value);
        }
        expire(key, validTime);
    }

    /**
     * 获取缓存中的数据
     *
     * @param key 缓存的key
     * @return
     */
    public String get(String key) {
        String result = null;
        try {
            result = jedisCluster.get(key);
        } catch (RuntimeException e) {
            getCacheErrorProcess().handleCacheGetError(e, this, key);
        }
        return result;
    }

//    @Override
//    public Set<String> keys(String prefixKey) {
//        String result = null;
//        try {
//            result = jedisCluster.eval(key);
//        } catch (RuntimeException e) {
//            getCacheErrorProcess().handleCacheGetError(e, this, key);
//        }
//        return result;
//    }

    /**
     * 集群的方法不适合提供这个keys
     *
     * @param prefixKey
     * @return
     */
    @Override
    public Set<String> keys(String prefixKey) {
        return null;
    }
}
