package com.moon.server.aspect;

import com.moon.server.annotation.SysLog;
import com.moon.server.entity.all.StaticData;
import com.moon.server.entity.sys.OperateEntity;
import com.moon.server.entity.sys.UserEntity;
import com.moon.server.helper.AsyncHelper;
import com.moon.server.helper.WebHelper;
import com.moon.server.service.sys.OperateService;
import com.moon.server.service.sys.TokenService;
import io.swagger.annotations.Api;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.TimerTask;

@Aspect
@Component
@SuppressWarnings("ALL")
public class LogAspect {
    @Autowired
    private TokenService tokenService;

    @Autowired
    private OperateService operateService;

    private final static String SELECT = "select";

    private final static String INSERT = "insert";

    private final static String UPDATE = "update";

    private final static String DELETE = "delete";

    private final static String UPLOAD = "upload";

    private final static String DOWNLOAD = "download";

    private final static String COUNT = "count";

    private static final Log log = LogFactory.getLog(LogAspect.class);

    @Pointcut("@annotation(com.moon.server.annotation.SysLog)")
    public void logPointCut() {
        //
    }

    /**
     * @Around,@Before,@After
     */
    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();

        Object result = point.proceed();

        long time = System.currentTimeMillis() - beginTime;

        saveLog(point, time);

        return result;
    }

    private void saveLog(ProceedingJoinPoint joinPoint, long time) {
        try {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Class<?> clazz = joinPoint.getTarget().getClass();
            Method method = signature.getMethod();

            HttpServletRequest req = WebHelper.getRequest();
            String url = req.getServletPath();

            OperateEntity oe = new OperateEntity();
            oe.setIp(WebHelper.getIpAddress(req));
            oe.setUrl(url);
            oe.setExec(time);

            Api api = clazz.getAnnotation(Api.class);
            if (api != null) {
                String[] strs = api.tags()[0].split(StaticData.BACKSLASH);
                oe.setModular1(strs[0]);
                oe.setModular2(strs[1]);
            }

            oe.setClazz(clazz.getName() + "." + method.getName());
            oe.setType(getType(method.getName()));

            SysLog sysLog = method.getAnnotation(SysLog.class);
            if (sysLog != null) {
                oe.setBak(sysLog.value());
            }

            UserEntity ue = tokenService.getCurrentUser(req);
            if (ue != null) {
                oe.setUserid(ue.getId());
            }

            // operateService.insertOperate(oe)
            AsyncHelper helper = new AsyncHelper();
            helper.execute(new TimerTask() {
                @Override
                public void run() {
                    operateService.insertOperate(oe);
                }
            });
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
    }

    private static int getType(String methodName) {
        if (methodName.contains(SELECT)) {
            return 1;
        }
        if (methodName.contains(INSERT)) {
            return 2;
        }
        if (methodName.contains(UPDATE)) {
            return 3;
        }
        if (methodName.contains(DELETE)) {
            return 4;
        }
        if (methodName.contains(UPLOAD)) {
            return 5;
        }
        if (methodName.contains(DOWNLOAD)) {
            return 6;
        }
        // methodName.indexOf(COUNT) > -1
        if (methodName.contains(COUNT)) {
            return 7;
        }

        return 0;
    }
}