package com.qxueyou.scc.base.handler;

import java.io.ByteArrayOutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.Writer;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.PostConstruct;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import com.qxueyou.scc.base.model.CacheConstants;
import com.qxueyou.scc.base.service.ICacheService;
import com.qxueyou.scc.base.util.ClientUtils;
import com.qxueyou.scc.base.util.FreeMarkerMd5MethodDefine;

import freemarker.template.Configuration;
import freemarker.template.Template;
import reactor.util.IoUtils;

@Order(100)
@Aspect
@Component
public class QCacheMonitor {
	private static final Logger logger = LogManager.getLogger("QCacheMonitor");

	private static int MAX_KEY_LENGTH = 250;

	private static FreeMarkerMd5MethodDefine md5MethodObj = new FreeMarkerMd5MethodDefine();

	private static Pattern argPattern = Pattern.compile("\\$\\{arg([0-9])\\}");
	
	//判断当前线程是否已经执行过目标方法的标志
	private final ThreadLocal<Map<String, Object>> targetMethodResult = new ThreadLocal<Map<String, Object>>();
	
	private Configuration cfg;

	/** 缓存 **/
	@Autowired
	ICacheService cache;

	@Autowired
	QCacheRedis qCacheRedis;

	@Pointcut("execution(@com.iqtogether.qxueyou..QCache* * *(..))")
	public void pointCutMethod() {

	}

	@PostConstruct
	private void initFreeMarkerCfg() throws Exception {
		cfg = new Configuration(Configuration.VERSION_2_3_21);
		cfg.setTemplateUpdateDelay(10);
		cfg.setCacheStorage(new freemarker.cache.MruCacheStorage(1000, 200));
		cfg.setDefaultEncoding("UTF-8");
		cfg.setLocale(java.util.Locale.CHINA);
		cfg.setClassicCompatible(true);
	}

	@Around("pointCutMethod()" )
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
		MethodSignature methodSignature = null;
		QCacheReader annoQCacheReader = null;
		QCacheCleaner annoQCacheCleaner = null;
		String excuteMethodKey = null;
		try {
			//test();
			methodSignature = (MethodSignature) pjp.getSignature();
			
			excuteMethodKey = this.getExecuteMethodKey(pjp);
			
			//读取缓存的注解
			annoQCacheReader = AnnotationUtils.findAnnotation(methodSignature.getMethod(), QCacheReader.class);
			//清理缓存注解
			annoQCacheCleaner = AnnotationUtils.findAnnotation(methodSignature.getMethod(), QCacheCleaner.class);
			
			if(annoQCacheReader!=null && annoQCacheCleaner==null){
				this.processReadCache(pjp, annoQCacheReader, methodSignature);
			}
			
			if(annoQCacheReader==null && annoQCacheCleaner!=null){
				this.processCleanCache(pjp, annoQCacheCleaner, methodSignature);
			}
			
			if(annoQCacheReader!=null && annoQCacheCleaner!=null){
				this.processCleanCache(pjp, annoQCacheCleaner, methodSignature);
				this.processReadCache(pjp, annoQCacheReader, methodSignature);
			}
		} catch (Exception e) {
			logger.error("缓存处理失败，msg=" + e.getMessage(), e);
		}
		
