/*******************************************************************************
 *******************************************************************************/
package at.gv.egiz.eaaf.core.impl.idp.process.test;

import static at.gv.egiz.eaaf.core.impl.idp.process.ProcessInstanceState.NOT_STARTED;
import static at.gv.egiz.eaaf.core.impl.idp.process.ProcessInstanceState.SUSPENDED;
import static org.junit.Assert.assertEquals;

import java.io.IOException;
import java.io.InputStream;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import at.gv.egiz.eaaf.core.api.idp.process.ProcessEngine;
import at.gv.egiz.eaaf.core.exceptions.ProcessExecutionException;
import at.gv.egiz.eaaf.core.impl.idp.module.test.TestRequestImpl;
import at.gv.egiz.eaaf.core.impl.idp.process.ProcessDefinitionParser;
import at.gv.egiz.eaaf.core.impl.idp.process.ProcessDefinitionParserException;
import at.gv.egiz.eaaf.core.impl.idp.process.ProcessEngineImpl;
import at.gv.egiz.eaaf.core.impl.idp.process.ProcessInstance;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/process/spring/test/SpringExpressionAwareProcessEngineTest-context.xml")
public class ProcessEngineTest {
	
	@Autowired private static ProcessEngine pe;
 
	@Autowired private ApplicationContext applicationContext;
	
	private boolean isInitialized = false;
	
	@Before
	public void init() throws IOException, ProcessDefinitionParserException {
		
		if (!isInitialized) {
			ProcessDefinitionParser pdp = new ProcessDefinitionParser();

			if (pe == null) {
				pe = applicationContext.getBean("processEngine", ProcessEngine.class);
				
			}
			
			((ProcessEngineImpl) pe).setTransitionConditionExpressionEvaluator(new BooleanStringExpressionEvaluator());
			try (InputStream in = ProcessEngineTest.class.getResourceAsStream("/process/test/SampleProcessDefinition1.xml")) {
				((ProcessEngineImpl) pe).registerProcessDefinition(pdp.parse(in));
			}
			try (InputStream in = ProcessEngineTest.class.getResourceAsStream("/process/test/SampleProcessDefinition2.xml")) {
				((ProcessEngineImpl) pe).registerProcessDefinition(pdp.parse(in));
			}

			//initHibernateForTesting();
			isInitialized = true;
		}
	}
	
	private static void initHibernateForTesting() throws IOException{

//		InputStream in = ProcessEngineTest.class.getResourceAsStream("/at/gv/egovernment/moa/id/process/hibernate.configuration.test.properties");
//		Properties props = new Properties();
//		props.load(in);
//
//		try {
//			//ConfigurationDBUtils.initHibernate(props);
//			Configuration config = new Configuration();
//			config.addProperties(props);
//			//config.addAnnotatedClass(ProcessInstanceStore.class);
//			config.addAnnotatedClass(AssertionStore.class);
//			//MOASessionDBUtils.initHibernate(config, props);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
	}
	
	@Test
	public void testSampleProcess1() throws IOException, ProcessDefinitionParserException, ProcessExecutionException {
		
		TestRequestImpl testReq = new TestRequestImpl();
		
		String piId = pe.createProcessInstance("SampleProcess1");
		ProcessInstance pi = pe.getProcessInstance(piId);
		assertEquals(NOT_STARTED, pi.getState());

		// start process
		testReq.setProcessInstanceID(piId);
		pe.start(testReq);
		pi = pe.getProcessInstance(piId);
		assertEquals(SUSPENDED, pi.getState());

		System.out.println("Do something asynchronously");
		testReq.setProcessInstanceID(piId);
		pe.signal(testReq);
		try {
			pi = pe.getProcessInstance(piId);
			throw new ProcessExecutionException("ProcessInstance should be removed already, but it was found.");
			//assertEquals(ENDED, pi.getState());
			
		} catch (IllegalArgumentException e) {
			// do nothing because processInstance should be already removed 
			
		}
	}
	
	@Test
	public void testSampleProcess2() throws IOException, ProcessDefinitionParserException, ProcessExecutionException {

		TestRequestImpl testReq = new TestRequestImpl();
		
		String piId = pe.createProcessInstance("SampleProcess2");
		ProcessInstance pi = pe.getProcessInstance(piId);
		assertEquals(NOT_STARTED, pi.getState());

		// start process
		testReq.setProcessInstanceID(piId);
		pe.start(testReq);
		pi = pe.getProcessInstance(piId);
		assertEquals(SUSPENDED, pi.getState());

		System.out.println("Do something asynchronously");
		testReq.setProcessInstanceID(piId);
		pe.signal(testReq);
		try {
			pi = pe.getProcessInstance(piId);
			throw new ProcessExecutionException("ProcessInstance should be removed already, but it was found.");
			//assertEquals(ENDED, pi.getState());
			
		} catch (IllegalArgumentException e) {
			// do nothing because processInstance should be already removed 
			
		}
		
		
	}

	@Test(expected = IllegalArgumentException.class)
	public void testProcessInstanceDoesNotExist() {
		pe.getProcessInstance("does not exist");
	}

}