import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;


import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;

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.type.FactField;
import org.drools.definition.type.FactType;
import org.drools.impl.KnowledgeBaseImpl;
import org.drools.io.ResourceFactory;
import org.drools.rule.Package;
import org.drools.runtime.ClassObjectFilter;
import org.drools.runtime.StatefulKnowledgeSession;
import org.drools.runtime.rule.FactHandle;
import org.drools.util.DroolsStreamUtils;

/*
 * debug.drl : File uploaded on guvnor. It declares both the type PerUserCount and the simple rule.
 * Nothing esle needs to be uploaded on guvnor
 *
 *
 * CP=.:.../drools-api.jar:...drools-core.jar:...log4j-1.2.13.jar:.../commons-httpclient-3.1.jar
 *
 *


package mytest.debug.rules


declare PerUserCount
	num : long
	profile : String
end

rule "Event"
	when
	    e: PerUserCount()
	then
        System.out.println("Possible spammer [p=" + e.getProfile() + "] : count = " + e.getNum());
end

 *
 *
 */

public class Test {
	
    // Change that to the IP:port of your guvnor:
	private static final String GUVNOR_END_POINT = "10.15.38.76:8080";

    // Package name 
	private static final String PKG_NAME = "mytest.debug.rules";
	private static final String FACT_TYPE_NAME = "PerUserCount";
	private static final String URL_PREFIX = "/drools-guvnor/org.drools.guvnor.Guvnor/package";
	private static final String RESOURCE_PATH = "/mytest.debug.rules/LATEST";


	private static final Logger log = Logger.getLogger("Test");
	

	private static long count = 1;
	
	private KnowledgeBase newKbase;
	private HttpClient httpClient;
	private StatefulKnowledgeSession knowledgeSession;
	private final String url;
	
	public Test() {
		this.httpClient = new HttpClient();
		StringBuilder url = new StringBuilder();
		url.append("http://");
		url.append(GUVNOR_END_POINT);
		url.append(URL_PREFIX);
		url.append(RESOURCE_PATH);
		this.url = url.toString();
	}
	
	public void startTest() {
		
        downloadPkgFromGuvnor(url);

    	knowledgeSession = newKbase.newStatefulKnowledgeSession(); 

        for (int i = 0; i < 10; i++) {
        	runIteration();    	
        	try {
        		Thread.sleep(5000);
        	} catch(InterruptedException ie) {
        	}
        }
    }

    private Map createFactObject() {
    	Map<String, Object> result = new HashMap<String, Object>();
    	result.put("num", count);
    	result.put("profile", new String("p" + System.currentTimeMillis()) + "-" + count++);
    	return result;
    }
    
    private void clearWorkingMemory(FactType factType) {
        Collection<? extends FactHandle> handles = knowledgeSession.getFactHandles(new ClassObjectFilter(factType.getFactClass()));
        for(FactHandle handle : handles) {
            knowledgeSession.retract(handle);
        } 
    }
    
    private void populateWorkingMemory(Map<String, Object> bean, FactType factType)
    {
        try {
        	Object fact = factType.newInstance();
        	for (String key : bean.keySet()) {
                FactField field = factType.getField(key);
                if (field != null) {
                    field.set(fact, bean.get(key) );
                }

            }            
            knowledgeSession.insert(fact);
        }
        catch (InstantiationException e) {
            log.error(e);
        }
        catch (IllegalAccessException e) {
            log.error(e);
        }
    }

    private void runIteration() {
        final FactType factType = knowledgeSession.getKnowledgeBase().getFactType(PKG_NAME, FACT_TYPE_NAME);
    	clearWorkingMemory(factType);
        for (int i = 0; i < 500; i++) { 
        	Map obj = createFactObject();
        	populateWorkingMemory(obj, factType);
        }
        knowledgeSession.fireAllRules();
    }
    
    
       
    private void downloadPkgFromGuvnor(final String url) {
    	try {
    		
    		HttpMethod method = new GetMethod(url);
    		int status = httpClient.executeMethod(method);
    		if (status != HttpStatus.SC_OK) {
    			log.error("Failed to retriece the binary package");
    			return;
    		}
    		applyRules(url, method.getResponseBodyAsStream());
    	}
    	catch (Exception e) {
    		log.error("Request for " + url + " failed, rolling back update.", e);
    		return;
    	}
    }

       
    private void applyRules(String url, InputStream is) {
        try {
            Object object = DroolsStreamUtils.streamIn( is );
            Package pkg = (Package) object;
            this.newKbase = KnowledgeBaseFactory.newKnowledgeBase();            	

            log.info( "KnowledgeAgent adding KnowledgeDefinitionsPackage " + pkg.getName() );
            ((KnowledgeBaseImpl) newKbase).ruleBase.addPackage( pkg );
        } catch ( Exception e ) {
            log.error( new RuntimeException( "KnowledgeAgent exception while trying to deserialize KnowledgeDefinitionsPackage  ", e ) );
        } finally {
            try {
                is.close();
            } catch ( IOException e ) {
                log.error( new RuntimeException( "KnowledgeAgent exception while trying to close KnowledgeDefinitionsPackage  ", e ) );
            }
        }
    }

	public static void main(String [] args) {
		Test t = new Test();
		t.startTest();
	}
}