package com.eactive.eai.adapter.http.client.impl;

import java.io.StringReader;
import java.math.BigDecimal;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethodBase;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.DeleteMethod;
import org.apache.commons.httpclient.methods.EntityEnclosingMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.StopWatch;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;

import com.eactive.eai.adapter.http.HttpMemoryLogger;
import com.eactive.eai.adapter.http.HttpMethodType;
import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceSupport;
import com.eactive.eai.adapter.http.client.HttpClientAdapterVO;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.exception.ExceptionUtil;
import com.eactive.eai.common.message.MessageType;
import com.eactive.eai.common.util.CommonLib;
import com.jayway.jsonpath.DocumentContext;
import com.jayway.jsonpath.JsonPath;
import com.openbanking.eai.common.token.AccessTokenManager;
import com.openbanking.eai.common.token.AccessTokenVO;
import com.openbanking.eai.common.token.OAuth2AccessTokenVO;

/**
 * 1. 기능 : EAI HTTP OutBound 용 어댑터로 수동 시스템의 HTTP 웹 컴포넌트를 GET/POST 방식으로 호출할 수 있는
 * 기능을 제공한다.<br>
 * 2. 처리 개요 : <br>
 * * - 2020-09-25: Http Header 받아서 처리할 수 있게 기능 추가<br>
 * 3. 주의사항 <br>
 *
 * @author :
 * @version : v 1.0.0
 * @see : HttpClientAdapterServiceFactory.java,
 *      HttpClientAdapterServiceSupport.java
 * @since :
 * 
 */
