package com.jd.buy.giftshop.shared.utils.aspect;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.annotation.PostConstruct;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jd.buy.giftshop.shared.utils.mapper.JsonMapper;
import com.jd.ump.profiler.CallerInfo;
import com.jd.ump.profiler.proxy.Profiler;

/**
 * UmpLog切面
 * 
 * 注意：如果把spring mvc的Controller
 * 作为切入点，下边的xml配置必须和springmvc-servlet.xml放一起，不然不起作用！！！
 * 
 * @author YANGLiiN
 * @date 13-8-15 上午11:11
 */

// implements InitializingBean
public class UmpLogAspect {

    private static final Logger logger = LoggerFactory.getLogger(UmpLogAspect.class);
    private JsonMapper jsonMapper = new JsonMapper();

    private boolean enable = true;
    private String system;
    private int maxExecTime = 1000;
    private Map<String, String> umpMaps = new HashMap<String, String>();
    private Set<String> whiteMethod = new HashSet<String>();

    public Object execUmpLog(ProceedingJoinPoint jp) throws Throwable {
        MethodSignature ms = (MethodSignature) jp.getSignature();
        String className = jp.getTarget().getClass().getName();
        String methodName = ms.getName();

        CallerInfo callerInfo = null;
        Object rs = null;
        long start;

        try {
            if (enable) {

                if ((!methodName.startsWith("get") && !methodName.startsWith("set"))
                    || whiteMethod.contains(methodName)) {
                    String umpLogKey = umpMaps.get(className);
                    if (umpLogKey != null && !"".equals(umpLogKey)) {
                        StringBuilder sb = new StringBuilder(system).append(".")
                                                                    .append(umpLogKey)
                                                                    .append(".")
                                                                    .append(methodName);
                        String jproKey = sb.toString();

                        callerInfo = Profiler.registerInfo(jproKey, false, true);

                    }
                }

            }
            start = System.currentTimeMillis();
            rs = jp.proceed();
            long time = System.currentTimeMillis() - start;

            if (time > maxExecTime) {
                logger.info("***调用【{}】方法执行耗时【{}ms】***", className
                                                        + "."
                                                        + methodName, time);
            }

        }
        catch (Throwable e) {
            if (callerInfo != null) {
                Profiler.functionError(callerInfo);
            }
            logger.error("***参数列表【{}】,执行结果【{}】,异常堆栈【{}】***",
                         jsonMapper.toJson(jp.getArgs()),
                         jsonMapper.toJson(rs),
                         e);

            throw e;

        }
        if (callerInfo != null) {
            Profiler.registerInfoEnd(callerInfo);
        }

        return rs;

    }

    @PostConstruct
    public void afterPropertiesSet() throws Exception {
        if (enable) {
            Profiler.InitHeartBeats(system + ".heart");
            Profiler.registerJVMInfo(system + ".jvm");
        }

    }

    public void setEnable(boolean enable) {
        this.enable = enable;
    }

    public void setMaxExecTime(int maxExecTime) {
        this.maxExecTime = maxExecTime;
    }

    public void setSystem(String system) {
        this.system = system;
    }

    public void setUmpMaps(Map<String, String> umpMaps) {
        this.umpMaps = umpMaps;
    }

    public void setWhiteMethod(Set<String> whiteMethod) {
        this.whiteMethod = whiteMethod;
    }
}