package de.dfki.km.semanticmeetingannotation;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;

import org.gnowsis.util.RDFLoader;
import org.gnowsis.util.RDFLoaderException;
import org.gnowsis.util.RDFTool;

import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
import com.hp.hpl.jena.ontology.Individual;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntResource;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.ResIterator;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
import com.hp.hpl.jena.vocabulary.RDF;

import de.dfki.km.semanticmeetingannotation.vocabulary.MEETING;

public class OutlookInferenceEngine {

	/**
	 * @param args
	 */
	Model dedu = null;
	

	public Model getDedu() {
		return dedu;
	}

	public void makeOutlookConverting() throws Exception {
		 
	       
	        String ontologyFn = "src/ontologies/Meeting.owl";
	        String rulesFn = "file:src/ontologies/MappingRules.txt"; 
	        String url = "jdbc:mysql://localhost/sparql2sql";
	        String user = "sparql2sql";
	        String pwd = "sparql2sql";
	        Model source = null;
	        Model ontology = null;
	        
	        
	        
	        try {
				ontology = RDFLoader.loadFrom(ontologyFn);
			} catch (RDFLoaderException e) {
				e.printStackTrace();
			}
	        
			String query = "PREFIX rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n" +
			
			"PREFIX foaf:    <http://xmlns.com/foaf/0.1/>\n" +
			"PREFIX rdfs:    <http://www.w3.org/2000/01/rdf-schema#>\n" +
			"PREFIX mail:    <http://www.gnowsis.org/ont/email_0.1#>\n" +
			"CONSTRUCT { ?s ?p ?o. }\n" +
			"WHERE {GRAPH ?source { ?s ?p ?o}}\n";
			OutlookData outlook;
			try {
			   outlook = new OutlookData(url,user,pwd);   
			} catch (Exception e) {
				e.printStackTrace();
				throw e;
			}
			
			try {
				outlook.excuteQuery(query);
			} catch (Exception e) {
				
				e.printStackTrace();
			}
			
			source = outlook.getResult();
			
	        // load reasoner
	        List rules = Rule.rulesFromURL(rulesFn);
	        GenericRuleReasoner reasoner = new GenericRuleReasoner(rules);
	        reasoner.setMode(GenericRuleReasoner.HYBRID);
	        // load an Inference Model, from reasoner, ontology and instance file
	        InfModel inf = ModelFactory.createInfModel(reasoner, ontology, source);
	        inf.setNsPrefixes( ontology );
	        // make the inference!
	        dedu = inf;
//	        dedu = inf.getDeductionsModel();
	        String s = RDFTool.modelToString(dedu, "N3");
	        // dump deductions 
//	        System.out.println(s);
//	        dedu.write(System.out, "RDF/XML");
//	        System.out.println("-------------------all-------------------");
//	        inf.write(System.out, "RDF/XML");
	        }
 
	public static void main(String[] args) throws Exception {
		OutlookInferenceEngine engine = new OutlookInferenceEngine();
		engine.makeOutlookConverting();
		//convert outlook deductionModel to the form of "ontModel"
		SemanticMeetingData data = new SemanticMeetingData();
		data.init();
		data.createNewInstanceModel("OutlookData");
		data.setDataModel(data.getOnemeeting());
		data.setOntModel(data.getMeetingOntology());
    	data.getResourceds().setResource(null);
		OntModel ont = data.getOnemeetingOnt();
		Model outlookModel = engine.getDedu();
		// list persons
		for (ResIterator r = outlookModel.listSubjectsWithProperty(RDF.type, MEETING.Person);
		 	r.hasNext(); )
		{
			Resource person = r.nextResource();
			Individual indi = ont.createIndividual(person.toString(),MEETING.Person);
			//System.out.println(person);
			StmtIterator property = person.listProperties();
    		while(property.hasNext()){
    	    Statement s = property.nextStatement();
    		Property p = s.getPredicate();
    		indi.addProperty(p,outlookModel.getProperty(person,p).getObject());
	    }
		
		}
		//list appointment
		for (ResIterator r = outlookModel.listSubjectsWithProperty(RDF.type, MEETING.Meeting);
	 	r.hasNext(); )
	   {
		Resource meeting = r.nextResource();
//		System.out.println(meeting);
		Individual indi = ont.createIndividual(meeting.toString(),MEETING.Meeting);
		StmtIterator property = meeting.listProperties();
		while(property.hasNext()){
	    
		Statement s = property.nextStatement();
		Property p = s.getPredicate();
	    indi.addProperty(p,outlookModel.getProperty(meeting,p).getObject());
        }
	}
		
	     data.setOnemeeting(ont);
  		 data.setDataModel(data.getOnemeeting());
  		 PrintWriter out = null;
  		 
  		try {
			 out = new PrintWriter(new FileOutputStream("./testOutlook.owl",false));
			 com.hp.hpl.jena.rdf.model.RDFWriter writer = data.getResourceds().getModel().getWriter("RDF/XML-ABBREV") ;
			 writer.setProperty("xmlbase","http://www.somewhere.org/ont/outlook") ;
			 writer.write(data.getResourceds().getModel(),out,"http://www.somewhere.org/ont/outlook#");
			 System.out.println("has saved");
			 }
			 catch (FileNotFoundException ex) {
			 ex.printStackTrace();
			 }
			 out.close() ;
	}
}