package com.sample;

import java.util.HashMap;
import java.util.Map;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.drools.core.command.GetVariableCommand;
import org.drools.core.command.impl.GenericCommand;
import org.jbpm.process.audit.AuditLogService;
import org.jbpm.process.audit.AuditLoggerFactory;
import org.jbpm.process.audit.AuditLoggerFactory.Type;
import org.jbpm.process.audit.JPAAuditLogService;
import org.jbpm.process.core.context.variable.VariableScope;
import org.jbpm.process.instance.context.variable.VariableScopeInstance;
import org.jbpm.test.JBPMHelper;
import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.api.runtime.manager.RuntimeEngine;
import org.kie.api.runtime.manager.RuntimeEnvironmentBuilder;
import org.kie.api.runtime.manager.RuntimeManager;
import org.kie.api.runtime.manager.RuntimeManagerFactory;
import org.kie.api.runtime.process.WorkflowProcessInstance;
import org.kie.internal.command.Context;

public class ProcessMain {

    private static AuditLogService audit;

    public static void main(String[] args) {
        KieServices ks = KieServices.Factory.get();
        KieContainer kContainer = ks.getKieClasspathContainer();
        KieBase kbase = kContainer.getKieBase("kbase");

        RuntimeManager manager = createRuntimeManager(kbase);
        RuntimeEngine engine = manager.getRuntimeEngine(null);
        final KieSession ksession = engine.getKieSession();

        AuditLoggerFactory.newInstance(Type.JPA, ksession, null);

        Map<String, Object> params = new HashMap<String, Object>();
        params.put("test", "value");

        final WorkflowProcessInstance p = (WorkflowProcessInstance) ksession.startProcess("com.sample.bpmn.hello", params);

        Map<String, Object> variables = ksession.execute(new GenericCommand<Map<String, Object>>() {

            private static final long serialVersionUID = 1L;

            @Override
            public Map<String, Object> execute(Context context) {
                org.jbpm.process.instance.ProcessInstance processInstance = (org.jbpm.process.instance.ProcessInstance) ksession.getProcessInstance(p
                        .getId());
                VariableScopeInstance variableScope = (VariableScopeInstance) processInstance.getContextInstance(VariableScope.VARIABLE_SCOPE);
                return variableScope.getVariables();
            }

        });

        /**
         * Via Command
         */
        String cmdStr = (String) ksession.execute(new GetVariableCommand("test"));

        /**
         * Via WorkflowProcessInstance
         */
        String wfStr = (String) p.getVariable("test");

        /**
         * Via Audit Log
         */

        String auditStr = audit.findVariableInstances(p.getId(), "test").get(0).getValue();

        /**
         * Via VariableScopeInstance
         */
        String varScopeStr = (String) variables.get("test");

        System.out.println(cmdStr);
        System.out.println(wfStr);
        System.out.println(auditStr);
        System.out.println(varScopeStr);

        manager.disposeRuntimeEngine(engine);
        System.exit(0);
    }

    private static RuntimeManager createRuntimeManager(KieBase kbase) {
        JBPMHelper.startH2Server();
        JBPMHelper.setupDataSource();
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("org.jbpm.persistence.jpa");

        audit = new JPAAuditLogService(emf);
        ((JPAAuditLogService) audit).setPersistenceUnitName("org.jbpm.persistence.jpa");

        RuntimeEnvironmentBuilder builder = RuntimeEnvironmentBuilder.Factory.get().newDefaultBuilder().entityManagerFactory(emf)
                .knowledgeBase(kbase);
        return RuntimeManagerFactory.Factory.get().newSingletonRuntimeManager(builder.get(), "com.sample:example:1.0");
    }

}