package net.easipay.cache.client.manager;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.whalin.MemCached.MemCachedClient;
import com.whalin.MemCached.SockIOPool;

import net.easipay.cache.config.CacheConfig;
import net.easipay.cache.util.StringUtils;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class CacheClientManager {
	Logger logger = LoggerFactory.getLogger(CacheClientManager.class);
	private static MemCachedClient memCachedClient;
	private static ShardedJedisPool jedisPool = null; 
	 
	public void initCacheClient(){
		int cacheMode=CacheConfig.getCacheMode();
		logger.debug("===========cacheMode:"+cacheMode);
		switch (cacheMode) {
		case 1:
			initMemcachedClient();
			break;
		case 2:
			initRedisClient();
			break;
		default:
			break;
		}
	}
	/**
     * 获取Jedis实例
     * @return
     */
    public synchronized static ShardedJedis getJedis() {
        try {
            if (jedisPool != null) {
            	ShardedJedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 获取memcached实例
     * @return
     */
    public synchronized static MemCachedClient getMemCachedClient() {
    	if (memCachedClient != null) {
            return memCachedClient;
        } else {
            return null;
        }
    }
    /**
     * 初始化memcached客户端
     */
	void initMemcachedClient(){
		logger.debug("===========start to intit MemcachedClient,services:"+CacheConfig.getServers());
		 /************************************配置Memcached**************************************/  
        SockIOPool sockIOPool = SockIOPool.getInstance();  
        sockIOPool.setServers(CacheConfig.getServers().split(","));//设置memcached服务器地址  
        if (StringUtils.isNotBlank(CacheConfig.getWeights())){
        	String[] Weights=CacheConfig.getWeights().split(",");
        	Integer[] n = new Integer[Weights.length];   
        	 for(int i = 0;i<Weights.length;i++){  
        		 n[i] = Integer.parseInt(Weights[i]);  
        	 } 
            sockIOPool.setWeights(n);               //设置每个MemCached服务器权重   
        }
        sockIOPool.setFailover(CacheConfig.isFailover());       //当一个memcached服务器失效的时候是否去连接另一个memcached服务器.  
        sockIOPool.setInitConn(CacheConfig.getInitConn());      //初始化时对每个服务器建立的连接数目  
        sockIOPool.setMinConn(CacheConfig.getMinConn());                             //每个服务器建立最小的连接数  
        sockIOPool.setMaxConn(CacheConfig.getMaxConn());                            //每个服务器建立最大的连接数  
        sockIOPool.setMaintSleep(CacheConfig.getMaintSleep());                          //自查线程周期进行工作，其每次休眠时间  
        sockIOPool.setNagle(CacheConfig.isNagle());                            //Socket的参数，如果是true在写数据时不缓冲，立即发送出去。Tcp的规则是在发送一个包之前，包的发送方会等待远程接收方确认已收到上一次发送过来的包；这个方法就可以关闭套接字的缓存——包准备立即发出。  
        //sockIOPool.setSocketTO(3000);                          //Socket阻塞读取数据的超时时间  
        sockIOPool.setAliveCheck(CacheConfig.isAliveCheck());                        //设置是否检查memcached服务器是否失效  
        sockIOPool.setMaxIdle(CacheConfig.getMaxIdle());                     // 设置最大处理时间   
        //sockIOPool.setSocketConnectTO(0);                      //连接建立时对超时的控制  
        sockIOPool.initialize();                               // 初始化连接池  
        if (memCachedClient == null){  
            memCachedClient = new MemCachedClient();  
        }
        logger.debug("===========MemcachedClient init success=================");
	}
	/**
	 * 初始化redis连接池
	 */
	void initRedisClient(){
		logger.debug("===========start to init RedisClient,addr=======:"+CacheConfig.getRedisAddr());
        try {
        	List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
            String ADDR = CacheConfig.getRedisAddr();
            String[] addrs=ADDR.split(",");
            for(String addr:addrs){
            	String[] adds=addr.split(":");
            	shards.add( new JedisShardInfo(adds[0],Integer.parseInt(adds[1])) );
            }
        	
            int MAX_IDLE=CacheConfig.getRedisMaxIdle();
            boolean TEST_ON_BORROW=CacheConfig.isTestOnBorrow();
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxIdle(MAX_IDLE); //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
            config.setTestOnBorrow(TEST_ON_BORROW);//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的         
            jedisPool = new ShardedJedisPool(config, shards);
        } catch (Exception e) {
            e.printStackTrace();
        }
        logger.debug("===========init RedisClient success=================");
	}
	/**
	 * 设置参数
	 * @param cacheConfig
	 */
	public void setCacheConfig(Map<String, String> cacheConfig){		
		if (StringUtils.isNotBlank(cacheConfig.get("cacheMode")) &&!StringUtils.equals(cacheConfig.get("cacheMode"),"${easipay.cache.cacheMode}")) {
	    	CacheConfig.setCacheMode(Integer.parseInt(cacheConfig.get("cacheMode")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("servers")) &&!StringUtils.equals(cacheConfig.get("servers"),"${easipay.memcached.servers}")) {
	    	CacheConfig.setServers(cacheConfig.get("servers"));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("weights")) &&!StringUtils.equals(cacheConfig.get("weights"),"${easipay.memcached.weights}")) {
	    	CacheConfig.setWeights(cacheConfig.get("weights"));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("initConn")) &&!StringUtils.equals(cacheConfig.get("initConn"),"${easipay.memcached.initConn}")) {
	    	CacheConfig.setInitConn(Integer.parseInt(cacheConfig.get("initConn")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("minConn")) &&!StringUtils.equals(cacheConfig.get("minConn"),"${easipay.memcached.minConn}")) {
	    	CacheConfig.setMinConn(Integer.parseInt(cacheConfig.get("minConn")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("maxConn")) &&!StringUtils.equals(cacheConfig.get("maxConn"),"${easipay.memcached.maxConn}")) {
	    	CacheConfig.setMaxConn(Integer.parseInt(cacheConfig.get("maxConn")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("maintSleep")) &&!StringUtils.equals(cacheConfig.get("maintSleep"),"${easipay.memcached.maintSleep}")) {
	    	CacheConfig.setMaintSleep(Integer.parseInt(cacheConfig.get("maintSleep")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("aliveCheck")) &&!StringUtils.equals(cacheConfig.get("aliveCheck"),"${easipay.memcached.aliveCheck}")) {
	    	CacheConfig.setAliveCheck(new Boolean(cacheConfig.get("aliveCheck")));
	    }
	    //redis
	    if (StringUtils.isNotBlank(cacheConfig.get("redisAddr")) &&!StringUtils.equals(cacheConfig.get("redisAddr"),"${easipay.redis.redisAddr}")) {
	    	CacheConfig.setRedisAddr(cacheConfig.get("redisAddr"));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("redisMaxIdle")) &&!StringUtils.equals(cacheConfig.get("redisMaxIdle"),"${easipay.redis.redisMaxIdle}")) {
	    	CacheConfig.setRedisMaxIdle(Integer.parseInt(cacheConfig.get("redisMaxIdle")));
	    }
	    if (StringUtils.isNotBlank(cacheConfig.get("testOnBorrow")) &&!StringUtils.equals(cacheConfig.get("redisAddr"),"${easipay.redis.testOnBorrow}")) {
	    	CacheConfig.setTestOnBorrow(new Boolean(cacheConfig.get("testOnBorrow")));
	    }
	  }
}