package drools;

import java.io.StringReader;
import java.util.Properties;
import java.util.Random;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;

import junit.framework.Assert;

import org.drools.ClockType;
import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseConfiguration;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderConfiguration;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.builder.conf.ClassLoaderCacheOption;
import org.drools.conf.EventProcessingOption;
import org.drools.definition.type.FactType;
import org.drools.event.rule.DebugAgendaEventListener;
import org.drools.event.rule.DebugWorkingMemoryEventListener;
import org.drools.impl.EnvironmentFactory;
import org.drools.io.Resource;
import org.drools.io.ResourceFactory;
import org.drools.marshalling.MarshallerFactory;
import org.drools.marshalling.ObjectMarshallingStrategy;
import org.drools.persistence.jpa.JPAKnowledgeService;
import org.drools.runtime.Environment;
import org.drools.runtime.EnvironmentName;
import org.drools.runtime.KnowledgeSessionConfiguration;
import org.drools.runtime.StatefulKnowledgeSession;
import org.drools.runtime.conf.ClockTypeOption;
import org.drools.runtime.rule.WorkingMemoryEntryPoint;
import org.hibernate.transaction.BTMTransactionManagerLookup;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import bitronix.tm.TransactionManagerServices;
import bitronix.tm.jndi.BitronixInitialContextFactory;

public class NpeTest {

    private final static String DROOLS_PU = "org.drools.persistence.jpa";

    private static KnowledgeBase knowledgeBase;

    private static StatefulKnowledgeSession statefulKnowledgeSession;

    private static KnowledgeSessionConfiguration knowledgeSessionConfiguration;

    private static Environment environment;

    private static EntityManagerFactory entityManagerFactory;

    private static EntityManager entityManager;

    private static TransactionManager transactionManager;

    private static UserTransaction userTransaction;

    private static int id;

    private static String rule = "package drools\n\n" +
            "import java.util.ArrayList\n\n" +
            "declare Event\n" +
            "\t@role(event)\n" +
            //"\t@expires(1s)\n" +
            "\tid: Long\n" +
            "end\n\n" +
            "rule \"test\"\n" +
            "\twhen\n" +
            "\t\t Number(doubleValue > 2) from accumulate($e : Event() over window:time(1h) from entry-point \"S\", count($e))\n" +
            "\t\t $events : ArrayList() from collect($e : Event() over window:time(1h) from entry-point \"S\")\n" +
            "\tthen\n" +
            "\t\tSystem.out.println(\"OK!\");\n" +
            "\t\tfor (Object object : new ArrayList($events)) {\n" +
            "\t\t\tretract(object);\n" +
            "\t\t}\n" +
            "end\n";

    @BeforeClass
    public static void initSuite() {
        KnowledgeBuilderConfiguration knowledgeBuilderConfiguration = KnowledgeBuilderFactory.newKnowledgeBuilderConfiguration();
        KnowledgeBuilder knowledgeBuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(knowledgeBuilderConfiguration);
        System.out.println(rule);
        Resource resource = ResourceFactory.newReaderResource(new StringReader(rule));

        knowledgeBuilder.add(resource, ResourceType.DRL);

        if (knowledgeBuilder.hasErrors()) {
            Assert.fail();
        }

        KnowledgeBaseConfiguration knowledgeBaseConfiguration = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
        knowledgeBaseConfiguration.setOption(EventProcessingOption.STREAM);
        knowledgeBaseConfiguration.setOption(ClassLoaderCacheOption.DISABLED);
        knowledgeBase = KnowledgeBaseFactory.newKnowledgeBase(knowledgeBaseConfiguration);

        knowledgeBase.addKnowledgePackages(knowledgeBuilder.getKnowledgePackages());
    }

    @Before
    public void initCase() {
        System.out.println("==========================================================================================");

        entityManagerFactory = Persistence.createEntityManagerFactory(NpeTest.DROOLS_PU);
        entityManager = entityManagerFactory.createEntityManager();
        transactionManager = TransactionManagerServices.getTransactionManager();

        Properties jndi = new Properties();
        jndi.put(Context.INITIAL_CONTEXT_FACTORY,
                BitronixInitialContextFactory.class.getName());
        InitialContext context = null;
        try {
            context = new InitialContext(jndi);
            userTransaction = (UserTransaction) context.lookup(new BTMTransactionManagerLookup().getUserTransactionName());
        } catch (NamingException e) {
            Assert.fail();
        } finally {
            try {
                context.close();
            } catch (NamingException e) {
                Assert.fail();
            }
        }

        environment = EnvironmentFactory.newEnvironment();
        environment.set(EnvironmentName.ENTITY_MANAGER_FACTORY, entityManagerFactory);
        environment.set(EnvironmentName.APP_SCOPED_ENTITY_MANAGER, entityManager);
        environment.set(EnvironmentName.TRANSACTION_MANAGER, transactionManager);
        environment.set(EnvironmentName.TRANSACTION, userTransaction);
        environment.set(EnvironmentName.OBJECT_MARSHALLING_STRATEGIES, 
                new ObjectMarshallingStrategy[] { MarshallerFactory.newSerializeMarshallingStrategy() });

        knowledgeSessionConfiguration = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
        knowledgeSessionConfiguration.setOption(ClockTypeOption.get(ClockType.REALTIME_CLOCK.getId()));

        entityManager.getTransaction().begin();
        if (statefulKnowledgeSession != null) {
            statefulKnowledgeSession = JPAKnowledgeService.loadStatefulKnowledgeSession(id, knowledgeBase, knowledgeSessionConfiguration, environment);
        } else {
            statefulKnowledgeSession = JPAKnowledgeService.newStatefulKnowledgeSession(knowledgeBase, knowledgeSessionConfiguration, environment);
            id = statefulKnowledgeSession.getId();
        }
        entityManager.getTransaction().commit();

        statefulKnowledgeSession.addEventListener(new DebugAgendaEventListener());
        statefulKnowledgeSession.addEventListener(new DebugWorkingMemoryEventListener());

        entityManager.getTransaction().begin();
    }

    private void event() throws Exception {
        FactType eventType = knowledgeBase.getFactType("drools", "Event");
        Object event = eventType.newInstance();
        eventType.set(event, "id", new Random(System.currentTimeMillis()).nextLong());
        WorkingMemoryEntryPoint entryS = statefulKnowledgeSession.getWorkingMemoryEntryPoint("S");
        entryS.insert(event);
    }

    @Test
    public void first() throws Exception {
        event();
    }

    @Test
    public void second() throws Exception {
        event();
    }

    @Test
    public void third() throws Exception {
        event();
    }

    //@Test
    //public void fourth() throws Exception {
        //event();
    //}

    @After
    public void cleanUpCase() {
        statefulKnowledgeSession.fireAllRules();
        statefulKnowledgeSession.dispose();
        entityManager.getTransaction().commit();
        entityManager.close();
        entityManagerFactory.close();
        System.out.println("==========================================================================================");
    }

}