package simplified.tests;

import static org.camunda.bpm.engine.test.assertions.bpmn.AbstractAssertions.init;
import static org.camunda.bpm.engine.test.assertions.bpmn.AbstractAssertions.processEngine;
import static org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests.assertThat;
import static org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests.complete;
import static org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests.externalTask;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;

import javax.inject.Named;

import org.apache.ibatis.logging.LogFactory;
import org.camunda.bpm.engine.ManagementService;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import org.camunda.bpm.engine.runtime.Job;
import org.camunda.bpm.engine.runtime.ProcessInstance;
import org.camunda.bpm.engine.test.Deployment;
import org.camunda.bpm.engine.test.ProcessEngineRule;
import org.camunda.bpm.engine.test.mock.Mocks;
import org.camunda.bpm.extension.process_test_coverage.junit.rules.TestCoverageProcessEngineRuleBuilder;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;

/**
 * Test case starting an in-memory database-backed Process Engine.
 */
public class SimplifiedTest {

  @ClassRule
  @Rule
  public static ProcessEngineRule rule = TestCoverageProcessEngineRuleBuilder.create().build();

  static {
    LogFactory.useSlf4jLogging();
  }

  @Before
  public void setup() {
    init(rule.getProcessEngine());
    
    registerNamed(
		new Step1Delegate(),
		new Step2Delegate()
		);
  }

  /**
   * Simplified test of the workflow.
   */
  @Test
  @Deployment(resources = {"wf-simplified.bpmn"})
  public void testWorkflowExecution() {
	  ProcessInstance pi = this.startWf("TheBusinessKey");
	  assertNotNull("processInstance", pi);
	  
	  continueTasks(pi, "step1");
	  continueTasks(pi, "step2", "ocr");
	  
	  assertThat(pi).isEnded();
  }
  
  /*
   * ****************************** U T I L I T I E S ******************************
   */
  
  private void registerNamed(Object... objects) {
	  for (Object o : objects) {
		  Named named = o.getClass().getAnnotation(Named.class);
		  if (named == null) {
			  System.err.printf("######## missing @Named() annotation on class: %s\n", o.getClass().getName());
			  continue;
		  }
		  String name = named.value();
		  if (name == null || name.isEmpty()) {
			  System.err.printf("######## missing value in @Named() annotation on class: %s\n", o.getClass().getName());
			  continue;
		  }
		  Mocks.register(name, o);
	  }
  }
  
  private ProcessInstance startWf(String businessKey) {
	  // start a new process by sending the corresponding message
	  ProcessInstance pi = processEngine().getRuntimeService()
		  .createMessageCorrelation("SimplifiedStartMessage")
		  .processInstanceBusinessKey(businessKey)
		  .correlateStartMessage();
	  
	  // done
	  return pi;
  }
  
  private static void continueTasks(ProcessInstance pi, String... activities) {
	  assertThat(pi).isNotEnded();
	  
	  ManagementService managementService = rule.getManagementService();
	  
	  for (String activity : activities) {
		  Job job = managementService.createJobQuery()
				  		.processInstanceId(pi.getProcessInstanceId())
				  		.activityId(activity)
				  		.singleResult();
		  if (job == null) {
			  fail("no Job found for activity '" + activity + "'");
		  }
		  if (activity.equalsIgnoreCase("ocr")) {
			  assertThat(pi).isWaitingAt(activity).externalTask().hasTopicName("ExternalOCR");
			  complete(externalTask());
			  continue;
		  }
		  managementService.executeJob(job.getId());
	  }
  }
  
  /*
   * ****************************** delegates ******************************
   */
  
  @Named("STEP1")
  private static class Step1Delegate implements JavaDelegate {
  	
  	public Step1Delegate() { }

  	@Override
  	public void execute(DelegateExecution execution) throws Exception {
  		System.out.println("## STEP 1 ##\n");
  	}

  }
  
  @Named("STEP2")
  private static class Step2Delegate implements JavaDelegate {
  	
  	public Step2Delegate() { }

  	@Override
  	public void execute(DelegateExecution execution) throws Exception {
  		System.out.println("## STEP 2 ##\n");
  	}

  }


}