package com.stylefeng.guns.modular.system.controller.util;

import com.google.common.collect.Lists;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.io.*;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class HttpUtils {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    private final static String KEY = "5cc9622f299335639dbc046f3812c52a";

    //请求超时时间
    private final static Integer TIME_OUT = 1000;
    //http连接池
    private static volatile PoolingHttpClientConnectionManager poolingHttpClientConnectionManager;
    //请求配置
    private static RequestConfig requestConfig;

    public static PoolingHttpClientConnectionManager getPoolingHttpClientConnectionManager() {
        if (poolingHttpClientConnectionManager == null) {
            synchronized (HttpUtils.class) {
                if (poolingHttpClientConnectionManager == null) {
                    poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
                    //连接池最大连接数
                    poolingHttpClientConnectionManager.setMaxTotal(1024);
                    //每个路由最大连接数
                    poolingHttpClientConnectionManager.setDefaultMaxPerRoute(32);

                    //配置请求的超时设置
                    requestConfig =
                            RequestConfig.custom().setConnectionRequestTimeout(TIME_OUT).setConnectTimeout(TIME_OUT).setSocketTimeout(TIME_OUT).build();
                }
            }
        }
        return poolingHttpClientConnectionManager;
    }

    public static CloseableHttpClient getHttpClient() {
        return HttpClients.custom().setConnectionManager(getPoolingHttpClientConnectionManager()).setDefaultRequestConfig(requestConfig).build();
    }

    /**
     * 请求发送执行
     *
     * @param httpMethd
     * @return
     */
    public String registRequest(HttpUriRequest httpMethd) {
        CloseableHttpClient httpClient = getHttpClient();
        CloseableHttpResponse httpResponse = null;
        try {
            httpResponse = httpClient.execute(httpMethd, HttpClientContext.create());
            int statusCode = httpResponse.getStatusLine().getStatusCode();
            if (httpResponse.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
                log.error("响应失败 statusCode {}", statusCode);
                httpMethd.abort();
            }
            log.debug("响应成功 statusCode {}", statusCode);
            String response = EntityUtils.toString(httpResponse.getEntity(), Consts.UTF_8);
            log.debug("响应成功 response {}", response);
            return response;
        } catch (ConnectTimeoutException e) {
            throw new RuntimeException("接口超时");
        } catch (SocketTimeoutException e) {
            throw new RuntimeException("读取接口数据超时");
        } catch (IOException e) {
            throw new RuntimeException("接口请求失败，请尝试检查网络环境或请求接口是否能正常访问");
        } finally {
            // 关闭响应
            try {
                if (httpResponse != null) {
                    httpResponse.close();
                }
                // 关闭连接
                //httpClient.close();
            } catch (IOException e) {
                throw new RuntimeException("关闭流异常:IOException");
            }
        }
    }

    /**
     * 请求发送执行
     *
     * @param url
     * @return
     */
    public String registRequest(String url, File file) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse httpResponse = null;
        try  {
        HttpPost httpPost = new HttpPost(url);
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(10000)
                .setConnectTimeout(5000)
                .build();
        httpPost.setConfig(requestConfig);
        HttpEntity entity = MultipartEntityBuilder.create().addPart("img", new FileBody(file)).build();
        httpPost.setEntity(entity);
         httpResponse = httpClient.execute(httpPost);
        int statusCode = httpResponse.getStatusLine().getStatusCode();
        if (httpResponse.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
            log.error("响应失败 statusCode {}", statusCode);
            httpPost.abort();
        }
        log.debug("响应成功 statusCode {}", statusCode);
        String response = EntityUtils.toString(httpResponse.getEntity(), Consts.UTF_8);
        log.debug("响应成功 response {}", response);
        return response;
        } catch (ConnectTimeoutException e) {
            throw new RuntimeException("接口超时");
        } catch (SocketTimeoutException e) {
            throw new RuntimeException("读取接口数据超时");
        } catch (IOException e) {
            throw new RuntimeException("接口请求失败，请尝试检查网络环境或请求接口是否能正常访问");
        } finally {
            // 关闭响应
            try {
                if (httpResponse != null) {
                    httpResponse.close();
                }
                // 关闭连接
                httpClient.close();
            } catch (IOException e) {
                throw new RuntimeException("关闭流异常:IOException");
            }
        }
    }

    /**
     *
     * @param type
     * @param file
     * @return
     * @throws Exception
     */
    public String ocr(String type, File file){
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String result = null;
        // HttpClient请求的相关设置，可以不用配置，用默认的参数，这里设置连接和超时时长(毫秒)
        RequestConfig config = RequestConfig.custom().setConnectTimeout(30000).setSocketTimeout(30000).build();
        try {
            HttpPost httppost = new HttpPost("http://v.juhe.cn/certificates/query");
            // FileBody封装File类型的参数
            FileBody bin = new FileBody(file);
            // StringBody封装String类型的参数
            StringBody keyBody = new StringBody(KEY, ContentType.TEXT_PLAIN);
            StringBody typeBody = new StringBody(type, ContentType.TEXT_PLAIN);
            // addPart将参数传入，并指定参数名称
            HttpEntity reqEntity = MultipartEntityBuilder.create()
                    .addPart("pic", bin).addPart("key", keyBody)
                    .addPart("cardType", typeBody).build();
            httppost.setEntity(reqEntity);
            httppost.setConfig(config);
            // 执行网络请求并返回结果
            response = httpClient.execute(httppost);
            HttpEntity resEntity = response.getEntity();
            if (resEntity != null) {
                result = ConvertStreamToString(resEntity.getContent(), "UTF-8");
            }
            EntityUtils.consume(resEntity);
        } catch (Exception e) {
            throw new RuntimeException("接口请求失败，请尝试检查网络环境或请求接口是否能正常访问"+":"+e);
        } finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                throw new RuntimeException("流关闭失败!"+":"+e);
            }
        }
        // 得到的是JSON类型的数据需要第三方解析JSON的jar包来解析
        return result;
    }

    // 此方法是把传进的字节流转化为相应的字符串并返回，此方法一般在网络请求中用到
    public static String ConvertStreamToString(InputStream is, String charset)
            throws Exception {
        StringBuilder sb = new StringBuilder();
        try (InputStreamReader inputStreamReader = new InputStreamReader(is,charset)) {
            try (BufferedReader reader = new BufferedReader(inputStreamReader)) {
                String line = null;
                while ((line = reader.readLine()) != null) {
                    sb.append(line).append("\r\n");
                }
            }
        }
        return sb.toString();
    }

    public List<BasicNameValuePair> toPairs(Map<String, Object> params) {
        List<BasicNameValuePair> pairs = Lists.newArrayList();
        if (params != null && !params.isEmpty()) {
            pairs = params.entrySet().stream().map(entry -> new BasicNameValuePair(entry.getKey(),
                    entry.getValue().toString())).collect(Collectors.toList());
        }
        return pairs;
    }

    /**
     * get url请求
     *
     * @param url
     * @return
     */
    public String get(String url) {
        HttpGet request = new HttpGet();
        try {
            request.setURI(new URI(url));
            return registRequest(request);
        } catch (Exception e) {
            log.error("请求失败", e);
        }
        return null;
    }

    /**
     * PSOT URL方式提交
     *
     * @param url    请求url
     * @param params 请求参数
     * @return
     */
    public String postFromUrl(String url, Map<String, Object> params) {
        HttpPost request = new HttpPost(url);
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(10000)
                .setConnectTimeout(5000)
                .build();
        request.setConfig(requestConfig);
        request.setEntity(new UrlEncodedFormEntity(toPairs(params), Consts.UTF_8));
        return registRequest(request);
    }

    /**
     * PSOT JSON方式提交
     *
     * @param url    请求url
     * @param params json串
     * @return
     */
    public String postFromJson(String url, String params) {
        HttpPost request = new HttpPost(url);
        request.setHeader("Content-type", "application/json");
        request.setHeader("Accept", "application/json");
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(8000)
                .setConnectTimeout(6000)
                .build();
        request.setConfig(requestConfig);
        StringEntity entity = new StringEntity(params, StandardCharsets.UTF_8);
        entity.setContentType("application/json");
        request.setEntity(entity);
        try {
            return registRequest(request);
        } catch (Exception e) {
            log.error("请求失败", e);
        }
        return null;
    }
}