package com.changhong.epc.zuul.util;

import com.alibaba.fastjson.TypeReference;
import com.iemsoft.framework.cloud.core.constant.BaseConst;
import com.iemsoft.framework.cloud.core.tools.JSONTool;
import com.iemsoft.framework.cloud.core.tools.ObjectUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.*;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
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.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
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.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeoutException;

@Slf4j
public class HttpUtil {
    private static final String HTTP = "http";
    private static final String HTTPS = "https";
    private static SSLConnectionSocketFactory sslsf = null;
    private static PoolingHttpClientConnectionManager cm = null;
    private static SSLContextBuilder builder = null;
	public static final String APPLICATION_JSON = "application/json;charset=utf-8";
    static {
        try {
            builder = new SSLContextBuilder();
            // 全部信任 不做身份鉴定
            builder.loadTrustMaterial(null, new TrustStrategy() {
                @Override
                public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                    return true;
                }
            });
            sslsf = new SSLConnectionSocketFactory(builder.build(), new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register(HTTP, new PlainConnectionSocketFactory())
                    .register(HTTPS, sslsf)
                    .build();
            cm = new PoolingHttpClientConnectionManager(registry);
            cm.setMaxTotal(200);//max connection
        } catch (Exception e) {
            // System.err.println(e.getMessage());
        }
    }
    
    public static <T> T get(String url, Map<String, String> header, Class<T> result) throws TimeoutException {
        try (CloseableHttpClient httpClient = url.startsWith("https") ? getHttpClient() : HttpClients.createDefault()){

            HttpGet httpGet = new HttpGet(url);
            // 设置头信息
            if (ObjectUtil.notEmpty(header)) {
                for (Map.Entry<String, String> entry : header.entrySet()) {
                	httpGet.addHeader(entry.getKey(), entry.getValue());
                }
            }
            HttpResponse httpResponse = httpClient.execute(httpGet);
            int statusCode = httpResponse.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                HttpEntity resEntity = httpResponse.getEntity();
                String str = EntityUtils.toString(resEntity, BaseConst.PROJECT_CHARSET);
                if(ObjectUtil.notEmpty(str)){
                	return JSONTool.toObj(str, result);
                }
                return null;
            } else {
            	readHttpResponse(httpResponse);
            	return null;
            }
        } catch (Exception e) {
        	throw new TimeoutException();
        }
    }
    
    /**
     * httpClient post请求
     * @param url 请求url
     * @param header 头部信息
     * @param param 请求参数 form提交适用
     * @return 可能为空 需要处理
     * @throws Exception
     *
     */
    public static <T> T post(String  url, Map<String, String> header, Map<String, ? extends Object> param, Object body, TypeReference<T> type) throws Exception {
        String result = "";
        try (CloseableHttpClient httpClient = url.startsWith("https") ? getHttpClient() : HttpClients.createDefault()){
        	log.debug("开始发送请求:{}", url);
        	log.debug("header:{}", JSONTool.toJson(header));
        	log.debug("body  :{}", JSONTool.toJson(body));
            HttpPost httpPost = new HttpPost(url);
            // 设置头信息
            if (ObjectUtil.notEmpty(header)) {
                for (Map.Entry<String, String> entry : header.entrySet()) {
                    httpPost.addHeader(entry.getKey(), entry.getValue());
                }
            }
            // 设置请求参数
            if (ObjectUtil.notEmpty(param)) {
                List<NameValuePair> formparams = new ArrayList<NameValuePair>();
                for (Map.Entry<String, ? extends Object> entry : param.entrySet()) {
                    //给参数赋值
                    formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
                }
                UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
                httpPost.setEntity(urlEncodedFormEntity);
            }
            // 设置实体 优先级高
            if (body != null) {
            	StringEntity stringEntity = new StringEntity(JSONTool.toJson(body), BaseConst.PROJECT_CHARSET);
            	stringEntity.setContentType(APPLICATION_JSON);
                httpPost.setEntity(stringEntity);
            }
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int statusCode = httpResponse.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                HttpEntity resEntity = httpResponse.getEntity();
                result = EntityUtils.toString(resEntity);
                log.debug("response:{}", result);
            } else {
            	log.error("请求url:{}", url);
            	log.error("response:{}", readHttpResponse(httpResponse));
            }
        } catch (Exception e) {throw e;
        }
        return JSONTool.toObj(result, type);
    }
    

	public static String getParam(Map<String, Object> param){
		if(ObjectUtil.empty(param)){
			return "";
		}
		StringBuilder query = new StringBuilder();
		for (Map.Entry<String, Object> entry : param.entrySet()) {
			query.append(entry.getKey()).append('=').append(entry.getValue()).append('&');
		}
		query.deleteCharAt(query.length()-1);
		return query.toString();
	}
    
    public static CloseableHttpClient getHttpClient() {
        CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .setConnectionManager(cm)
                .setConnectionManagerShared(true)
                .build();
        return httpClient;
    }
    public static String readHttpResponse(HttpResponse httpResponse)
            throws ParseException, IOException {
        StringBuilder builder = new StringBuilder();
        // 获取响应消息实体
        HttpEntity entity = httpResponse.getEntity();
        // 响应状态
        builder.append("status:" + httpResponse.getStatusLine());
        builder.append("headers:");
        HeaderIterator iterator = httpResponse.headerIterator();
        while (iterator.hasNext()) {
            builder.append("\t" + iterator.next());
        }
        // 判断响应实体是否为空
        if (entity != null) {
            String responseString = EntityUtils.toString(entity);
            builder.append("response length:" + responseString.length());
            builder.append("response content:" + responseString.replace("\r\n", ""));
        }
        return builder.toString();
    }
    
   
}