package com.pax.order.workflow.controller;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import javax.validation.Valid;

import org.camunda.bpm.engine.HistoryService;
import org.camunda.bpm.engine.RepositoryService;
import org.camunda.bpm.engine.RuntimeService;
import org.camunda.bpm.engine.TaskService;
import org.camunda.bpm.engine.impl.javax.el.ExpressionFactory;
import org.camunda.bpm.engine.impl.juel.ExpressionFactoryImpl;
import org.camunda.bpm.engine.impl.juel.SimpleContext;
import org.camunda.bpm.engine.impl.juel.SimpleResolver;
import org.camunda.bpm.engine.runtime.ActivityInstance;
import org.camunda.bpm.engine.runtime.ProcessInstance;
import org.camunda.bpm.model.bpmn.BpmnModelInstance;
import org.camunda.bpm.model.bpmn.instance.Assignment;
import org.camunda.bpm.model.bpmn.instance.DataInputAssociation;
import org.camunda.bpm.model.bpmn.instance.EventDefinition;
import org.camunda.bpm.model.bpmn.instance.FlowNode;
import org.camunda.bpm.model.bpmn.instance.IntermediateCatchEvent;
import org.camunda.bpm.model.bpmn.instance.Message;
import org.camunda.bpm.model.bpmn.instance.MessageEventDefinition;
import org.camunda.bpm.model.bpmn.instance.SequenceFlow;
import org.camunda.bpm.model.bpmn.instance.ServiceTask;
import org.camunda.bpm.model.xml.instance.ModelElementInstance;
import org.json.simple.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.pax.order.workflow.model.OrderDetail;
import com.pax.order.workflow.model.SucceedingNodes;

@RestController
@RequestMapping("/api/v1")
public class CamundaController {

	@Autowired
	private RepositoryService repositoryService;

	@Autowired
	HistoryService historyService;

	@Autowired
	private RuntimeService runtimeService;

	@Autowired
	private TaskService taskService;

	public List<IntermediateCatchEvent> getNextTasks(String processDefinitionId, String taskDefinitionKey,
			Map<String, Object> vars) {
		BpmnModelInstance modelInstance = repositoryService.getBpmnModelInstance(processDefinitionId);
		ModelElementInstance instance = modelInstance.getModelElementById(taskDefinitionKey);
		System.out.println(instance);
		FlowNode flowNode = (FlowNode) instance;
		System.out.println(flowNode);
		return getOutgoingTask(flowNode, vars);
	}

	private List<IntermediateCatchEvent> getOutgoingTask(FlowNode node, Map<String, Object> vars) {
		List<IntermediateCatchEvent> possibleTasks = new ArrayList<>();
		for (SequenceFlow sf : node.getOutgoing()) {
			if (sf.getName() != null) {
				System.out.println("Entering flow node " + sf.getName());
			}
			boolean next = true;
			if (sf.getConditionExpression() != null) {
				ExpressionFactory factory = new ExpressionFactoryImpl();
				org.camunda.bpm.engine.impl.javax.el.ELContext context = new SimpleContext(new SimpleResolver());

				System.out.println("Generating map vars {}" + vars.toString());
				for (Map.Entry<String, Object> v : vars.entrySet()) {
					if (v.getValue() instanceof Boolean) {
						factory.createValueExpression(context, "${" + v.getKey() + "}", Boolean.class).setValue(context,
								v.getValue());
					} else if (v.getValue() instanceof java.util.Date) {
						factory.createValueExpression(context, "${" + v.getKey() + "}", java.util.Date.class)
								.setValue(context, v.getValue());
					} else {
						factory.createValueExpression(context, "${" + v.getKey() + "}", String.class).setValue(context,
								v.getValue());
					}
				}
				org.camunda.bpm.engine.impl.javax.el.ValueExpression expr1 = factory.createValueExpression(context,
						sf.getConditionExpression().getTextContent(), boolean.class);

				next = (Boolean) expr1.getValue(context);
				System.out.println(next);
				System.out.println("Evaluating expression" + sf.getConditionExpression().getTextContent() + "to result "
						+ expr1.getValue(context));

			}

			if (next && sf.getTarget() != null) {
				if (sf.getTarget() instanceof IntermediateCatchEvent) {
					System.out.println("Found next user task {}" + sf.getTarget().getName());
					possibleTasks.add((IntermediateCatchEvent) sf.getTarget());
					break;
				}

				possibleTasks.addAll(getOutgoingTask(sf.getTarget(), vars));
			}

		}
		return possibleTasks;
	}

	@PostMapping("/orderss")
	public List<SucceedingNodes> createUser(@Valid @RequestBody List<OrderDetail> orders) {

		List<IntermediateCatchEvent> nexttasksss = new ArrayList<IntermediateCatchEvent>();
		System.out.println(orders);
		List<SucceedingNodes> nodelist = new ArrayList<SucceedingNodes>();

		orders.stream().forEach((order) -> {

			System.out.println("inside Orders");

			SucceedingNodes nodes = new SucceedingNodes();
			nodes.setOrderId(order.getOrderId());

			List<ProcessInstance> instances = runtimeService.createProcessInstanceQuery()
					.variableValueEquals("orderId", order.getOrderId()).list();
			instances.stream().forEach((instance) -> {
				System.out.println("inside instances");

				String instanceId = instance.getProcessInstanceId();
				String processId = instance.getProcessDefinitionId();

				System.out.println("instance id " + instanceId);
				List<String> taskDefinitionKeys = runtimeService.getActiveActivityIds(instanceId);
				RestTemplate restTemplate = new RestTemplate();

				JSONObject obj = new JSONObject();
				obj.put("orderId", order.getOrderId());
				obj.put("shopId", order.getShopId());
				obj.put("instanceId", instanceId);
				obj.put("taskDefinitionKeys", taskDefinitionKeys);

				HttpHeaders headers = new HttpHeaders();
				headers.setContentType(MediaType.APPLICATION_JSON);

				HttpEntity<JSONObject> entity = new HttpEntity<JSONObject>(obj, headers);
				ResponseEntity<String> response = restTemplate.exchange("https://ecommerce.contacless-shoppingdev.com/orders/getActivityId",
						HttpMethod.POST, entity, String.class);

				String taskDefinitionKey = response.getBody();
				System.out.println(taskDefinitionKey);

				BpmnModelInstance modelInstance = repositoryService.getBpmnModelInstance(processId);
				ModelElementInstance currentActivityInstance = modelInstance.getModelElementById(taskDefinitionKey);
				List<IntermediateCatchEvent> nexttasks = new ArrayList<IntermediateCatchEvent>();

				if (!(currentActivityInstance instanceof IntermediateCatchEvent)) {

					Map<String, Object> variables = runtimeService.getVariables(instanceId);

					variables.put("shopId", order.getShopId());
					nexttasks = getNextTasks(processId, taskDefinitionKey, variables);

				} else {
					nexttasks.add((IntermediateCatchEvent) currentActivityInstance);
				}

				nexttasks.stream().forEach((usertask) -> {
					MessageEventDefinition eventDefinition = (MessageEventDefinition) usertask.getEventDefinitions()
							.iterator().next();
					Message message = eventDefinition.getMessage();
					String messageName = message.getName();

					System.out.println(messageName);
					nodes.setEventName(messageName);

					List<ServiceTask> nextTasks = usertask.getSucceedingNodes().filterByType(ServiceTask.class).list();

					nextTasks.stream().forEach((task) -> {
						nodes.setDisplayName(task.getAttributeValue("name"));

					});

				});

			});

			nodelist.add(nodes);

		});

		return nodelist;
	}
}