import java.util.Properties;

import junit.framework.Assert;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmContext;
import org.jbpm.graph.def.ActionHandler;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.graph.exe.ProcessInstance;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class SimpleTest implements ActionHandler {

	static Log logger = LogFactory.getLog(SimpleTest.class);
	static String SUBPROCESS_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
								"<process-definition xmlns=\"urn:jbpm.org:jpdl-3.2\" name=\"simplesubtest\">" +
								"<start-state name=\"start-state1\">" + 
								"	<description>start of the process</description>" +
								"	<transition name=\"start-to-check\" to=\"fileCheck\" />" +
								"</start-state>" +
							
								"<node name=\"fileCheck\" async=\"true\">" +
								"	<action name=\"action_filecheck\" class=\"SimpleTest\">" +
								"	</action>" +
								"	<transition name=\"check-to-do\" to=\"doWhatever\"></transition>" +
								"</node>" +
								
								"<node name=\"doWhatever\" async=\"true\">" +
								"	<action name=\"action_do\" class=\"SimpleTest\">" +
								"	</action>" +
								"	<transition name=\"check-to-end\" to=\"end-state-success\"></transition>" +
								"</node>" +
								
								"<end-state name=\"end-state-success\">" +
								"	<description>process finished normally</description>" +
								"</end-state>" +
								"</process-definition>";
	
	static String PROCESS_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
								"<process-definition xmlns=\"urn:jbpm.org:jpdl-3.2\" name=\"simpletest\">" +
								"<start-state name=\"start-state1\">" + 
								"	<description>start of the process</description>" +
								"	<transition name=\"start-to-check\" to=\"fileCheck\" />" +
								"</start-state>" +
							
								"<node name=\"fileCheck\" async=\"true\">" +
								"	<action name=\"action_check\" class=\"SimpleTest\">" +
								"	</action>" +
								"	<transition name=\"check-to-fork\" to=\"fork1\"></transition>" +
								"</node>" +
							
								"<fork name=\"fork1\" async=\"true\">" +
								"	<transition name=\"toNode1\" to=\"node1\"></transition>" +
								"	<transition name=\"toNode2\" to=\"node2\"></transition>" +
								"</fork>" +
							
								"<process-state name=\"node1\" async=\"true\">" +
								"	<sub-process name=\"simplesubtest\" />" +
								"	<transition name=\"node1toJoin1\" to=\"join1\"></transition>" +
								"</process-state>" +
							
								"<process-state name=\"node2\" async=\"true\">" +
								"	<sub-process name=\"simplesubtest\" />" +
								"	<transition name=\"node2toJoin1\" to=\"join1\"></transition>" +
								"</process-state>" +
							
								"<join name=\"join1\" async=\"true\">" +
								"	<transition name=\"joinToEnd\" to=\"end-state-success\"></transition>" +
								"</join>" +
							
								"<end-state name=\"end-state-success\">" +
								"	<description>process finished normally</description>" +
								"</end-state>" +
								"</process-definition>";

	static JbpmConfiguration config;
	
	@BeforeClass
	public static void beforeClass()
	{	
		config = JbpmConfiguration.getInstance("jbpm-test.cfg.xml");
		config.createSchema();		
		config.startJobExecutor();		
	}
	
	@AfterClass
	public static void afterClass()
	{
		config.close();
	}
	
	@Test
	public void testSimple() throws Exception 
	{
		//Assert.assertTrue(config.getJobExecutor().getNbrOfThreads()>1);
		
		logger.info("### TEST: deploy + start processes ###");
		
		// create test properties
		final Properties testProperties =new Properties();
		testProperties.put("test", "true");

		execute(new JbpmContextCallback<Void>(){
			public Void doWithinJpbmContext(JbpmContext context) throws Exception {
				logger.info(context);

				context.deployProcessDefinition(ProcessDefinition
						.parseXmlString(SUBPROCESS_XML));
				context.deployProcessDefinition(ProcessDefinition
						.parseXmlString(PROCESS_XML));
				return null;
			}
		});

		for (int i = 0; i < 10; i++)
		{
			logger.info("### TEST: starting process " + i + " ###");

			final ProcessInstance pi = execute(new JbpmContextCallback<ProcessInstance>(){
				public ProcessInstance doWithinJpbmContext(JbpmContext context) throws Exception {				
					ProcessInstance pi = context.newProcessInstance("simpletest");
					pi.getContextInstance().addVariables(testProperties);
					context.save(pi);
					pi.signal();
					return pi;
				}
			});
			logger.info("### TEST: wait for process completion ###");
		
			waitFor( pi.getId() ); 
			
			execute(new JbpmContextCallback<Void>(){
				public Void doWithinJpbmContext(JbpmContext context) throws Exception {
					ProcessInstance pi2 = context.getProcessInstance(pi.getId());
					Assert.assertEquals("end-state-success", pi2.getRootToken().getNode().getName());
					return null;
				}
			});
			logger.info("### TEST: finished ###");
		}
	}
	
	
	protected <T> T execute(JbpmContextCallback<T> callback) throws Exception
	{
		JbpmContext context = config.createJbpmContext();
		try
		{
			return callback.doWithinJpbmContext(context);
		}
		finally
		{
			context.close();
		}
	}
	
	protected void waitFor(final long piId) throws Exception
	{        
		long startTime = System.currentTimeMillis();
		
		int MIN = 2;
		
		while (true)		
		{
			if (System.currentTimeMillis() - startTime > MIN * 60 * 1000) 
			{
				Assert.fail("Aborting after "+MIN+" min.");
				return;
			}
			
			logger.info("waiting for workflow completion...."); // + pi.getRootToken().getNode().getName() );
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				logger.error("", e);
				Assert.fail();
			}
			
			if (execute(new JbpmContextCallback<Boolean>(){

				public Boolean doWithinJpbmContext(JbpmContext context) throws Exception {
					return context.getProcessInstance(piId).hasEnded();
				}})) break;			
		 }		
	}
	
	public interface JbpmContextCallback<T> 
	{
		public T doWithinJpbmContext(JbpmContext context) throws Exception;
	}

	
	public void execute(ExecutionContext executionContext) throws Exception {

			System.out.println("ACTION: begin SimpleActionHandler");
			Thread.sleep(1000);
			System.out.println("ACTION: begin SimpleActionHandler");
			executionContext.leaveNode();
	}
}