package com.dlbridge.jadp.common.aop;

import com.dlbridge.jadp.common.utils.SpringUtil;
import lombok.extern.log4j.Log4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.ApplicationContext;
import org.springframework.context.expression.BeanFactoryResolver;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Set;

@Component
@Aspect
@Log4j
public class CacheRemoveAspect {

    @Resource
    ValueOperations<String, String> valueOperations;

    @Resource
    ApplicationContext context;

    ExpressionParser parser = new SpelExpressionParser();

    LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();

    @Resource
    SpringUtil springUtil;

    /**
     * 截获标有@CacheRemove的方法
     */
    @Pointcut(value = "(execution(* *.*(..)) && @annotation(com.dlbridge.jadp.common.aop.CacheRemove))")
    private void pointcut() {
    }

    /**
     * 功能描述: 切面在截获方法返回值之后
     */
    @AfterReturning(value = "pointcut()")
    private void process(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        //获取切入方法的数据
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        //获取切入方法
        Method method = signature.getMethod();
        //获得注解
        CacheRemove cacheRemove = method.getAnnotation(CacheRemove.class);
        //注解解析
        String[] params = discoverer.getParameterNames(method);
        EvaluationContext context = new StandardEvaluationContext();
        for (int len = 0; len < params.length; len++) {
            context.setVariable(params[len], args[len]);
        }
        ((StandardEvaluationContext) context).setBeanResolver(new BeanFactoryResolver(
                SpringUtil.beanFactory));
        if (cacheRemove != null) {
            StringBuilder sb = new StringBuilder();
            String value = cacheRemove.value();
            if (!value.equals("")) {
                sb.append(value);
            }
            //需要移除的正则key
            Expression expression = parser.parseExpression(cacheRemove.key());
            String value1 = expression.getValue(context, String.class);
            //指定清除的key的缓存
            cleanRedisCache(cacheRemove.value() + "*" + value1);
        }
    }

    private void cleanRedisCache(String key) {
        if (key != null) {
            //删除缓存
            Set<String> keys = valueOperations.getOperations().keys(key);
            keys.forEach(mykey -> {
                valueOperations.getOperations().delete(mykey);
                log.info("清除 " + mykey + " 缓存");
            });

        }
    }
}