		return clearAndReturnMethodResult(pjp,excuteMethodKey);
	}
	
	private void processReadCache(ProceedingJoinPoint pjp, QCacheReader qCacheReader, MethodSignature methodSignature)
			throws Exception {
		Object result = null;
		String strCacheKey = null;
		int expireTime = 0;
		try {
			expireTime = this.getCacheTimeSecond(qCacheReader);
			
			strCacheKey = this.checkAndGenerateCacheKey(pjp.getTarget().getClass(), qCacheReader.cacheKey(), methodSignature,
					converToParamMap(pjp.getArgs()));
			//执行方法对应的key值
			String excuteMethodKey =  this.getExecuteMethodKey(pjp);

			if (StringUtils.isNotEmpty(strCacheKey)) {
				String strBucketKey = qCacheReader.bucket();
				
				if (StringUtils.isEmpty(strBucketKey)) {
					strBucketKey = strCacheKey;
				}
				result = qCacheRedis.annocacheHget(CacheConstants.QXY_SERVICE_CACHE_NS + strBucketKey,
						strCacheKey, methodSignature.getMethod().getReturnType());
				if (result == null) {
					executeTargetMethod(pjp,excuteMethodKey);
					if (targetMethodResult.get()!=null && targetMethodResult.get().containsKey(excuteMethodKey)) {
						qCacheRedis.annocacheHset(CacheConstants.QXY_SERVICE_CACHE_NS + strBucketKey, strCacheKey,
								targetMethodResult.get().get(excuteMethodKey), expireTime);
					}
				}else{
					//如果result存在，则直接放入targetMethodResult中
					Map<String,Object> map = new HashMap<String,Object>();
					map.put(excuteMethodKey, result);
					targetMethodResult.set(map);
				}
			} else {
				executeTargetMethod(pjp,excuteMethodKey);
			}
		} catch (Throwable e) {
			throw new Exception("添加缓存发生异常,strCacheKey=" + strCacheKey, e);
		}
	}

	private void processCleanCache(ProceedingJoinPoint pjp, QCacheCleaner qCacheCleaner, MethodSignature methodSignature)
			throws Exception {
		String[] strClearBucketArr = null;
		String clearBucket = null;
		try {
			clearBucket =  this.checkAndGenerateCacheKey(pjp.getTarget().getClass(), qCacheCleaner.clearBucket(), methodSignature,
					converToParamMap(pjp.getArgs()));
			if (StringUtils.isNotEmpty(clearBucket)){
				if(StringUtils.isNotEmpty(qCacheCleaner.bucketSplitReg())) {
					strClearBucketArr = clearBucket.split(qCacheCleaner.bucketSplitReg());
				}else{
					strClearBucketArr =new String[]{clearBucket};
				}
			}
			if (strClearBucketArr != null && strClearBucketArr.length > 0) {
				for (int i = 0; i < strClearBucketArr.length; i++) {
					strClearBucketArr[i] = CacheConstants.QXY_SERVICE_CACHE_NS.concat(strClearBucketArr[i]);
				}
				logger.info("清理的bucket:"+ArrayUtils.toString(strClearBucketArr));
				this.qCacheRedis.del(strClearBucketArr);
			}
		} catch (Throwable e) {
			logger.error("清理缓存发生异常，strClearBucketArr" + ArrayUtils.toString(strClearBucketArr, ""), e);
		}
	}

	private String checkAndGenerateCacheKey(Class<?> targetClass, String key, MethodSignature methodSignature,
			Map<String, Object> paramMap) throws Exception {
		String strNewKey = null;

		if (StringUtils.isNotEmpty(key)) {
			logger.info("处理前的key:" + key);

			// 对部分参数进行替换处理
			strNewKey = replaceArgInfo(key, paramMap);
			// freeMarker解析cackeKey
			strNewKey = parseCacheKey(strNewKey, targetClass, methodSignature, paramMap);

			logger.info("处理后的key:" + strNewKey);
			if (strNewKey.length() > MAX_KEY_LENGTH) {
				throw new Exception("Service缓存时Key过长，大于250个字符");
			}
		}
		return strNewKey;
	}

	private String parseCacheKey(String strCacheKey, Class<?> targetClass, MethodSignature methodSignature,
			Map<String, Object> paramMap) throws Exception {
		Map<String, Object> data = null;
		Reader in = null;
		String templateName = null;
		Template template = null;
		ByteArrayOutputStream stream = null;
		Writer out = null;
		try {
			data = new HashMap<String, Object>();
			if(paramMap!=null){
				data.putAll(paramMap);
			}
			
			data.put("md5", md5MethodObj);
			data.put("clzName", targetClass.getName());
			data.put("methodName", methodSignature.getMethod().getName());
			data.put("classId", ClientUtils.getClassId());
			data.put("userId", ClientUtils.getUserId());
			data.put("orgId", ClientUtils.getOrgId());

			in = new StringReader(strCacheKey);
			templateName = targetClass.getName().concat(".").concat(methodSignature.getMethod().getName());
			template = new Template(templateName, in, cfg);
			stream = new ByteArrayOutputStream();
			out = new OutputStreamWriter(stream);
			template.process(data, out);
			out.flush();
			return new String(stream.toByteArray(), "UTF-8");
		} catch (Exception e) {
			logger.error("使用freemark解析cacheKey失败", e);
			throw e;
		} finally {
			IoUtils.closeQuietly(stream);
			IoUtils.closeQuietly(out);
		}
	}

	private String replaceArgInfo(String strCacheKey, Map<String, Object> paramMap) throws Exception {
		StringBuffer sbBuffer = new StringBuffer(1024);
		Matcher matcher = null;
		String strParamName = null;
		Class<?> paramClz = null;

		logger.info("替换前的key:" + strCacheKey);
		if (StringUtils.isNotEmpty(strCacheKey) && paramMap != null && !paramMap.isEmpty()) {
			matcher = argPattern.matcher(strCacheKey);
			while (matcher.find()) {
				strParamName = "arg" + matcher.group(1);
				// 参数类型判断
				if (paramMap.containsKey(strParamName)) {
					if(paramMap.get(strParamName)!=null){
						paramClz = paramMap.get(strParamName).getClass();
						if (paramClz.isAssignableFrom(java.lang.Object.class)) {
							throw new Exception("错误:缓存参数类型不能是Object.class类型的对象");
						} else if (paramClz.isAssignableFrom(java.util.List.class) || paramClz.isArray()) {
							matcher.appendReplacement(sbBuffer, "<#list " + strParamName + " as node>_${node}</#list>");
						} else if (paramClz.isAssignableFrom(java.util.Map.class)) {
							matcher.appendReplacement(sbBuffer, "<#list " + strParamName + "?keys as key>_${key}:${"
									+ strParamName + "['${key}']}</#list>");
						} else if (paramClz.isAssignableFrom(java.util.Date.class)) {
							matcher.appendReplacement(sbBuffer, "${date?datetime}");
						}
					}
				} else {
					throw new Exception("错误:参数表达式中存在不合法的参数");
				}
			}
			matcher.appendTail(sbBuffer);
			logger.info("替换后的key:" + sbBuffer.toString());
			return sbBuffer.toString();
		}else{
			return strCacheKey;
		}
		
	}

	private Map<String, Object> converToParamMap(Object[] paramObjects) {
		Map<String, Object> paramMap = null;
		if (paramObjects != null && paramObjects.length > 0) {
			paramMap = new HashMap<String, Object>(paramObjects.length);
			for (int i = 0; i < paramObjects.length; i++) {
				paramMap.put("arg" + i, paramObjects[i]);
			}
		}
		return paramMap;
	}

	private int getCacheTimeSecond(QCacheReader cacheAnno) throws Exception {
		int expireTime = 0;
		switch (cacheAnno.timeUnit()) {
		case MINUTE:
			expireTime = cacheAnno.cacheTime() * 60;
			break;
		case HOUR:
			expireTime = cacheAnno.cacheTime() * 60 * 60;
			break;
		case DAY:
			expireTime = cacheAnno.cacheTime() * 24 * 60 * 60;
			break;
		default:
			expireTime = cacheAnno.cacheTime();
			break;
		}
		return expireTime;
	}
	
	/**
	 * 执行目标方法，只允许执行一次，并保存当前结果
	 * @param pjp
	 * @param key
	 * @throws Throwable
	 */
	private void executeTargetMethod(ProceedingJoinPoint pjp ,String key) throws Throwable{
		String excuteMethodKey= key;
		if(StringUtils.isEmpty(excuteMethodKey)){
			excuteMethodKey = this.getExecuteMethodKey(pjp);
		}
		//是否需要判断是否是void方法
		if(targetMethodResult.get()==null || !targetMethodResult.get().containsKey(excuteMethodKey)){
			Map<String,Object> map = new HashMap<String,Object>();
			map.put(excuteMethodKey, pjp.proceed());
			targetMethodResult.set(map);
		}
	}
	
	/**
	 * 返回并清理ThreadLocal<Map<String, Object>>的MAP中的KEY
	 * @param pjp
	 * @param key
	 * @throws Throwable
	 */
	private Object clearAndReturnMethodResult(ProceedingJoinPoint pjp ,String key) throws Throwable{
		Object result = null;
		String excuteMethodKey= key;
		if(StringUtils.isEmpty(excuteMethodKey)){
			excuteMethodKey = getExecuteMethodKey(pjp);
		}
		//是否需要判断是否是void方法(TODO)
		if(targetMethodResult.get()!=null && targetMethodResult.get().containsKey(excuteMethodKey)){
			result =targetMethodResult.get().get(excuteMethodKey);
			targetMethodResult.get().remove(excuteMethodKey);
		}else{
			result = pjp.proceed();
		}
		return result;
	}
	
	/**
	 * 返回当前目标方法的执行结果存储在ThreadLocal<Map<String, Object>>的MAP中的KEY
	 * @param pjp
	 * @return key
	 */
	private String getExecuteMethodKey(ProceedingJoinPoint pjp){
		MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
		StringBuffer sBuffer = new StringBuffer(512);
		sBuffer.append(Thread.currentThread().getId());
		sBuffer.append('.');
		sBuffer.append(pjp.getTarget().getClass().getName());
		sBuffer.append('.');
		sBuffer.append(methodSignature.getMethod().getName());
		return sBuffer.toString();
	}
	

