package org.drools.integrationtests;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

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

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.base.MapGlobalResolver;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderErrors;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.definition.KnowledgePackage;
import org.drools.io.Resource;
import org.drools.io.ResourceFactory;
import org.drools.persistence.jpa.JPAKnowledgeService;
import org.drools.runtime.Environment;
import org.drools.runtime.EnvironmentName;
import org.drools.runtime.StatefulKnowledgeSession;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import bitronix.tm.resource.jdbc.PoolingDataSource;

public class TimerAndCalendarTest {
    private PoolingDataSource ds1;
    private EntityManagerFactory emf;

    @Test
    public void testTimerRuleAfterReloadSession() throws Exception {
        KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
        StatefulKnowledgeSession ksession = createSession(kbase);
        // if we do not call 'ksession.fireAllRules()', this test will run successfully.
        ksession.fireAllRules();
        
        ksession = disposeAndReloadSession(ksession,kbase);
        
        // build timer rule, if the rule is fired, the list size will increase every 300ms
        String timerRule = "package org.drools.test\n" + 
                            "global java.util.List list \n" + 
                            "rule TimerRule \n" + 
                            "   timer (int:0 300) \n" + 
                            "when \n" + "then \n" + 
                            "        list.add(list.size()); \n" + 
                            " end";
        Resource resource = ResourceFactory.newByteArrayResource(timerRule.getBytes());
        Collection<KnowledgePackage> kpackages = buildKnowledgePackage(resource, ResourceType.DRL);
        kbase.addKnowledgePackages(kpackages);
        
        List<Integer> list = Collections.synchronizedList( new ArrayList<Integer>() );
        ksession.setGlobal( "list", list );
        Assert.assertEquals(0,list.size());
        ksession.fireAllRules();
        Thread.sleep(300);
        // if the rule is fired, the list size will greater than one.
        Assert.assertEquals(true,list.size()>0);
    }
    
    @Before
    public void setUp() throws Exception {
        ds1 = new PoolingDataSource();
        ds1.setUniqueName( "jdbc/testDS1" );
        ds1.setClassName( "org.h2.jdbcx.JdbcDataSource" );
        ds1.setMaxPoolSize( 3 );
        ds1.setAllowLocalTransactions( true );
        ds1.getDriverProperties().put( "user",
                                       "sa" );
        ds1.getDriverProperties().put( "password",
                                       "sasa" );
        ds1.getDriverProperties().put( "URL",
                                       "jdbc:h2:mem:mydb" );
        ds1.init();
        emf = Persistence.createEntityManagerFactory("org.drools.persistence.jpa");
    }
    @After
    public void tearDown() throws Exception {
        try {
            emf.close();
            ds1.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    private StatefulKnowledgeSession createSession(KnowledgeBase kbase) {
        StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession(kbase, null, createEnvironment());
        return ksession;
    }
    
    private StatefulKnowledgeSession disposeAndReloadSession(StatefulKnowledgeSession ksession, KnowledgeBase kbase) {
        int ksessionId = ksession.getId();
        ksession.dispose();
        StatefulKnowledgeSession newksession = JPAKnowledgeService.loadStatefulKnowledgeSession(ksessionId, kbase, ksession.getSessionConfiguration(), createEnvironment());
        return newksession;
    }
    
    private String getTimerRule() {
        String str = "package org.drools.test\n" + 
                      "global java.util.List list \n" + 
                    "rule TimerRule \n" + 
                    "   timer (int:0 300) \n" + 
                    "when \n" + "then \n" + 
                    "        list.add(list.size()); \n" + 
                    " end";
        return str;
    }
    
    private Environment createEnvironment() {
        Environment env = KnowledgeBaseFactory.newEnvironment();
        env.set(EnvironmentName.ENTITY_MANAGER_FACTORY, emf);
        // env.set(EnvironmentName.TRANSACTION_MANAGER,
        // TransactionManagerServices.getTransactionManager());
        env.set(EnvironmentName.GLOBALS, new MapGlobalResolver());
        return env;
    }
    
    private Collection<KnowledgePackage> buildKnowledgePackage(Resource resource, ResourceType resourceType) {
        KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
        kbuilder.add(resource, resourceType);
        KnowledgeBuilderErrors errors = kbuilder.getErrors();
        if (errors != null && errors.size() > 0) {
            for (KnowledgeBuilderError error : errors) {
                System.err.println("Error: " + error.getMessage());
            }
            Assert.fail("KnowledgeBase did not build");
        }
        Collection<KnowledgePackage> packages = kbuilder.getKnowledgePackages();
        return packages;
    }
    
}