D-Net

package eu.dnetlib.msro.workflows.graph;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.annotation.Resource;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.Node;

import org.springframework.beans.factory.annotation.Required;

import com.google.common.collect.Sets;

import eu.dnetlib.conf.PropertyFetcher;

import eu.dnetlib.msro.workflows.util.NodeHelper;

import eu.dnetlib.rmi.manager.MSROException;

/**

 * Created by michele on 19/11/15.

 */

public class GraphLoader {

	private NodeHelper nodeHelper;

	@Resource(name = "propertyFetcher")

	private PropertyFetcher propertyFetcher;

	private static final Log log = LogFactory.getLog(GraphLoader.class);

	public Graph loadGraph(final Document doc, final Map<String, String> globalParams) throws MSROException {

		final Graph graph = new Graph();

		for (final Object o : doc.selectNodes("//CONFIGURATION/WORKFLOW/NODE")) {

			final Element n = (Element) o;

			final String nodeName = n.valueOf("@name");

			final String nodeType = n.valueOf("@type");

			final boolean isStart = StringUtils.equalsIgnoreCase(n.valueOf("@isStart"), "true");

			final boolean isJoin = StringUtils.equalsIgnoreCase(n.valueOf("@isJoin"), "true");

			final Map<String, Object> params = calculateParamsForNode(n, globalParams);

			if (isStart) {

				graph.addNode(GraphNode.newStartNode(nodeName, nodeType, params));

			} else if (isJoin) {

				graph.addNode(GraphNode.newJoinNode(nodeName, nodeType, params));

			} else {

				graph.addNode(GraphNode.newNode(nodeName, nodeType, params));

			}

			for (final Object o1 : n.selectNodes(".//ARC")) {

				final Element a = (Element) o1;

				final String arcName = a.valueOf("@name");

				final String to = a.valueOf("@to");

				graph.addArc(new Arc(StringUtils.isNotBlank(arcName) ? arcName : Arc.DEFAULT_ARC, nodeName, to));

			}

			graph.addNode(GraphNode.newSuccessNode());

		}

		checkValidity(graph);

		return graph;

	}

	public Map<String, Object> calculateParamsForNode(final Node node, final Map<String, String> globalParams) {

		final Map<String, Object> params = new HashMap<String, Object>();

		for (final Object o : node.selectNodes(".//PARAM")) {

			final Element p = (Element) o;

			final String pName = p.valueOf("@name");

			final String pValue = p.valueOf("@value");

			final String pRef = p.valueOf("@ref");

			final String pProp = p.valueOf("@property");

			if (StringUtils.isNotBlank(pRef) && StringUtils.isNotBlank(globalParams.get(pRef))) {

				params.put(pName, globalParams.get(pRef));

			} else if (StringUtils.isNotBlank(pValue)) {

				params.put(pName, pValue);

			} else if (StringUtils.isNotBlank(pProp)) {

				params.put(pName, resolveProperty(pProp));

			} else if (p.selectSingleNode("./MAP") != null) {

				final Map<String, String> map = new HashMap<String, String>();

				for (final Object e : p.selectNodes("./MAP/ENTRY")) {

					final Element entry = (Element) e;

					final String eKey = entry.valueOf("@key");

					final String eValue = entry.valueOf("@value");

					final String eRef = entry.valueOf("@ref");

					final String eProp = entry.valueOf("@property");

					if (StringUtils.isNotBlank(eRef) && StringUtils.isNotBlank(globalParams.get(eRef))) {

						map.put(eKey, globalParams.get(eRef));

					} else if (StringUtils.isNotBlank(eValue)) {

						map.put(eKey, eValue);

					} else if (StringUtils.isNotBlank(eProp)) {

						map.put(eKey, resolveProperty(eProp));

					}

				}

				params.put(pName, map);

			} else if (p.selectSingleNode("./LIST") != null) {

				final List<String> list = new ArrayList<String>();

				for (final Object i : p.selectNodes("./LIST/ITEM")) {

					final Element item = (Element) i;

					final String iValue = item.valueOf("@value");

					final String iRef = item.valueOf("@ref");

					final String iProp = item.valueOf("@property");

					if (StringUtils.isNotBlank(iRef) && StringUtils.isNotBlank(globalParams.get(iRef))) {

						list.add(globalParams.get(iRef));

					} else if (StringUtils.isNotBlank(iValue)) {

						list.add(iValue);

					} else if (StringUtils.isNotBlank(iProp)) {

						list.add(resolveProperty(iProp));

					}

				}

				params.put(pName, list);

			}

		}

		return params;

	}

	private String resolveProperty(final String propertyName) {

		if (!this.propertyFetcher.getProps().containsKey(propertyName)) {

			log.warn("unable to find system property: " + propertyName);

		}

		return this.propertyFetcher.getProperty(propertyName);

	}

	private void checkValidity(final Graph graph) throws MSROException {

		final Set<String> nodesFromArcs = new HashSet<String>();

		boolean foundSuccess = false;

		boolean foundStart = false;

		for (final Arc arc : graph.getArcs()) {

			if (StringUtils.isBlank(arc.getFrom()) || StringUtils.isBlank(arc.getFrom())) { throw new MSROException("Invalid arc: missing from e/o to"); }

			if (StringUtils.equals(arc.getTo(), GraphNode.SUCCESS_NODE)) {

				foundSuccess = true;

			}

			nodesFromArcs.add(arc.getFrom());

			nodesFromArcs.add(arc.getTo());

		}

		if (!foundSuccess) { throw new MSROException("Arc to success not found"); }

		final Set<String> diff = Sets.symmetricDifference(graph.nodeNames(), nodesFromArcs);

		if (!diff.isEmpty()) { throw new MSROException("Missing or invalid nodes in arcs: " + diff); }

		for (final GraphNode n : graph.nodes()) {

			if (StringUtils.isBlank(n.getName())) { throw new MSROException("Invalid node: missing name"); }

			if (n.isStart()) {

				foundStart = true;

			}

			if (!this.nodeHelper.isValidType(n.getType())) { throw new MSROException("Invalid node type: " + n.getType()); }

		}

		if (!foundStart) { throw new MSROException("Start node not found"); }

	}

	public NodeHelper getNodeHelper() {

		return this.nodeHelper;

	}

	@Required

	public void setNodeHelper(final NodeHelper nodeHelper) {

		this.nodeHelper = nodeHelper;

	}

}