//	public void test() {
//		
//		ExecutorService es = null;
//		
//		try {
//			int j =0;
//			int size = 1000;
//			while (size>0) {
//				long start = System.currentTimeMillis();
//				++j;
//				size=size-50;
//				
//				this.annoCacheRedis.del("testhget");
//				es = Executors.newFixedThreadPool(1000);
//				System.out.println("testReisConn");
//				for (int i = 0; i < 1000; i++) {
//					es.execute(new TestThread());
//				}
//				es.shutdown();
//				if(es.awaitTermination(1, java.util.concurrent.TimeUnit.HOURS)){
//					System.out.println("线程执行完成");	
//				}
//				long end = System.currentTimeMillis();
//				System.out.println(start-end);
//			}
//		}catch (Exception e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
//		
//	}
//	
//	
//	static class TestThread implements Runnable{
//		public void run() {
//			CommonRedisTemplate commonTemplate = null;
//			ShardedJedis sjedisJedis = null;
//			try {
//				 commonTemplate = SpringUtil.getBean("commonRedisTemplate",CommonRedisTemplate.class);
//					for(int i=0;i<1;i++){
//						sjedisJedis = commonTemplate.getJedisClient();
//						sjedisJedis.incr("testincr1");
//						sjedisJedis.hset("testhget", String.valueOf(Thread.currentThread().getName().concat(String.valueOf(i))), "1234567890");
//						sjedisJedis.hget("testhget", String.valueOf(Thread.currentThread().getName().concat(String.valueOf(i))));
//					}
//			} catch (Exception e) {
//				e.printStackTrace();
//			}finally {
//				commonTemplate.closeJedisClient(sjedisJedis);
//			}
//		}
//		
//	}
	
	
	
}