/**
 * Copyright 2016-2017 ZTE Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.onap.workflow.activitiext.restservicetask;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.BpmnError;
import org.activiti.engine.delegate.DelegateExecution;
import org.activiti.engine.delegate.Expression;
import org.activiti.engine.delegate.JavaDelegate;
import org.activiti.engine.impl.context.Context;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;

/**
 * rest service
 * 
 * @author 10222158
 *
 */
public class HttpUtil implements JavaDelegate {

	private static final Logger logger = LoggerFactory.getLogger(HttpUtil.class);

	private Expression uri;
	private Expression method;
	private Expression accept;
	private Expression contentType;
	private Expression parameters;

	@Override
	public void execute(DelegateExecution execution) throws ActivitiException {

		try {
			this.executeMethod(execution);
		} catch (Exception e) {

			logger.error("Invoke rest service failed!", e);
			throw new BpmnError(e.getMessage());
		}
	}

	/**
	 * invoke rest service
	 * 
	 * @param execution
	 */
	public boolean executeMethod(DelegateExecution execution) throws Exception {

		String uriValue = getValue(uri, execution);
		String methodValue = getValue(method, execution);
		String acceptValue = getValue(accept, execution);
		String contentTypeValue = getValue(contentType, execution);
		String parametersValue = getValue(parameters, execution);

		Map<String, String> requestBody = new HashMap<String, String>();

		if (!StringUtils.isEmpty(parametersValue)) {

			// Parse the parameter into Object List
			List<Parameter> parameters = JSONArray.parseArray(parametersValue, Parameter.class);

			for (Parameter param : parameters) {

				handleParam(execution, param, requestBody, uriValue);
			}
		}

		String requestPayload = JSON.toJSONString(requestBody);

		// invoke http service
		HttpResponseMessage msg = HighLevelRestApi.invoke(methodValue, uriValue, requestPayload, acceptValue,
				contentTypeValue);

		// inject the result to variable
		execution.setVariable(execution.getCurrentActivityId(), msg);

		logger.info("statusCode: " + msg.getStatusCode());
		logger.info("responseBody: " + msg.getResponseBody());
		
		return true;
	}

	/**
	 * 
	 * @param execution
	 * @param param
	 * @param requestBody
	 * @param uriValue
	 */
	public void handleParam(DelegateExecution execution, Parameter param, Map<String, String> requestBody,
			String uriValue) throws ActivitiException {

		if (ConstString.PARAMETER_TYPE_EXPRESSION.equals(param.getType())) {
			handleExpression(execution, param);
		}

		switch (param.getPosition()) {
		case ConstString.PARAMETER_POSITION_PATH:

			// replace the path parameter
			uriValue = uriValue.replaceAll("\\{+" + param.getName() + "+\\}", param.getValue());
			break;
		case ConstString.PARAMETER_POSITION_QUERY:

			// add the query parameter
			if (!uriValue.contains("?")) {
				uriValue = uriValue + "?" + param.getName() + "=" + param.getValue();
			} else {
				uriValue = uriValue + "&" + param.getName() + "=" + param.getValue();
			}
			break;
		case ConstString.PARAMETER_POSITION_BODY:

			// add parameter to request body
			requestBody.put(param.getName(), param.getValue());
			break;
		default:
			throw new ActivitiException(
					"The position '" + param.getPosition() + "' is illegal, please check your input!");
		}
	}

	/**
	 * get value from VariableScope
	 * 
	 * @param expression
	 * @param execution
	 * @return
	 */
	public String getValue(Expression expression, DelegateExecution execution) {

		String value = new String();
		if (expression != null) {
			value = (String) expression.getValue(execution);
		}

		return value;
	}

	/**
	 * parse expression in the parameter
	 * 
	 * @param execution
	 * @param param
	 */
	public void handleExpression(DelegateExecution execution, Parameter param) {

		Expression expression = Context.getProcessEngineConfiguration().getExpressionManager()
				.createExpression(param.getValue());

		String value = String.valueOf(expression.getValue(execution));

		param.setValue(value);
	}
}