package com.nuvole.four.service;

import com.nuvole.four.domain.extend.AppDTO;
import org.apache.commons.lang3.StringEscapeUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Coding makes me happy.
 * 　┏┓　　　┏┓
 * ┏┛┻━━━┛┻┓
 * ┃　　☆☆☆　　┃
 * ┃　　　━　　　┃
 * ┃　┳┛　┗┳　┃
 * ┃　　　　　　　┃
 * ┃　　　┻　　　┃
 * ┗━┓　史　┏━┛
 * 　　┃　诗　┃神兽保佑
 * 　　┃　之　┃代码无BUG！
 * 　　┃　宠　┗━━━┓
 * 　　┃Author:　　　┣┓
 * 　　┃　　  liu.Q　┏┛
 * 　　┗┓┓┏━┳┓┏┛
 * 　　　┃┫┫　┃┫┫
 * 　　　┗┻┛　┗┻┛
 * ----------------------
 *
 * @Date : 上午11:18 2018/3/2
 * @Description :
 */
@Service
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            AppDTO dto = new AppDTO();
            Map map = new HashMap();
            // todo xuekang
            // StringEscapeUtils.unescapeHtml4(key)
            map.put("key", StringEscapeUtils.unescapeHtml4(key));
            map.put("value",value);
            dto.setMap(map);
            AppDTO s = new AppDTO();
            BeanUtils.copyProperties(dto,s);
            operations.set((String)s.getMap().get("key"), s.getMap().get("value"));
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {

        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            AppDTO dto = new AppDTO();
            Map map = new HashMap();
            map.put("key",StringEscapeUtils.unescapeHtml4(key));
            map.put("value",value);
            map.put("expireTime",expireTime);
            map.put("timeUnit",timeUnit);
            dto.setMap(map);
            AppDTO s = new AppDTO();
            BeanUtils.copyProperties(dto,s);
            operations.set((String)s.getMap().get("key"), s.getMap().get("value"));
//            operations.set(StringEscapeUtils.unescapeHtml4(key), value);
            redisTemplate.expire((String)s.getMap().get("key"), (Long)s.getMap().get("expireTime"), (TimeUnit) s.getMap().get("timeUnit"));
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(StringEscapeUtils.unescapeHtml4(key));
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        AppDTO dto = new AppDTO();
        Map map = new HashMap();
        map.put("key",StringEscapeUtils.unescapeHtml4(key));
        dto.setMap(map);
        AppDTO s = new AppDTO();
        BeanUtils.copyProperties(dto,s);
        return redisTemplate.hasKey((String)s.getMap().get("key"));
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {

        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        AppDTO dto = new AppDTO();
        Map map = new HashMap();
        map.put("key",StringEscapeUtils.unescapeHtml4(key));
        dto.setMap(map);
        AppDTO s = new AppDTO();
        BeanUtils.copyProperties(dto,s);
        result = operations.get((String)s.getMap().get("key"));
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}