package com.marquis.chen.server.utils;

import cn.hutool.core.convert.Convert;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * 客户端工具类
 *
 * @author marquis.chen
 */
@Slf4j
public class ServletUtils {

    /**
     * 获取Request参数，返回String类型
     *
     * @param name 参数名
     */
    public static String getParameter(String name) {
        return getRequest().getParameter(name);
    }

    /**
     * 获取Request参数，返回指定类型
     *
     * @param name  参数名
     * @param clazz 参数类型
     */
    public static <T> T getParameter(String name, Class<T> clazz) {
        return Convert.convert(clazz, getRequest().getParameter(name));
    }

    /**
     * 获取Request参数，如果为空或转换失败返回默认值
     *
     * @param name         参数名
     * @param defaultValue 默认值
     */
    public static <T> T getParameter(String name, T defaultValue) {
        return Convert.convert(defaultValue.getClass(), getRequest().getParameter(name), defaultValue);
    }

    /**
     * 获取所有query参数，返回Map
     *
     * @return {@link Map}
     */
    public static Map<String, String> getParameters() {
        return getParameters(null);
    }

    /**
     * 获取所有query参数，返回Map
     *
     * @param request ServletRequest
     * @return {@link Map}
     */
    public static Map<String, String> getParameters(HttpServletRequest request) {
        if (request == null) {
            request = getRequest();
        }
        Enumeration<String> parameterNames = request.getParameterNames();
        HashMap<String, String> map = new HashMap<>(16);
        while (parameterNames.hasMoreElements()) {
            String key = parameterNames.nextElement();
            map.put(key, request.getParameter(key));
        }
        return map;
    }

    /**
     * 获取body参数
     */
    public static String getBody(HttpServletRequest request) {
        if (request == null) {
            request = getRequest();
        }
        StringBuilder data = new StringBuilder();
        BufferedReader reader = null;
        try (InputStream inputStream = request.getInputStream()) {
            reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
            String line = "";
            while ((line = reader.readLine()) != null) {
                data.append(line);
            }
        } catch (IOException e) {
            log.warn("获取body数据出错！");
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    log.error(ExceptionUtils.getMessage(e));
                }
            }
        }
        return data.toString();
    }

    /**
     * 获取body参数
     */
    public static String getBody() {
        return getBody(null);
    }

    /**
     * 获取request
     */
    public static HttpServletRequest getRequest() {
        return getRequestAttributes().getRequest();
    }

    /**
     * 获取response
     */
    public static HttpServletResponse getResponse() {
        return getRequestAttributes().getResponse();
    }

    /**
     * 获取session
     */
    public static HttpSession getSession() {
        return getRequest().getSession();
    }

    public static ServletRequestAttributes getRequestAttributes() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return (ServletRequestAttributes) attributes;
    }

    /**
     * 将字符串渲染到客户端
     *
     * @param response 渲染对象
     * @param string   待渲染的字符串
     * @return null
     */
    public static void renderString(HttpServletResponse response, String string) {
        renderString(response, string, "application/json");
    }

    /**
     * 将字符串渲染到客户端
     *
     * @param response    渲染对象
     * @param string      待渲染的字符串
     * @param contentType 响应内容类型
     */
    public static void renderString(HttpServletResponse response, String string, String contentType) {
        try {
            response.setStatus(200);
            response.setContentType(contentType);
            response.setCharacterEncoding(StandardCharsets.UTF_8.displayName());
            response.getWriter().print(string);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 是否是Ajax异步请求
     *
     * @param request
     */
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String accept = request.getHeader("accept");
        if (accept != null && accept.contains("application/json")) {
            return true;
        }

        String xRequestedWith = request.getHeader("X-Requested-With");
        if (xRequestedWith != null && xRequestedWith.contains("XMLHttpRequest")) {
            return true;
        }

        String uri = request.getRequestURI();
        if (StringUtils.equalsAnyIgnoreCase(uri, ".json", ".xml")) {
            return true;
        }

        String ajax = request.getParameter("__ajax");
        if (StringUtils.equalsAnyIgnoreCase(ajax, "json", "xml")) {
            return true;
        }
        return false;
    }

    /**
     * 获取完整的请求路径，包括：域名，端口，上下文访问路径
     *
     * @return 服务地址
     */
    public static String getServerUrl() {
        HttpServletRequest request = getRequest();
        StringBuffer url = request.getRequestURL();
        String contextPath = request.getServletContext().getContextPath();
        // Nginx代理需要配置 proxy_set_header X-Forwarded-Scheme $scheme;
        String scheme = request.getHeader("X-Forwarded-Scheme");
        String domain = url.delete(url.length() - request.getRequestURI().length(), url.length()).append(contextPath).toString();
        if (StringUtils.isNotBlank(scheme)) {
            domain =  domain.replaceFirst("https?", scheme);
        }
        return domain;
    }
}

# Java