package com.ssi.config;

import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
import com.alicp.jetcache.anno.config.EnableMethodCache;
import com.alicp.jetcache.anno.support.GlobalCacheConfig;
import com.alicp.jetcache.anno.support.SpringConfigProvider;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.embedded.LinkedHashMapCacheBuilder;
import com.alicp.jetcache.redis.lettuce.RedisLettuceCacheBuilder;
import com.alicp.jetcache.support.FastjsonKeyConvertor;
import com.alicp.jetcache.support.JavaValueDecoder;
import com.alicp.jetcache.support.JavaValueEncoder;
import com.google.common.base.Joiner;
import io.lettuce.core.RedisClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * JetCache缓存配置
 */
@Configuration
@EnableMethodCache(basePackages = {
        "com.ssi.model",
        "com.ssi.service"
})
@EnableCreateCacheAnnotation
public class JetCacheConfig {

    private final String clientName = "JetCacheClient";

    @Autowired
    private JetCacheRedisConfig jetCacheRedisConfig;

    @Bean
    public RedisClient pool() {

        JetCacheRedisConfig.Sentinel sentinel = jetCacheRedisConfig.getSentinel();
        Duration timeout = jetCacheRedisConfig.getTimeout();
        int t = timeout == null ? 5000 : (int) timeout.toMillis();

        String url = jetCacheRedisConfig.getUrl();
        if (url == null) {
            if (sentinel != null) {

                url = String.format("redis-sentinel://user:%s@%s/?sentinelMasterId=%s&database=%s&timeout=%s",
                        jetCacheRedisConfig.getPassword(),
                        Joiner.on(",").skipNulls().join(sentinel.getNodes()),
                        sentinel.getMaster(),
                        jetCacheRedisConfig.getDatabase(),
                        t);
            } else {

                url = String.format("redis://user:%s@%s:%s?database=%s&timeout=%s",
                        jetCacheRedisConfig.getPassword(),
                        jetCacheRedisConfig.getHost(),
                        jetCacheRedisConfig.getPort(),
                        jetCacheRedisConfig.getDatabase(),
                        t);
            }
        }

        return RedisClient.create(url);
    }

    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }

    @Bean
    public GlobalCacheConfig config(SpringConfigProvider configProvider, RedisClient redisClient) {
        Map localBuilders = new HashMap();
        EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
                .createLinkedHashMapCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);

        Map remoteBuilders = new HashMap();
        RedisLettuceCacheBuilder remoteCacheBuilder = RedisLettuceCacheBuilder.createRedisLettuceCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .redisClient(redisClient);

        remoteCacheBuilder.setKeyPrefix("ivccs:vms:");

        remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);

        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setConfigProvider(configProvider);
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        globalCacheConfig.setStatIntervalMinutes(15);
        globalCacheConfig.setHiddenPackages(new String[]{"com.dfssi.dataplatform.v2x"});
        globalCacheConfig.setAreaInCacheName(false);

        return globalCacheConfig;
    }

}