package com.jzq.common.http;

import com.alibaba.fastjson.JSONObject;
import com.jzq.common.CommonUtil;
import com.jzq.common.ResultInfo;
import com.jzq.common.exception.ResultInfoException;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.HttpRequestRetryHandler;
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.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.ByteArrayBody;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.InputStreamBody;
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.client.LaxRedirectStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.ExecutionContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.File;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.io.UnsupportedEncodingException;
import java.net.ConnectException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.UnknownHostException;
import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * http的请求服务类
 * 也可以考虑使用spring restTemplate调用
 */
public class HttpClientUtils {
    public static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
    private static Object objTg = new Object();
    private static HttpClientUtils httpClientUtils;
    /**
     * 默认连接超时时间
     */
    private final static int DEFAULT_CONN_TIMEOUT = 6000;
    /**最大重试次数*/
    private final static int DEFAULT_RETRY_TIMES = 3;

    private CloseableHttpClient client;

    /**
     * ssl trust管理
     */
    public static class SSLTrustAllManager implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    }

    /**
     * 初始化ssl管理
     * @return
     * @throws KeyStoreException
     * @throws CertificateException
     * @throws NoSuchAlgorithmException
     * @throws IOException
     * @throws KeyManagementException
     */
    private SSLConnectionSocketFactory initSSLConnectionSocketFactory() throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException, KeyManagementException {
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        trustStore.load(null, null);
        SSLContext sslcontext = SSLContexts.custom()
                .loadTrustMaterial(trustStore,
                        new TrustSelfSignedStrategy())
                .build();
        sslcontext.init(null, new TrustManager[] { new SSLTrustAllManager() }, null);
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext,
                //new String[] { "TLSv1","TLSv1.1","TLSv1.2","SSLv3"},//参考ProtocolVersion//这里写为null为所有
                null,
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        return sslsf;
    }


    public HttpClientUtils() throws Exception {
        // 设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", initSSLConnectionSocketFactory())
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        connManager.setValidateAfterInactivity(1000);
        ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setMalformedInputAction(CodingErrorAction.IGNORE)
                .setUnmappableInputAction(CodingErrorAction.IGNORE)
                .setCharset(Consts.UTF_8)
                .build();
        connManager.setDefaultConnectionConfig(connectionConfig);
        connManager.setMaxTotal(100);
        connManager.setDefaultMaxPerRoute(10);//最大路由深度，即301次数

        //默认头信息,创建自定义的httpclient对象
        List<Header> defaultHeaders=new ArrayList<Header>();
        defaultHeaders.add(new BasicHeader("Accept","text/html,application/xhtml+xml,application/xml,application/json;q=0.9,*/*;q=0.8"));
        defaultHeaders.add(new BasicHeader("Accept-Language","zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"));
        defaultHeaders.add(new BasicHeader("Connection","close"));
        defaultHeaders.add(new BasicHeader("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:59.0) Gecko/20100101 Firefox/59.0"));
        //默认请求配置
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(DEFAULT_CONN_TIMEOUT)
                .setConnectTimeout(DEFAULT_CONN_TIMEOUT)
                //.setProxy(new HttpHost("myotherproxy", 8080)) //设置代理
                .setConnectionRequestTimeout(DEFAULT_CONN_TIMEOUT).build();
        //重试拦截
        HttpRequestRetryHandler myRetryHandler = new HttpRequestRetryHandler() {
            @Override
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                if (executionCount >= DEFAULT_RETRY_TIMES) {
                    //Do not retry if over max retry count
                    return false;
                }
                if (exception instanceof InterruptedIOException) {
                    // Timeout
                    return false;
                }
                if (exception instanceof UnknownHostException) {
                    // Unknown host
                    return false;
                }
                if (exception instanceof ConnectException) {
                    // Connection refused
                    return false;
                }
                if (exception instanceof SSLException) {
                    // SSL handshake exception
                    return false;
                }
                HttpRequest request = (HttpRequest) context.getAttribute(ExecutionContext.HTTP_REQUEST);
                boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
                if (idempotent) {
                    return true;
                }
                return false;
            }
        };

        client = HttpClients.custom()
                .setConnectionManager(connManager)
                .setDefaultHeaders(defaultHeaders)
                .setDefaultRequestConfig(requestConfig)
                .setRetryHandler(myRetryHandler)
                .setRedirectStrategy(new LaxRedirectStrategy())
                .build();
    }
    /**
     * init实例
     * @return
     */
    public static HttpClientUtils init(){
        synchronized (objTg) {
            if (httpClientUtils == null) {
                try {
                    httpClientUtils = new HttpClientUtils();
                } catch (Exception e) {
                    throw new ResultInfoException("ACCESS_SIGN_ERROR","httpClient初始化出错",e);
                }
            }
        }
        return httpClientUtils;
    }


    /**
     * 工具类,通过url和params 生成url地址
     * @param url
     * @param params
     * @return
     * @throws URISyntaxException
     */
    public static URI builderUrl(String url, Map<String, Object> params){
        URIBuilder builder = null;
        try {
            builder = new URIBuilder(url);
            if(params!=null&&params.size()>0){
                for(String key: params.keySet()){
                    Object obj=params.get(key);
                    if(obj==null){continue;}
                    builder.setParameter(key, CommonUtil.parValNoErr(obj, String.class));
                }
            }
            return builder.build();
        } catch (URISyntaxException e) {
           throw new ResultInfoException("HTTP_URL_FORMART","转换地址出错:"+url,e);
        }
    }

    public static void fillHeader(HttpRequestBase request, Map<String, Object> heads){
        //请求头
        if (heads != null && heads.size() > 0) {
            for (String key : heads.keySet()) {
                request.addHeader(key, heads.get(key) + "");
            }
        }
    }
    /**
     * get请求
     * @param uri
     * @param heads
     * @param params
     * @return
     * @throws Exception
     */
    public String getGet(String uri, Map<String, Object> heads, Map<String, Object> params) {
        HttpGet request = new HttpGet(builderUrl(uri,params));
        fillHeader(request,heads);
        CloseableHttpResponse response = null;
        try {
            response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) {
                // 获得返回的字符串
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                return result;
            } else {
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                result= StringUtils.isNotBlank(result)?result.substring(0,result.length()>200?200:result.length()) : "";
                ResultInfo<String> res=new ResultInfo<String>();
                res.setData(result);
                res.setSuccess(false);
                res.setResultCode(response.getStatusLine().getStatusCode()+"");
                throw new ResultInfoException("HTTP_RESPONSE_ERROR", JSONObject.toJSONString(res));
            }
        } catch (IOException e) {
            throw new ResultInfoException("EXCEPTION","网络请求失败",e);
        } finally {
            try {
                response.close();
            } catch (Exception e) {}
        }
    }

    public byte[] getGetByte(String uri, Map<String, Object> heads, Map<String, Object> params) {
        HttpGet request = new HttpGet(builderUrl(uri,params));
        fillHeader(request,heads);
        CloseableHttpResponse response = null;
        try {
            response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) {
                // 获得返回的字符串
                byte[] result = EntityUtils.toByteArray(response.getEntity());
                return result;
            } else {
                ResultInfo<String> res=new ResultInfo<String>();
                res.setSuccess(false);
                res.setResultCode(response.getStatusLine().getStatusCode()+"");
                throw new ResultInfoException("HTTP_RESPONSE_ERROR", JSONObject.toJSONString(res));
            }
        } catch (IOException e) {
            throw new ResultInfoException("EXCEPTION","网络请求失败",e);
        } finally {
            try {
                response.close();
            } catch (Exception e) {}
        }
    }

    /**
     * 直接获取返回体,注意要手动关闭response
     * @param uri
     * @param heads
     * @param params
     * @return
     */
    public CloseableHttpResponse getGetResponse(String uri, Map<String, Object> heads, Map<String, Object> params) throws IOException {
        HttpGet request = new HttpGet(builderUrl(uri,params));
        fillHeader(request,heads);
        CloseableHttpResponse response = null;
        response = client.execute(request);
        return response;
    }

    /**
     * 构建post的body信息,
     * @param request
     * @param params
     * @param ifMutipart 是否启用富文件方式上传
     */
    private void buildPostBody(HttpPost request, Map<String, Object> params, boolean ifMutipart){
        if(ifMutipart){
            //富文本请求
            MultipartEntityBuilder meBuiler = MultipartEntityBuilder.create();
            if (params != null && params.size() > 0) {
                for (String key : params.keySet()) {
                    Object obj = params.get(key);
                    if(obj==null){
                        continue;
                    }else if (obj instanceof File) {
                        FileBody fb = new FileBody((File) obj);
                        meBuiler.addPart(key, fb);
                    } else if (obj instanceof ByteArrayBody) {
                        meBuiler.addPart(key, (ByteArrayBody) obj);
                    } else if (obj instanceof FileBody) {
                        meBuiler.addPart(key, (FileBody) obj);
                    } else if (obj instanceof InputStreamBody) {
                        meBuiler.addPart(key, (InputStreamBody) obj);
                    }else {
                        StringBody sb = new StringBody(CommonUtil.parValNoErrDef(obj, String.class, ""), ContentType.create("text/plain", "UTF-8"));
                        meBuiler.addPart(key, sb);
                    }
                }
            }
            HttpEntity httpEntity = meBuiler.build();
            request.setEntity(httpEntity);
        }else{
            //普通请求
            List<NameValuePair> pList = new ArrayList<NameValuePair>();
            if (params != null && params.size() > 0) {
                for (String key : params.keySet()) {
                    Object obj=params.get(key);
                    if(obj==null){continue;}
                    pList.add(new BasicNameValuePair(key, obj + ""));
                }
            }
            try {
                request.setEntity(new UrlEncodedFormEntity(pList, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                throw new ResultInfoException("HTTP_REQ_ENCODE_ERROR","请求参数格式化出错",e);
            }
        }
    }

    /**
     * post的上传请求
     * @param uri
     * @param heads
     * @param params
     * @return
     * @throws Exception
     */
    public String getPost(String uri, Map<String, Object> heads, Map<String, Object> params, boolean ifMutipart) {
        HttpPost request = new HttpPost(uri);
        fillHeader(request,heads);
        buildPostBody(request,params,ifMutipart);
        CloseableHttpResponse response = null;
        try {
            response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) {
                // 获得返回的字符串
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                return result;
            } else {
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                result= StringUtils.isNotBlank(result) ?result.substring(0,result.length()>200?200:result.length()) : "";
                ResultInfo<String> res=new ResultInfo<String>();
                res.setData(result);
                res.setSuccess(false);
                res.setResultCode(response.getStatusLine().getStatusCode()+"");
                throw new ResultInfoException("HTTP_RESPONSE_ERROR", JSONObject.toJSONString(res));
            }
        } catch (IOException e) {
            throw new ResultInfoException("HTTP_IO_ERROR","网络请求失败",e);
        } finally {
            try {
                response.close();
            } catch (Exception e) {}
        }
    }

    /**
     * post的上传请求，返回byte[]
     * @param uri
     * @param heads
     * @param params
     * @return
     * @throws Exception
     */
    public byte[] getPostByte(String uri, Map<String, Object> heads, Map<String, Object> params, boolean ifMutipart) {
        HttpPost request = new HttpPost(uri);
        fillHeader(request,heads);
        buildPostBody(request,params,ifMutipart);
        CloseableHttpResponse response = null;
        try {
            response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) {
                // 获得返回的byte[]
                byte[] result = EntityUtils.toByteArray(response.getEntity());
                return result;
            } else {
                ResultInfo<String> res=new ResultInfo<String>();
                res.setSuccess(false);
                res.setResultCode(response.getStatusLine().getStatusCode()+"");
                throw new ResultInfoException("HTTP_RESPONSE_ERROR", JSONObject.toJSONString(res));
            }
        } catch (IOException e) {
            throw new ResultInfoException("HTTP_IO_ERROR","网络请求失败",e);
        } finally {
            try {
                response.close();
            } catch (Exception e) {}
        }
    }

    /**
     * post的上传请求，返回CloseableHttpResponse,必须手动关闭
     * @param uri
     * @param heads
     * @param params
     * @return
     * @throws Exception
     */
    public CloseableHttpResponse getPostResponse(String uri, Map<String, Object> heads, Map<String, Object> params, boolean ifMutipart) {
        HttpPost request = new HttpPost(uri);
        fillHeader(request,heads);
        buildPostBody(request,params,ifMutipart);
        CloseableHttpResponse response = null;
        try {
            response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) {
                return response;
            } else {
                String result = EntityUtils.toString(response.getEntity(), "UTF-8");
                result= StringUtils.isNotBlank(result)?result.substring(0,result.length()>200?200:result.length()) : "";
                ResultInfo<String> res=new ResultInfo<String>();
                res.setData(result);
                res.setSuccess(false);
                res.setResultCode(response.getStatusLine().getStatusCode()+"");
                throw new ResultInfoException("HTTP_RESPONSE_ERROR", JSONObject.toJSONString(res));
            }
        } catch (IOException e) {
            throw new ResultInfoException("HTTP_IO_ERROR","网络请求失败",e);
        } finally {
            try {
                response.close();
            } catch (Exception e) {}
        }
    }
}