public class HttpClientAdapterServiceRest extends HttpClientAdapterServiceSupport
		implements HttpClientAdapterServiceKey {
	public static final String TYPE_VARIABLE_URL_REQUEST = "variableUrlRequest";
	public static final String TYPE_SIMPLE_REQUEST = "simpleRequest";

	public static final String REST_OPTION = "REST_OPTION";

	////public static final String HEADER_CONTENT_TYPE = "Content-Type";
	public static final String HEADER_GROUP = "HEADER_GROUP";
	public static final String HTTP_STATUS = "HTTP_STATUS";
	public static final String HEADER_KEYS = "HEADER_KEYS";

	/**
	 * 1. 기능 : REST API 통신에 사용 <br>
	 * 2. 처리 개요 : - 속성 정보를 설정 하고 수동 시스템 서비스를 호출 한다. <br>
	 * 3. 주의사항 <br>
	 *
	 * @param prop    Http Adapter 속성 정보
	 * @param message 송신 전문(JSON)
	 * @return 반환 된 Object
	 * @exception Exception 수동 시스템 간 통신 중 발생
	 **/
	@SuppressWarnings({ "unchecked" })
	public Object execute(Properties prop, Object data, Properties tempProp) throws Exception {
		HttpClientAdapterVO vo = super.setting(prop, tempProp);

		String headerGroupName = prop.getProperty(HEADER_GROUP);
		String relayResponseHeaderKeys = prop.getProperty(HEADER_KEYS, "");
		boolean useAdapterToken = StringUtils.equalsIgnoreCase(prop.getProperty("ADAPTER_TOKEN_USE_YN", "N"), "Y");

		// ex) $.dataHeader.GW_RSLT_CD
		String tokenErrorCodeKey = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_KEY");
		String tokenErrorCodeValues = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_VALUES");
		String tokenErrorHttpStatusCode = prop.getProperty("ADAPTER_TOKEN_ERROR_HTTP_STATUS_CODE"); // 200 or 400번대

		// 레이아웃 메시지 타입 REST URL 추출 시 활용. Default JSON
		String messageType = prop.getProperty("MESSAGE_TYPE", MessageType.JSON);
		String inboundMethod = tempProp.getProperty(HttpAdapterServiceKey.INBOUND_METHOD, "POST");

		/**
		 * @formatter:off
		 * TSEAIHE02.RESTOPTION 정보 => JSON 형태로 구성
		 * - type : simpleRequest, variableUrlRequest
		 * - extraPath : 어댑터 프로퍼티 URL에 추가될 HTTP REST URL
		 * - method : get, delete, post, put
		 * - contentType: application/json(default), application/x-www-form-urlencoded
		 * - adapterTokenUseYn: Y, N(default)
		 * ex)
		 * {"type":"simpleRequest","extraPath":"v2.0/accout/balance","method":"post"}
		 * @formatter:on
		 */

		String restOptionData = tempProp.getProperty(REST_OPTION);

		JSONObject restOptionObject = parseJson(restOptionData);
		if (restOptionObject == null) {
			throw new Exception("OptionData parsing result is NULL");
		}

		String rmethod = (String) restOptionObject.getOrDefault("method", inboundMethod);
		String contentType = (String) restOptionObject.getOrDefault("contentType", "application/json");
		String adapterTokenUseYn = (String) restOptionObject.get("adapterTokenUseYn");
		if (StringUtils.isNotBlank(adapterTokenUseYn)) { // interface 에 설정된게 우선한다.
			useAdapterToken = StringUtils.equalsIgnoreCase(adapterTokenUseYn, "Y");
		}

		HttpClient mclient = this.client;
		String sendData = "";
		if (data instanceof String) {
			sendData = (String) data;
		} else if (data instanceof byte[]) {
			sendData = new String((byte[]) data, vo.getEncode());
		}

		////mclient.getParams().setContentCharset(vo.getEncode());

		JSONObject dataObject = null;
		Object httpHeader = null;
		if (MessageType.JSON.equals(messageType)) {
			dataObject = parseJson(sendData);
			if (dataObject != null && StringUtils.isNotBlank(headerGroupName)) {
				httpHeader = dataObject.get(headerGroupName);
				dataObject.remove(headerGroupName);
			}
		}

		logger.debug("HttpClientAdapterServiceRest] dataObject1 =  [" + dataObject + "]");

		// interface 에 설정된게 우선한다.
		String uri = null;
		if (dataObject == null) {
			uri = changeUrl(messageType, vo.getUrl(), restOptionData, sendData);
		} else {
			uri = changeUrl(messageType, vo.getUrl(), restOptionData, dataObject);
		}

		logger.debug("HttpClientAdapterServiceRest] dataObject2 =  [" + dataObject + "]");

//		////if (vo.getConnectionTimeout() != 0) {
//			mclient.getHttpConnectionManager().getParams().setConnectionTimeout(vo.getConnectionTimeout());
//		}

		if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
			logger.debug(
					"HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL=[" + vo.getUrl() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") PARAMETER_NAME=["
					+ vo.getParameterName() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") ENCODE=["
					+ vo.getEncode() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") RESPONSE_TYPE=["
					+ vo.getResponseType() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL_ENCODE_YN=["
					+ vo.getUrlEncodeYn() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") CONNECTION_TIMEOUT=["
					+ vo.getConnectionTimeout() + "] ");
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") REST_OPTION=["
					+ restOptionData + "] ");
		}

		HttpMethodBase method = null;
		switch (HttpMethodType.getValue(rmethod)) {
		case GET:
			method = new GetMethod(uri);
			break;
		case DELETE:
			method = new DeleteMethod(uri);
			break;
		case POST:
			method = new PostMethod(uri);
			break;
		case PUT:
			method = new PutMethod(uri);
			break;
		default:
			// set default method
			method = new GetMethod(uri);
			break;
		}
		
		configureHttpClient(mclient, method, vo, uri, contentType);

		switch (HttpMethodType.getValue(rmethod)) {
		case GET:
		case DELETE:
			HashMap<String, String> h = getParameters(dataObject);
			NameValuePair[] params = new NameValuePair[h.size()];
			int count = 0;
			for (String key : h.keySet()) {
				String value = h.get(key);
				params[count] = new NameValuePair(key, value);
				count++;
			}
			method.setQueryString(params);
			if (logger.isDebug()) {
				logger.debug(
						"HttpClientAdapterServiceRest] (get Method) QueryString = [" + method.getQueryString() + "]");
			}

			break;
		case PUT:
		case POST:
			assignPostBody(dataObject, contentType, method);
			break;
		default:
			break;
		}

		if (logger.isDebugEnabled()) {
			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") method.getParams()=["
					+ method.getParams().toString() + "] ");
		}

		OAuth2AccessTokenVO accessToken = null;
		if (useAdapterToken) {
			AccessTokenManager tokenManager = AccessTokenManager.getInstance();
			accessToken = (OAuth2AccessTokenVO) tokenManager.getAccessTokenVO(vo.getAdapterGroupName());

			// 토큰이 없거나 만료 됐으면 재발급
			if (accessToken == null || accessToken.isExpired()) {
				String oldToken = accessToken == null ? null : accessToken.getAccessToken();
				accessToken = (OAuth2AccessTokenVO) tokenManager.retryAccessTokenVO(vo.getAdapterGroupName(), prop,
						oldToken);
			}

			if (logger.isDebug()) {
				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") TOKEN = ["
						+ accessToken + "]");
			}

			setAuthHeaders(method, accessToken);

			if (logger.isDebug()) {
				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
						+ ") RequestHeader [Authorization=" + method.getRequestHeader("Authorization") + "]");
			}
		}

		// 전달 header 셋팅
		// Adapter 레벨 header 보다 data로 넘어온 httpHeader를 우선 적용(header명이 같다면 덮어씀)
		assignRequestHeaders(method, httpHeader);

		int status = -1;

		try {
			byte[] responseMessage = null;

			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
				if (dataObject != null) {
					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = ["
							+ dataObject.toJSONString() + "]");
					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
							+ CommonLib.getDumpMessage(dataObject.toJSONString()));
				} else {
					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = [" + sendData
							+ "]");
					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
							+ CommonLib.getDumpMessage(sendData));
				}
			}
			StopWatch stopWatch = new StopWatch();
			stopWatch.start();

			if (vo.getTraceLevel() >= 3) {
				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
						"SEND [" + sendData + "]" + CommonLib.getDumpMessage(sendData));
			}
			try {
				if (logger.isDebug()) {
					logger.debug("[method getName]" + method.getName());
					logger.debug("[method getRequestCharSet]" + method.getRequestCharSet());
					logger.debug("[method getRequestHeaders]" + method.getRequestHeaders().toString());
					logger.debug("[method getQueryString]" + method.getQueryString());
					logger.debug("[method getParams]" + method.getParams().toString());
					logger.debug("[method getURI]" + method.getURI());
				}
				status = mclient.executeMethod(method);
				if (logger.isDebug()) {
					logger.debug("[received status]" + status);
				}
			} catch (ConnectException e) {
				responseMessage = method.getResponseBody();
				if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
					logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
					logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = ["
							+ new String(responseMessage, vo.getEncode()) + "]");
					logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = "
							+ CommonLib.getDumpMessage(responseMessage));
				}
				throw new Exception("excuteMethod java.net.ConnectException = " + e.getMessage());
			}

			stopWatch.stop();

			/**
			 * @formatter:off
			 * OAuth 토큰 응답 체크(Adapter properties로 설정)
			 * 응답코드에 따라 유효한 토큰 확인(토큰 재발급 여부 확인)
			 * API 서비스 마다 정책이 다름(보통 400대에서 체크하나 200에서도 체크할 수 있음)
			 * 
			 * TOKEN_ERROR_CODE_KEY: 응답 json error code key
			 * __ex) $.dataHeader.resultCode
			 * TOKEN_ERROR_CODE_VALUES: 토큰 재발급이 필요한 응답 error codes(ex: O0001,O0002,O0003)
			 * TOKEN_ERROR_HTTP_STATUS_CODE: 보통 400대에서 체크하나 API 제공자에 따라 200에서도 체클할수 있음
			 * ex) TOKEN_ERROR_HTTP_STATUS_CODE = 200
			 * @formatter:on
			 */
			boolean needReissue = false;

			if (status == 200) {
				responseMessage = method.getResponseBody();
				if (useAdapterToken && StringUtils.equals(tokenErrorHttpStatusCode, "200")) {
					needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
							vo.getEncode());
				}
			} else if (status == 302) {
				responseMessage = method.getResponseBody();
				if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
					relayResponseHeaderKeys += ",Location";
				}
			} else if (status >= 400 && status < 500) {
				responseMessage = method.getResponseBody();
				if (useAdapterToken) {
					needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
							vo.getEncode());
				}

				if (!needReissue) {
					String errMsg = String.format(
							"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
							status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
					throw new Exception(errMsg);
				}
			} else {
				responseMessage = method.getResponseBody();
				String errMsg = String.format(
						"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
						status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
				throw new Exception(errMsg);
			}

			// ----------------------------------------------------------
			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
				logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
				logger.debug("HttpClientAdapterServiceRest] RECV " + vo.getEncode() + "(" + vo.getAdapterGroupName()
						+ ") = [" + new String(responseMessage, vo.getEncode()) + "]");
				logger.debug("HttpClientAdapterServiceRest] RECV MS949 (" + vo.getAdapterGroupName() + ") = ["
						+ new String(responseMessage, "MS949") + "]");
				logger.debug("HttpClientAdapterServiceRest] RECV euc-kr (" + vo.getAdapterGroupName() + ") = ["
						+ new String(responseMessage, "euc-kr") + "]");
				logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = "
						+ CommonLib.getDumpMessage(responseMessage));
			}

			if (useAdapterToken) {
				if (responseMessage == null) {
					throw new Exception("responseMessage is NULL, HttpStatus=" + status);
				}

				// OAuth 토큰 재요청 코드 확인
				if (needReissue) {
					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
						logger.debug("HttpClientAdapterServiceRest] retry access token response code = ["
								+ vo.getResponseType() + "] message = [" + new String(responseMessage, vo.getEncode())
								+ "]");
					}

					// 토큰 재발급
					AccessTokenManager tokenManager = AccessTokenManager.getInstance();
					String oldToken = accessToken == null ? null : accessToken.getAccessToken();
					OAuth2AccessTokenVO newaccessToken = (OAuth2AccessTokenVO) tokenManager
							.retryAccessTokenVO(vo.getAdapterGroupName(), prop, oldToken);
					method.setRequestHeader("Authorization", newaccessToken.getAuthorization());

					setAuthHeaders(method, newaccessToken);

					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
						logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
								+ ") RETRY TOKEN = [" + newaccessToken + "]");
					}

					try {
						status = mclient.executeMethod(method);
					} catch (ConnectException e) {
						throw new Exception("retry excuteMethod Exceptioin = " + e.getMessage());
					}

					if (status == 200) {
						responseMessage = method.getResponseBody();
					} else if (status == 302) {
						responseMessage = method.getResponseBody();
						if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
							relayResponseHeaderKeys += ",Location";
						}
					} else {
						responseMessage = method.getResponseBody();
						String errMsg = String.format(
								"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
								status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
						throw new Exception(errMsg);
					}

					// ----------------------------------------------------------
					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
						logger.debug("HttpClientAdapterServiceRest] RETRY responseType =" + vo.getResponseType());
						logger.debug("HttpClientAdapterServiceRest] RETRY RECV " + vo.getEncode() + "("
								+ vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode())
								+ "]");
						logger.debug("HttpClientAdapterServiceRest] RETRY RECV (" + vo.getAdapterGroupName() + ") = "
								+ CommonLib.getDumpMessage(responseMessage));
					}
					// ----------------------------------------------------------
				}
			}

			if (vo.getTraceLevel() >= 3) {
				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
						"RECV [" + new String(responseMessage, vo.getEncode()) + "]"
								+ CommonLib.getDumpMessage(responseMessage));
			}

			assignRelayDataToInbound(tempProp, method.getResponseHeaders());

			return assignResponseHeaders(method, responseMessage, headerGroupName, vo.getEncode(), messageType,
					relayResponseHeaderKeys, status);
		} catch (SocketTimeoutException ste) { // Read Timeout :: HttpClient 3.1일 경우
			if (vo.getTraceLevel() >= 3) {
				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
						"HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
								+ ste.toString(),
						ste);
			}
			logger.error("HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
					+ ste.toString(), ste);
			throw ste;
		} catch (ConnectException ce) {
			if (vo.getTraceLevel() >= 3) {
				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
						"HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
								+ ce.toString(),
						ce);
			}
			logger.error("HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
					+ ce.toString(), ce);
			throw ce;
		} catch (Exception e) {
			if (vo.getTraceLevel() >= 3) {
				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(), e.toString(), e);
			}
			logger.error("HttpClientAdapterServiceRest] Exception (" + vo.getAdapterGroupName() + ") : " + e.toString(),
					e);
			throw e;
		} finally {
			method.releaseConnection();
			if (status != HttpStatus.SC_OK) {
				String[] msgArgs = new String[1];
				msgArgs[0] = String.valueOf(status);
				String resMsg = ExceptionUtil.make("RDCEAIAHA013", msgArgs);
				if (logger.isDebug()) {
					logger.debug(resMsg);
				}
			}
		}
	}

	private void assignRelayDataToInbound(Properties prop, Header[] responseHeaders) {
		if (responseHeaders == null || responseHeaders.length == 0) {
			return;
		}

		Properties headerProp = new Properties();
		for (Header header : responseHeaders) {
			headerProp.put(header.getName(), header.getValue());
		}

		Map<String, Object> map = new HashMap<String, Object>();
		map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_HEADERS, headerProp);

		prop.put(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP, map);
	}

	/**
	 * 현재 1단계 레이아웃에만 적용되도록 구현됨.
	 * 
	 * @param method
	 * @param responseMessage
	 * @param headerGroupName
	 * @param encode
	 * @param messageType
	 * @param relayHeaderKeys
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String assignResponseHeaders(HttpMethodBase method, byte[] responseMessage, String headerGroupName,
			String encode, String messageType, String relayHeaderKeys, int status) throws Exception {
		if (!MessageType.JSON.equals(messageType) || StringUtils.isBlank(headerGroupName)
				|| StringUtils.isBlank(relayHeaderKeys)) {
			return new String(responseMessage, encode);
		}

		String[] relayKeyArr = org.springframework.util.StringUtils.tokenizeToStringArray(relayHeaderKeys, ",");
		JSONObject headerJson = new JSONObject();
		for (String key : relayKeyArr) {
			Header header = method.getResponseHeader(key);
			if (header != null) {
				headerJson.put(header.getName(), header.getValue());
			}
		}

		headerJson.put(HTTP_STATUS, String.valueOf(status));

		if (headerJson.size() <= 0) {
			return new String(responseMessage, encode);
		}

		JSONObject message = null;
		if (responseMessage == null || responseMessage.length == 0) {
			message = new JSONObject();
		} else {
			message = parseJson(new String(responseMessage, encode));
			if (message == null) {
				message = new JSONObject();
				message.put("Malformed_Response_Message", new String(responseMessage, encode));
			}
		}

		if (StringUtils.isNotBlank(headerGroupName) && message != null)
			message.put(headerGroupName, headerJson);
		return message.toJSONString();
	}

	private void setAuthHeaders(HttpMethodBase method, OAuth2AccessTokenVO accessToken) throws Exception {
		method.setRequestHeader("Authorization",
				String.format("%s %s", AccessTokenVO.BEARER_TYPE, accessToken.getAccessToken()));
	}

	private boolean checkTokenRetry(byte[] responseMessage, String tokenErrorCodeKey, String tokenErrorCodeValues,
			String encode) {
		if (responseMessage == null) {
			return false;
		}

		if (StringUtils.isBlank(tokenErrorCodeKey)) {
			return false;
		}

		if (StringUtils.isBlank(tokenErrorCodeValues)) {
			return false;
		}

		try {
			DocumentContext jsonContext = JsonPath.parse(new String(responseMessage, encode));
			String responseCode = jsonContext.read(tokenErrorCodeKey);
			if (StringUtils.isBlank(responseCode)) {
				return false;
			}

			String[] arr = org.springframework.util.StringUtils.tokenizeToStringArray(tokenErrorCodeValues, ",");
			return ArrayUtils.contains(arr, responseCode);
		} catch (Exception e) {
			logger.error("HttpClientAdapterServiceRest] checkTokenRetry error=" + e.getMessage());
		}

		return false;
	}

	private void assignRequestHeaders(HttpMethodBase method, Object httpHeader) {
		if (httpHeader == null) {
			return;
		}

		if (httpHeader instanceof JSONObject) {
			JSONObject jsonObject = (JSONObject) httpHeader;
			for (Object key : jsonObject.keySet()) {
				Object obj = jsonObject.get(key);
				if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
					continue;
				}

				method.setRequestHeader((String) key, (String) obj);

				if (logger.isDebugEnabled()) {
					logger.debug("Request Header :" + (String) key + "=[" + (String) obj + "]");
				}

			}
		}
	}

	@SuppressWarnings("deprecation")
	private void assignPostBody(Object eaiBody, String contentType, HttpMethodBase method) {
		if (eaiBody == null) {
			return;
		}

		if (StringUtils.contains(contentType, "application/x-www-form-urlencoded")) {
			handleJsonValue("", eaiBody, method);
		} else {
			((EntityEnclosingMethod) method).setRequestBody(eaiBody.toString());
		}
	}

	@SuppressWarnings("deprecation")
	private void handleJsonValue(String keyPath, Object value, HttpMethodBase method) {
		if (value == null) {
			return;
		}

		if (value instanceof JSONObject) {
			handleJsonObject(keyPath, (JSONObject) value, method);
		} else if (value instanceof JSONArray) {
			handleJsonArray(keyPath, (JSONArray) value, method);
		} else {
			String valueStr = String.valueOf(value);
			if (StringUtils.isBlank(keyPath)) {
				((EntityEnclosingMethod) method).setRequestBody(valueStr);
			} else {
				if (keyPath.endsWith("]")) {
					((PostMethod) method).addParameter(keyPath, valueStr);
				} else {
					((PostMethod) method).setParameter(keyPath, valueStr);
				}
			}
			logger.debug(keyPath + "=" + valueStr);
		}
	}

	/**
	 * req_list[0].tran_no=12345<br>
	 * req_list[0].org_tran_amt=12000<br>
	 * req_list[1].tran_no=12445<br>
	 * req_list[1].org_tran_amt=11000
	 */
	private void handleJsonArray(String keyPath, JSONArray jsonArray, HttpMethodBase method) {
		for (int i = 0; i < jsonArray.size(); i++) {
			Object object = jsonArray.get(i);
			String newKeyPath = null;
			if (StringUtils.isBlank(keyPath)) {
				newKeyPath = "NA[" + i + "]";
			} else {
				newKeyPath = keyPath + "[" + i + "]";
			}
			handleJsonValue(newKeyPath, object, method);
		}
	}

	/**
	 * obj.aaa=111<br>
	 * obj.bbb=222<br>
	 */
	private void handleJsonObject(String keyPath, JSONObject jsonObject, HttpMethodBase method) {
		for (Object key : jsonObject.keySet()) {
			Object object = jsonObject.get(key);
			String newKeyPath = StringUtils.isBlank(keyPath) ? "" : keyPath + ".";
			newKeyPath += key;
			handleJsonValue(newKeyPath, object, method);
		}
	}

	private HashMap<String, String> getParameters(Object message) throws Exception {

		HashMap<String, String> result = new HashMap<String, String>();

		if (message != null) {
			if (message instanceof JSONObject) {
				JSONObject jsonObject = (JSONObject) message;
				for (Object key : jsonObject.keySet()) {
					Object obj = jsonObject.get(key);
					if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
						continue;
					}
					result.put((String) key, getStringValue(obj));
				}
			} else {
				String[] messages = ((String) message).split("&");
				String[] data = null;

				for (int i = 0; i < messages.length; i++) {
					data = messages[i].split("=", 2);
					if (data.length == 2) {
						result.put(data[0], data[1]);
					}
				}
			}
		}

		return result;
	}
	
	public String getStringValue(Object obj) {
		if (obj == null) {
			return null;
		}

		if (obj instanceof String) {
			return (String) obj;
		} else if (obj instanceof Long) {
			return Long.toString((Long) obj);
		} else if (obj instanceof BigDecimal) {
			return ((BigDecimal) obj).toPlainString();
		} else {
			return (String) obj;
		}
	}

	@SuppressWarnings("deprecation")
	private JSONObject parseJson(String message) throws Exception {
		if (message == null) {
			return null;
		}

		return (JSONObject) JSONValue.parse(message);
	}

	private Document convertXmlDocument(String message) throws Exception {
		SAXReader builder = new SAXReader();
		Document document = builder.read(new StringReader(message));
		return document;
	}

	@SuppressWarnings("deprecation")
	private String changeUrl(String messageType, String url, String restOption, Object sendData) {
		if ((MessageType.JSON.equals(messageType) || MessageType.XML.equals(messageType))) {
			try {
				if (StringUtils.isBlank(restOption)) {
					return url;
				}
				List<String> urlVariableList = new ArrayList<String>();
				JSONObject restOptionObject = parseJson(restOption);

				if (restOptionObject == null)
					throw new Exception("restOption is NULL");

				String type = (String) restOptionObject.get("type");
				String requestExtraPath = (String) restOptionObject.get("extraPath");
				url = getUrl(url, requestExtraPath);
				if (TYPE_VARIABLE_URL_REQUEST.equals(type)) {
					JSONArray uriVariables = (JSONArray) restOptionObject.get("uriVariables");
					if (MessageType.JSON.equals(messageType)) {
						JSONObject jsonObject;
						if (sendData instanceof JSONObject) {
							jsonObject = (JSONObject) sendData;
						} else {
							jsonObject = (JSONObject) JSONValue.parse((String) sendData);
						}
						for (Object tempObject : uriVariables) {
							String urlVaribleId = (String) tempObject;
							String uriVariable = (String) jsonObject.get(urlVaribleId);
							urlVariableList.add(uriVariable);
							jsonObject.remove(urlVaribleId);
						}
					} else if (MessageType.XML.equals(messageType)) {
						Document doc;
						if (sendData instanceof Document) {
							doc = (Document) sendData;
						} else {
							doc = convertXmlDocument((String) sendData);
						}
						for (Object tempObject : uriVariables) {
							String urlVaribleId = (String) tempObject;
							Element element = (Element) doc.selectSingleNode("//" + urlVaribleId);
							urlVariableList.add(element.getText());
							if (doc.getRootElement() == element) {
								doc = null;
							} else {
								element.getParent().remove(element);
							}
						}
					}
					if (urlVariableList.size() > 0) {
						UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build();
						Object[] urls = urlVariableList.toArray();
						url = uriComponents.expand(urls).toUriString();
						logger.debug("HttpClientAdapterServiceRest] after extand url=[" + url + "] ");
					}
				}
			} catch (Exception e) {
				logger.error("Failed to change url", e);
			}
		}
		return url;
	}

	private String getUrl(String baseUrl, String extraPath) {
		if (StringUtils.isBlank(extraPath)) {
			return baseUrl;
		}

		if (StringUtils.contains(extraPath, "http://") || StringUtils.contains(extraPath, "https://")) {
			return extraPath;
		}

		String targetUrl = baseUrl;
		if (!targetUrl.endsWith("/")) {
			targetUrl += "/";
		}
		if (extraPath.startsWith("/")) {
			targetUrl += extraPath.substring(1);
		} else {
			targetUrl += extraPath;
		}

		logger.debug("HttpClientAdapterServiceRest] after concatenate url=[" + targetUrl + "] ");
		return targetUrl;
	}
}
