package com.zteits.park.util;



import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.Map;

import javax.net.ssl.SSLContext;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * User: rizenguo
 * Date: 2014/10/29
 * Time: 14:36
 */
public class Https2yz{

    private static final Logger log = LoggerFactory.getLogger(Https2yz.class);
    /**表示请求器是否已经做了初始化工作*/
    private boolean hasInit = false;

    /**连接超时时间，默认10秒*/
    private int socketTimeout = 10000;

    /**传输超时时间，默认30秒*/
    private int connectTimeout = 30000;

    //请求器的配置
    private RequestConfig requestConfig;

    //HTTP请求器
    private CloseableHttpClient httpClient;

    private void init() throws IOException, KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException, KeyManagementException {

        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try {
            keyStore.load(Https2yz.class.getClassLoader().getResourceAsStream("yztingche.cn.p12"), null);//设置证书密码
        } catch (CertificateException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } finally {
        }

        SSLContext sslcontext = SSLContexts.custom()
                .loadKeyMaterial(keyStore, null)
                .build();

        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        		    sslcontext,
                    new String[] { "TLSv1" }, 
                    null,
                    SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        
        httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();

        //根据默认超时限制初始化requestConfig
        requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();

        hasInit = true;
    }
    
    public  String sendPost(String url, Map<String,Object> params) throws UnrecoverableKeyException, KeyManagementException, KeyStoreException, NoSuchAlgorithmException, IOException {
        if (!hasInit) {
            init();
        }
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);
        ArrayList<NameValuePair> pairs = covertParams2NVPS(params);  
        httpPost.setEntity(new UrlEncodedFormEntity(pairs, "UTF-8"));  
        String result = "";
        try {  
            CloseableHttpResponse response = httpClient.execute(httpPost);  
            HttpEntity entity = response.getEntity();  
            if (entity != null) {  
                 result = EntityUtils.toString(entity);  
                response.close();  
                
            }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
        	httpPost.abort();
        }  
        return result;  
/*
        log.info("API，POST过去的数据是：");
        log.info(postDataXML);
        //得指明使用UTF-8编码，否则到API服务器XML的中文不能被成功识别
        StringEntity postEntity = new StringEntity(pairs, "UTF-8");
        httpPost.addHeader("Content-Type", "text/xml");
        httpPost.setEntity(postEntity);

        //设置请求器的配置
        httpPost.setConfig(requestConfig);

        log.info("executing request" + httpPost.getRequestLine());

        try {
        	CloseableHttpResponse  response = httpClient.execute(httpPost);

            HttpEntity entity = response.getEntity();

            result = EntityUtils.toString(entity, "UTF-8");

        } catch (ConnectionPoolTimeoutException e) {
        	log.info("http get throw ConnectionPoolTimeoutException(wait time out)");

        } catch (ConnectTimeoutException e) {
        	log.info("http get throw ConnectTimeoutException");

        } catch (SocketTimeoutException e) {
        	log.info("http get throw SocketTimeoutException");

        } catch (Exception e) {
        	log.info("http get throw Exception");

        } finally {
            httpPost.abort();
        }

        return result;*/
    }
    
    private static ArrayList<NameValuePair> covertParams2NVPS(Map<String, Object> params) {  
        ArrayList<NameValuePair> pairs = new ArrayList<NameValuePair>();  
        for (Map.Entry<String, Object> param : params.entrySet()) {  
            pairs.add(new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue())));  
        }  
  
        return pairs;  
    }

    /**
     * 设置连接超时时间
     *
     * @param socketTimeout 连接时长，默认10秒
     */
    public void setSocketTimeout(int socketTimeout) {
        this.socketTimeout = socketTimeout;
        resetRequestConfig();
    }

    /**
     * 设置传输超时时间
     *
     * @param connectTimeout 传输时长，默认30秒
     */
    public void setConnectTimeout(int connectTimeout) {
    	this.connectTimeout = connectTimeout;
        resetRequestConfig();
    }

    private void resetRequestConfig(){
        requestConfig = RequestConfig.custom().setSocketTimeout(socketTimeout).setConnectTimeout(connectTimeout).build();
    }

    /**
     * 允许商户自己做更高级更复杂的请求器配置
     *
     * @param requestConfig 设置HttpsRequest的请求器配置
     */
    public void setRequestConfig(RequestConfig requestConfig) {
    	this.requestConfig = requestConfig;
    }
}