package com.qxueyou.scc.base.util;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
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.entity.BasicHttpEntity;
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.util.EntityUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * @author xiadehu
 */
public class HttpClient {

	private static final String UTF_8 = "UTF-8";
	
	private CloseableHttpClient httpClient;

	private RequestConfig requestConfig;

	protected static final Logger log = LogManager.getLogger("HttpClient");

	private static final int timeout = 30000;

	public HttpClient() {
		init();
	}

	public CloseableHttpClient getHttpClient() {
		return httpClient;
	}

	public void setHttpClient(CloseableHttpClient httpClient) {
		this.httpClient = httpClient;
	}
	
	private void init() {
		X509TrustManager xtm = new X509TrustManager() { // 创建TrustManager
			public void checkClientTrusted(X509Certificate[] chain,
					String authType) throws CertificateException {
			}

			public void checkServerTrusted(X509Certificate[] chain,
					String authType) throws CertificateException {
			}

			public X509Certificate[] getAcceptedIssuers() {
				return new X509Certificate[]{};
			}
		};
		try {
			// TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
			SSLContext ctx = SSLContext.getInstance("TLS");
			// 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
			ctx.init(null, new TrustManager[] { xtm }, null);

			/*
			 * SchemeRegistry schemeRegistry = new SchemeRegistry();
			 * schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory
			 * .getSocketFactory())); schemeRegistry.register(new
			 * Scheme("https", 443, new SSLSocketFactory(ctx)));
			 */

			/*
			 * PoolingClientConnectionManager cm = new
			 * PoolingClientConnectionManager(schemeRegistry);
			 * cm.setMaxTotal(200); cm.setDefaultMaxPerRoute(20);
			 */


			// httpClient = new DefaultHttpClient(cm);

			/*
			 * httpClient.getParams().setParameter(ClientPNames.COOKIE_POLICY,
			 * CookiePolicy.BEST_MATCH); httpClient.getParams().setParameter(
			 * ClientPNames.CONN_MANAGER_TIMEOUT, Long.valueOf(timeout));
			 * 
			 * HttpParams params = httpClient.getParams();
			 * HttpConnectionParams.setConnectionTimeout(params, timeout);
			 * HttpConnectionParams.setSoTimeout(params, timeout);
			 */

			// cyq modify begin
			PlainConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
			SSLConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
			Registry<ConnectionSocketFactory> r = RegistryBuilder.<ConnectionSocketFactory> create()
					.register("http", plainsf).register("https", sslsf).build();
			PoolingHttpClientConnectionManager ccm = new PoolingHttpClientConnectionManager(r);
			ccm.setMaxTotal(200);
			ccm.setDefaultMaxPerRoute(20);

			httpClient = HttpClients.custom().setConnectionManager(ccm).build();

			requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).setConnectTimeout(timeout)
					.setSocketTimeout(timeout).build();
			// end

		} catch (KeyManagementException e) {
			log.error(e, e);
		} catch (NoSuchAlgorithmException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		}
	}

	/**
	 * 向HTTPS地址发送POST请求
	 * 
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @return 响应内容
	 */
	@SuppressWarnings("unchecked")
	public String sendStringPostRequest(String reqURL, Map<String, String> params1) {
		Map<String, String> params = params1;
		try {
			if (params == null) {
				params = Collections.EMPTY_MAP;
			}

			HttpEntity entity = sendPostRequest(reqURL, params); // 获取响应实体
			
			if( null != entity ){
				String content = EntityUtils.toString(entity, UTF_8);

				EntityUtils.consume(entity);

				return content;
			}

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	/**
	 * 向HTTPS地址发送POST请求
	 * 
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @return 响应内容
	 */
	@SuppressWarnings("unchecked")
	public String sendStringPostRequest(String reqURL, String data) {
		try {

			StringEntity reqEntity = new StringEntity(data, UTF_8);

			HttpEntity entity = sendPostRequest(reqURL, Collections.EMPTY_MAP, reqEntity); // 获取响应实体

			if( null != entity ){
				
				String content = EntityUtils.toString(entity, UTF_8);

				EntityUtils.consume(entity);

				return content;
				
			}

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	/**
	 * 向HTTPS地址发送POST请求
	 * 
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @return 响应内容
	 */
	public String sendStringPostRequest(String reqURL, Map<String, String> headerParas1, String data) {
		Map<String, String> headerParas = headerParas1;
		try {

			StringEntity reqEntity = new StringEntity(data, UTF_8);

			HttpEntity entity = sendPostRequest(reqURL, headerParas, reqEntity); // 获取响应实体
			
			if( null != entity ){
				String content = EntityUtils.toString(entity, UTF_8);

				EntityUtils.consume(entity);

				return content;
			}

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	/**
	 * 向HTTPS地址发送POST请求
	 * 
	 * @param reqURL
	 *            请求地址
	 * @param params
	 *            请求参数
	 * @return 响应内容
	 */
	@SuppressWarnings("unchecked")
	public HttpEntity sendPostRequest(String reqURL, Map<String, String> params1) {
		Map<String, String> params = params1;
		if (params == null) {
			params = Collections.EMPTY_MAP;
		}

		List<NameValuePair> lstParams = new ArrayList<NameValuePair>(params.size());

		for (String key : params.keySet()) {
			lstParams.add(new BasicNameValuePair(key, params.get(key)));
		}

		return sendPostRequest(reqURL, Collections.EMPTY_MAP, lstParams);
	}

	@SuppressWarnings("unchecked")
	public HttpEntity sendPostRequest(String reqURL, Map<String, String> headerParas1, Map<String, String> params1) {
		Map<String, String> params = params1;
		Map<String, String> headerParas = headerParas1;
		if (params == null) {
			params = Collections.EMPTY_MAP;
		}

		headerParas = checkUserAgent(headerParas);

		List<NameValuePair> lstParams = new ArrayList<NameValuePair>(params.size());

		for (String key : params.keySet()) {
			lstParams.add(new BasicNameValuePair(key, params.get(key)));
		}

		return sendPostRequest(reqURL, headerParas, lstParams);
	}

	public HttpEntity sendPostRequest(String reqURL, Map<String, String> headerParas, List<NameValuePair> params) {

		try {
			HttpEntity entity = new UrlEncodedFormEntity(params, UTF_8);
			return sendPostRequest(reqURL, headerParas, entity);
		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		}
		return null;

	}

	public HttpEntity sendPostRequest(String reqURL, Map<String, String> headerParas1, HttpEntity reqEntity) {
		Map<String, String> headerParas = headerParas1;
		try {

			HttpPost httpPost = new HttpPost(reqURL); // 创建HttpPost
			httpPost.setEntity(reqEntity);

			headerParas = checkUserAgent(headerParas);
			for (String key : headerParas.keySet()) {
				httpPost.setHeader(key, headerParas.get(key));
			}

			Header[] headers = httpPost.getAllHeaders();
			for (Header header : headers) {
				log.debug("request--header:" + header.getName() + ":" + header.getValue());
			}

			HttpResponse response = httpClient.execute(httpPost); // 执行POST请求
			headers = response.getAllHeaders();
			for (Header header : headers) {
				log.debug("response--header:" + header.getName() + ":" + header.getValue());
			}
			HttpEntity entity = response.getEntity(); // 获取响应实体

			this.debug(httpPost.getURI(), response.getStatusLine().getStatusCode(), entity.getContentLength(), entity.getContentType());

			if (302 == response.getStatusLine().getStatusCode() && response.containsHeader("location")) {
				String location = response.getLastHeader("location").getValue();
				log.debug("重定向:" + location);
				EntityUtils.consume(entity);
				return sendPostRequest(location, headerParas, reqEntity);
			}

			return entity;

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	public String sendStringDeleteRequest(String reqURL, Map<String, String> headerParas1) {
		Map<String, String> headerParas = headerParas1;
		try {

			HttpDelete httpDelete = new HttpDelete(reqURL); // 创建HttpPost

			headerParas = checkUserAgent(headerParas);
			for (String key : headerParas.keySet()) {
				httpDelete.setHeader(key, headerParas.get(key));
			}

			Header[] headers = httpDelete.getAllHeaders();
			for (Header header : headers) {
				log.debug("request--header:" + header.getName() + ":" + header.getValue());
			}

			HttpResponse response = httpClient.execute(httpDelete); // 执行POST请求
			headers = response.getAllHeaders();
			for (Header header : headers) {
				log.debug("response--header:" + header.getName() + ":" + header.getValue());
			}
			HttpEntity entity = response.getEntity(); // 获取响应实体

			this.debug(httpDelete.getURI(), response.getStatusLine().getStatusCode(), entity.getContentLength(), entity.getContentType());

			if (302 == response.getStatusLine().getStatusCode() && response.containsHeader("location")) {
				return null;
			}

			return EntityUtils.toString(entity);

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}
	
	/**
	 * debug log
	 * 
	 * @param uri
	 * @param code
	 * @param length
	 * @param header
	 */
	private void debug(URI uri, int code, long length, Header header){
		log.debug("请求地址: " + uri);
		log.debug("响应状态: " + code);
		log.debug("响应长度: " + length);
		log.debug("响应类型: " + header);
	}

	public String sendStringPutRequest(String reqURL, Map<String, String> headerParas1, String body) {
		Map<String, String> headerParas = headerParas1;
		try {

			HttpPut httpPut = new HttpPut(reqURL); // 创建HttpPost

			headerParas = checkUserAgent(headerParas);
			for (String key : headerParas.keySet()) {
				httpPut.setHeader(key, headerParas.get(key));
			}

			Header[] headers = httpPut.getAllHeaders();
			for (Header header : headers) {
				log.debug("request--header:" + header.getName() + ":" + header.getValue());
			}

			StringEntity reqEntity = new StringEntity(body, UTF_8);
			httpPut.setEntity(reqEntity);

			HttpResponse response = httpClient.execute(httpPut); // 执行POST请求
			headers = response.getAllHeaders();
			for (Header header : headers) {
				log.debug("response--header:" + header.getName() + ":" + header.getValue());
			}
			HttpEntity entity = response.getEntity(); // 获取响应实体

			this.debug(httpPut.getURI(), response.getStatusLine().getStatusCode(), entity.getContentLength(), entity.getContentType());
			
			if (302 == response.getStatusLine().getStatusCode() && response.containsHeader("location")) {
				return null;
			}

			return EntityUtils.toString(entity);

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	public HttpEntity sendPostRequest(String reqURL, Map<String, String> headerParas1, String param) {
		Map<String, String> headerParas = headerParas1;
		try {

			HttpPost httpPost = new HttpPost(reqURL); // 创建HttpPost

			BasicHttpEntity requestBody = new BasicHttpEntity();
			requestBody.setContent(new ByteArrayInputStream(param.getBytes(UTF_8)));
			requestBody.setContentLength(param.getBytes(UTF_8).length);

			httpPost.setEntity(requestBody);

			headerParas = checkUserAgent(headerParas);
			for (String key : headerParas.keySet()) {
				httpPost.setHeader(key, headerParas.get(key));
			}

			Header[] headers = httpPost.getAllHeaders();
			for (Header header : headers) {
				log.debug("request--header:" + header.getName() + ":" + header.getValue());
			}

			log.debug("request--param:" + param);

			HttpResponse response = httpClient.execute(httpPost); // 执行POST请求
			headers = response.getAllHeaders();
			for (Header header : headers) {
				log.debug("response--header:" + header.getName() + ":" + header.getValue());
			}
			HttpEntity entity = response.getEntity(); // 获取响应实体

			this.debug(httpPost.getURI(), response.getStatusLine().getStatusCode(), entity.getContentLength(), entity.getContentType());
			
			if (302 == response.getStatusLine().getStatusCode() && response.containsHeader("location")) {
				String location = response.getLastHeader("location").getValue();
				log.debug("重定向:" + location);
				EntityUtils.consume(entity);
				return sendPostRequest(location, headerParas, param);
			}

			return entity;

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	public String sendStringGetRequest(String reqURL, Map<String, String> headerParas, Map<String, String> params) {
		try {	
			HttpEntity entity = sendGetRequest(reqURL, headerParas, params);
			
			if( null != entity ){
				return EntityUtils.toString(entity, UTF_8);
			}
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

	public HttpEntity sendGetRequest(String reqURL, Map<String, String> headerParas, Map<String, String> params) {
		HttpResponse response = this.sendGetRequestAsResponse(reqURL, headerParas, params);
		if(response != null){
			return response.getEntity();
		}
		return null;
	}

	private Map<String, String> checkUserAgent(Map<String, String> headerParas1) {
		Map<String, String> headerParas = headerParas1;
		if (headerParas == null || headerParas.isEmpty()) {
			headerParas = new HashMap<String, String>(1);
		}

		String agentKey = "User-Agent";
		if (headerParas.containsKey(agentKey)) {	
			headerParas.remove(agentKey);
		}

		headerParas.put(agentKey, "Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; Touch; rv:11.0) like Gecko");

		return headerParas;

	}

	@SuppressWarnings("unchecked")
	public HttpResponse sendGetRequestAsResponse(String reqURL, Map<String, String> headerParas1,
			Map<String, String> params1) {
		Map<String, String> params = params1;
		Map<String, String> headerParas = headerParas1;
		try {
			// HttpGet httpGet = new HttpGet(reqURL); // 创建HttpPost

			headerParas = checkUserAgent(headerParas);

			if (params == null) {
				params = Collections.EMPTY_MAP;
			}
			// begin
			RequestBuilder requestBuilder = RequestBuilder.get().setConfig(requestConfig).setUri(reqURL);
			for (String key : headerParas.keySet()) {
				requestBuilder.addHeader(key, headerParas.get(key));
			}
			for (String key : params.keySet()) {
				requestBuilder.addParameter(key, params.get(key));
			}
			HttpUriRequest request = requestBuilder.build();
			// end

			// Header[] headers = httpGet.getAllHeaders();
			Header[] headers = request.getAllHeaders();
			for (Header header : headers) {
				log.debug("request--header:" + header.getName() + ":" + header.getValue());
			}

			// HttpResponse response = httpClient.execute(httpGet); // 执行POST请求
			HttpResponse response = httpClient.execute(request);
			headers = response.getAllHeaders();
			for (Header header : headers) {
				log.debug("response--header:" + header.getName() + ":" + header.getValue());
			}
			HttpEntity entity = response.getEntity(); // 获取响应实体

			this.debug(request.getURI(), response.getStatusLine().getStatusCode(), entity.getContentLength(), entity.getContentType());
			
			if (302 == response.getStatusLine().getStatusCode() && response.containsHeader("location")) {
				String location = response.getLastHeader("location").getValue();
				log.debug("重定向");
				return sendGetRequestAsResponse(location, headerParas, params);
			}

			return response;

		} catch (UnsupportedEncodingException e) {
			log.error(e, e);
		} catch (ClientProtocolException e) {
			log.error(e, e);
		} catch (ParseException e) {
			log.error(e, e);
		} catch (IOException e) {
			log.error(e, e);
		}
		return null;
	}

}