/**
 * 统一异常处理
 */
@ControllerAdvice
public class ExceptionAdvice {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionAdvice.class);

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public BaseResponse handleException(Exception e) {
        logger.warn("接口出现异常", e);

        // 参数不正异常
        if (e instanceof MissingServletRequestParameterException) {
            return new ResultResponse(ResultCode.ARGUMENT_ERROR, ResultCode.ARGUMENT_ERROR_MSG).setInfo(e.getMessage());
        }

        // 请求方法不支持异常
        if (e instanceof HttpRequestMethodNotSupportedException) {
            return new BaseResponse()
                    .setCode(ResultCode.METHOD_NOT_SUPPORTED)
                    .setMessage(ResultCode.METHOD_NOT_SUPPORTED_MSG);
        }

        return new ResultResponse()
                .setInfo(e.getMessage())
                .setCode(ResultCode.FAIL)
                .setMessage("系统错误");
    }
}

/**
 * 加密返回类型中的result字段
 */
@Component
//这个注解代表处理哪些 Controller，可以根据包名或注解控制，这里用了注解
@ControllerAdvice(annotations = EncryptBody.class)
// 接口上的泛型代表方法的返回类型，一般来说 后端接口会有一个统一的返回类型
public class ResponseAdvice implements ResponseBodyAdvice<BaseResponse> {
    private static final Logger logger = LoggerFactory.getLogger(ResponseAdvice.class);

    // 决定方法是否处理
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 这里的逻辑是被 NotEncryptBody 的方法不处理
        if (Arrays.stream(returnType.getMethodAnnotations())
                .anyMatch(s -> s.annotationType().equals(NotEncryptBody.class))) {
            return false;
        }

        return true;
    }

    @Override
    public BaseResponse beforeBodyWrite(BaseResponse body,
                                        MethodParameter returnType,
                                        MediaType selectedContentType,
                                        Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                        ServerHttpRequest request,
                                        ServerHttpResponse response) {
        if (body == null) {
            final String msg = "返回 body 为 null";
            logger.error(msg);
            return new ResultResponse()
                    .setInfo(msg)
                    .setCode(ResultCode.FAIL)
                    .setMessage(ResultCode.FAIL_MSG);
        }

        if (body instanceof ResultResponse) {
            ResultResponse theRes = (ResultResponse) body;

            Object result = theRes.getResult();

            if (result != null) {
                String toBeEncode = "";
                if (result instanceof String) {
                    toBeEncode = (String) result;
                } else {
                    toBeEncode = JSON.toJSONString(result, SerializerFeature.WriteDateUseDateFormat, SerializerFeature.WriteMapNullValue);
                }
                // 试用sm4加密返回类型中的result字段
                String encode = Sm4Util.encryptEcbDefault(toBeEncode);

                theRes.setResult(encode);

                return theRes;
            }
        }

        return body;
    }
}

/**
 * 线程池工具类
 */
public class ThreadPoolUtil {

    private static ThreadPoolExecutor threadPool;

    /**
     * 无返回值直接执行
     *
     * @param runnable
     */
    public static void execute(Runnable runnable) {
        getThreadPool().execute(runnable);
    }

    /**
     * 返回值直接执行
     *
     * @param callable
     */
    public static <T> Future<T> submit(Callable<T> callable) {
        return getThreadPool().submit(callable);
    }

    /**
     * 关闭线程池
     */
    public static void shutdown() {
        getThreadPool().shutdown();
    }

    /**
     * dcs获取线程池
     *
     * @return 线程池对象
     */
    public static ThreadPoolExecutor getThreadPool() {
        if (threadPool != null) {
            return threadPool;
        } else {
            synchronized (ThreadPoolUtil.class) {
                if (threadPool == null) {
                    threadPool = new ThreadPoolExecutor(8, 16, 60, TimeUnit.SECONDS,
                            new LinkedBlockingQueue<>(64), new ThreadPoolExecutor.CallerRunsPolicy());
                }
                return threadPool;
            }
        }
    }
}