package org.argeo.slc.core.execution.generator;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.DefaultExecutionSpec;
import org.argeo.slc.execution.ExecutionContext;
import org.argeo.slc.execution.ExecutionFlow;
import org.argeo.slc.execution.ExecutionSpec;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * Execution Flow calling a list of <code>Runnable</code> (identified by their
 * bean name in the Spring Application Context) after configuring the Execution
 * context and a Map potentially shared by the called <code>Runnable</code>
 * 
 */
public class RunnableCallFlow implements ExecutionFlow, ApplicationContextAware {

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

	/**
	 * Key in the execution context for the index of the call (e.g. 0 for the
	 * first runnable called, ...)
	 */
	public final static String VAR_CALL_INDEX = "slcVar.runnableCallFlow.callIndex";

	/**
	 * Name of the flow. Also bean name
	 */
	private String name;

	/**
	 * Path of the flow
	 */
	private String path;

	/**
	 * Whether an exception in a <code>Runnable</code> shall stop the execution
	 * of the flow
	 */
	private Boolean failOnError = true;

	/**
	 * List of <code>Runnable</code> to call, with bean name, execution
	 * variables and context values
	 */
	private List<RunnableCall> runnableCalls;

	/**
	 * Map potentially referenced by called flows. Updated with the context
	 * values of a Runnable before calling it.
	 */
	private Map<String, Object> sharedContextValuesMap;

	/**
	 * ExecutionSpec of the flow. Does not contain any attribute.
	 */
	private ExecutionSpec executionSpec = new DefaultExecutionSpec();

	/**
	 * Reference to the ExecutionContext
	 */
	private ExecutionContext executionContext;

	/**
	 * Reference to the Spring <code>ApplicationContext</code>. Set via
	 * <code>setApplicationContext</code>, the class implementing
	 * <code>ApplicationContextAware</code>
	 */
	private ApplicationContext applicationContext;

	/**
	 * Runs a <code>Runnable</code> after configuring the Execution Context and
	 * <code>sharedContextValuesMap</code>
	 * 
	 * @param runnable
	 *            the <code>Runnable</code> to call
	 * @param executionVariables
	 *            the variables to add to the <code>ExecutionContext</code>
	 * @param contextValues
	 *            the variables to add to <code>sharedContextValuesMap</code>
	 * @param callIndex
	 *            index of the call (0 for the first called
	 *            <code>Runnable</code>) set as variable of the
	 *            <code>ExecutionContext</code>
	 */
	private void run(Runnable runnable, Map<String, Object> executionVariables,
			Map<String, Object> contextValues, int callIndex) {
		// add all variables to the Execution Context
		for (Map.Entry<String, Object> entry : executionVariables.entrySet()) {
			executionContext.setVariable(entry.getKey(), entry.getValue());
		}

		// add call Index Variable
		executionContext.setVariable(VAR_CALL_INDEX, callIndex);

		// clear sharedContextValues and add all values of contextValues
		if (sharedContextValuesMap != null) {
			sharedContextValuesMap.clear();
			sharedContextValuesMap.putAll(contextValues);
		}

		// then run the runnable
		doExecuteRunnable(runnable);
	}

	public void doExecuteRunnable(Runnable runnable) {
		runnable.run();
	}

	/**
	 * Executes the flow. For each <code>RunnableCall</code>, the corresponding
	 * flow is retrieved from the Spring Application Context, the
	 * <code>ExecutionContext</code> and <code>sharedContextValuesMap</code> are
	 * configured and the <code>Runnable</code> is called.
	 */
	public void run() {
		if (applicationContext == null) {
			throw new SlcException("No ApplicationContext defined");
		}

		try {
			for (int callIndex = 0; callIndex < runnableCalls.size(); ++callIndex) {
				RunnableCall runnableCall = runnableCalls.get(callIndex);
				Object bean = applicationContext.getBean(
						runnableCall.getBeanName(), Runnable.class);
				if (log.isDebugEnabled())
					log.debug("Running flow '" + runnableCall.getBeanName()
							+ "'");
				run((Runnable) bean, runnableCall.getExecutionVariables(),
						runnableCall.getContextValues(), callIndex);
			}
		} catch (RuntimeException e) {
			if (failOnError)
				throw e;
			else {
				log.error("Execution flow failed,"
						+ " but process did not fail"
						+ " because failOnError property"
						+ " is set to false: " + e);
				if (log.isTraceEnabled())
					e.printStackTrace();
			}
		}
	}

	public Iterator<Runnable> runnables() {
		List<Runnable> runnables = new ArrayList<Runnable>();
		for (int callIndex = 0; callIndex < runnableCalls.size(); ++callIndex) {
			RunnableCall runnableCall = runnableCalls.get(callIndex);
			Object bean = applicationContext.getBean(
					runnableCall.getBeanName(), Runnable.class);
			runnables.add((Runnable) bean);
		}
		return runnables.iterator();
	}

	public Runnable getRunnable() {
		if (runnableCalls.size() == 1)
			return runnables().next();
		else
			throw new SlcException("There are " + runnableCalls.size()
					+ " runnables in flow " + getName());
	}

	@Override
	public String toString() {
		return new StringBuffer("RunnableCallFlow ").append(name).toString();
	}

	public ExecutionSpec getExecutionSpec() {
		return executionSpec;
	}

	public String getName() {
		return name;
	}

	public Object getParameter(String key) {
		throw new SlcException("RunnableCallFlow have no parameters");
	}

	public String getPath() {
		return path;
	}

	public Boolean isSetAsParameter(String key) {
		// The ExecutionSpec having no attribute,
		// always return false
		return false;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setPath(String path) {
		this.path = path;
	}

	public void setExecutionContext(ExecutionContext executionContext) {
		this.executionContext = executionContext;
	}

	public void setRunnableCalls(List<RunnableCall> runnableCalls) {
		this.runnableCalls = runnableCalls;
	}

	public void setApplicationContext(ApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
	}

	public void setSharedContextValuesMap(Map<String, Object> contextValues) {
		this.sharedContextValuesMap = contextValues;
	}

	public void setFailOnError(Boolean failOnError) {
		this.failOnError = failOnError;
	}

}