/*
    ORDI - Ontology Repository and Data Integration
   
    Copyright (c) 2004-2007, OntoText Lab. / SIRMA
   
    This library is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 2.1 of the License, or (at your option)
    any later version.
   This library is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   details.
   You should have received a copy of the GNU Lesser General Public License along
   with this library; if not, write to the Free Software Foundation, Inc.,
   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  package com.ontotext.ordi.compatibilitytests;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.NoSuchElementException;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import junit.framework.TestCase;
  
  import org.openrdf.model.Literal;
  import org.openrdf.model.Resource;
  import org.openrdf.model.Statement;
  import org.openrdf.model.URI;
  import org.openrdf.model.ValueFactory;
  import org.openrdf.model.impl.ValueFactoryImpl;
  import org.openrdf.query.Binding;
  import org.openrdf.query.BindingSet;
  import org.openrdf.query.impl.EmptyBindingSet;
  import org.openrdf.query.parser.ParsedQuery;
  import org.openrdf.query.parser.sparql.SPARQLParser;
  
  import com.ontotext.ordi.iterator.CloseableIterator;
  import com.ontotext.ordi.tripleset.Listener;
  import com.ontotext.ordi.tripleset.ORDIConst;
  import com.ontotext.ordi.tripleset.TConnection;
  import com.ontotext.ordi.tripleset.TSource;
  import com.ontotext.ordi.tripleset.TStatement;
  
  /**
   * This is base test for compliance with ORDI tripleset model. To test
   * implementation please inherit this class and in the constructor of the
   * extending class initialize your implementation and
   * TestBaseTriplesetModel.source field.
   * 
   * TODO: Transaction support semantics is not yet fully determined!
   * 
   * @author vassil
   */
  public abstract class CompatibilityTests extends TestCase {
  
  	protected static final String SAMPLE_TRIPLE_FILE = "/test_triples.nt";
  	protected static final String SAMPLE_SPARQL_FILE = "/test_triples.sparql";
  	
  	protected TSource source;
  
  	/*****************************************************************
  	 * Test: Basic ORDI operations 
  	 ****************************************************************/
  	public void testBasicORDIOperationsAdd() throws Exception {
  		TConnection connection = source.getConnection();
  		ValueFactory factory = new ValueFactoryImpl();
  		Resource subj = factory.createBNode();
  		URI pred = factory.createURI("urn:ordi:compatibilitytest:predicate");
  		Literal obj = factory.createLiteral("Comaptibilitytest Literal)");
  		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
  		URI ts = factory.createURI("urn:ordi:compatibilitytest:tripleset");
  		URI ts2 = factory.createURI("urn:ordi:compatibilitytest:tripleset2");
  		
  		TStatement statement = connection.addStatement(subj, pred, obj, namedGraph);
  		assertEquals(statement.getSubject(), subj);
  		assertEquals(statement.getPredicate(), pred);
  		assertEquals(statement.getObject(), obj);
  		assertEquals(statement.getContext(), namedGraph);
  		assertEquals(statement.getTriplesetIterator().hasNext(), false);
  		
  		statement = connection.addStatement(subj, pred, obj, namedGraph, ts);
  		assertEquals(statement.getSubject(), subj);
  		assertEquals(statement.getPredicate(), pred);
  		assertEquals(statement.getObject(), obj);
  		assertEquals(statement.getContext(), namedGraph);
  		assertEquals(statement.getTriplesetIterator().hasNext(), true);
  		assertEquals(statement.getTriplesetIterator().next(), ts);
  		
  		assertEquals(connection.associateTripleset(subj, pred, obj, namedGraph, ts2), 1);
  		
  		statement = connection.addStatement(subj, pred, obj, namedGraph, ts);
 		assertEquals(statement.getSubject(), subj);
 		assertEquals(statement.getPredicate(), pred);
 		assertEquals(statement.getObject(), obj);
 		assertEquals(statement.getContext(), namedGraph);
 		assertEquals(statement.isMemberOf(ts), true);
 		assertEquals(statement.isMemberOf(ts2), true);
 		
 		assertEquals(connection.removeStatement(subj, pred, obj, namedGraph), 1);
 		assertEquals(connection.removeStatement(null, null, null, null), 0);		
 	}
 	
 	public void testBasicORDIOperationsAssociate() throws Exception {
 		TConnection connection = source.getConnection();
 		ValueFactory factory = new ValueFactoryImpl();
 		Resource subj = factory.createBNode();
 		URI pred = factory.createURI("urn:ordi:compatibilitytest:predicate");
 		Literal obj = factory.createLiteral("Comaptibilitytest Literal");
 		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
 		URI ts = factory.createURI("urn:ordi:compatibilitytest:tripleset");
 		
 		
 		//FIXME: Uncomment the failiing tests
 		//assertEquals(connection.associateTripleset(null, null, null, null, ts), 0);
 		TStatement statement = connection.addStatement(subj, pred, obj, namedGraph);
 		assertEquals(statement.getSubject(), subj);
 		assertEquals(statement.getPredicate(), pred);
 		assertEquals(statement.getObject(), obj);
 		assertEquals(statement.getContext(), namedGraph);
 		
 		for (int i = 0; i < 1000; i++) { 
 			assertEquals(connection.associateTripleset(subj, pred, 
 					obj, namedGraph, factory.createURI(ts.toString()+i)), 1);
 			statement = connection.addStatement(subj, pred, obj, namedGraph);
 			assertEquals(statement.getSubject(), subj);
 			assertEquals(statement.getPredicate(), pred);
 			assertEquals(statement.getObject(), obj);
 			assertEquals(statement.getContext(), namedGraph);
 			assertEquals(statement.isMemberOf(factory.createURI(ts.toString()+i)), true);
 		}
 		
 		statement = connection.addStatement(subj, pred, obj, namedGraph);
 		Iterator<URI> iterator = statement.getTriplesetIterator();
 		for (int i = 0; i < 1000; i++) {
 			iterator.next();
 		}
 		assertFalse(iterator.hasNext());
 		
 		for (int i = 0; i < 1000; i++) {
 			assertEquals(connection.deassociateTripleset(subj, pred, 
 					obj, namedGraph, factory.createURI(ts.toString()+i)), 1);
 			statement = connection.addStatement(subj, pred, obj, namedGraph);
 			assertEquals(statement.getSubject(), subj);
 			assertEquals(statement.getPredicate(), pred);
 			assertEquals(statement.getObject(), obj);
 			assertEquals(statement.getContext(), namedGraph);
 			assertEquals(statement.isMemberOf(factory.createURI(ts.toString()+i)), false);
 		}
 		
 		statement = connection.addStatement(subj, pred, obj, namedGraph);
 		assertEquals(statement.getSubject(), subj);
 		assertEquals(statement.getPredicate(), pred);
 		assertEquals(statement.getObject(), obj);
 		assertEquals(statement.getContext(), namedGraph);
 		assertEquals(statement.getTriplesetIterator().hasNext(), false);
 		
 		assertEquals(connection.removeStatement(subj, pred, obj, namedGraph), 1);
 		assertEquals(connection.removeStatement(null, null, null, null), 0);
 	}
 	
 	public void testBasicORDIOperationRemove() throws Exception {
 		TConnection connection = source.getConnection();
 		NTParser parser = new NTParser(this.getClass().getResourceAsStream(SAMPLE_TRIPLE_FILE));
 		ValueFactory factory = new ValueFactoryImpl();
 		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
 		URI namedGraph2 = factory.createURI("urn:ordi:compatibilitytest:namedgraph2");
 		URI namedGraph3 = factory.createURI("urn:ordi:compatibilitytest:namedgraph3");
 		
 		Statement st = null;
 		Statement lastSt = null;
 		int count = 0;
 		while((st = parser.next()) != null) {			
 			connection.addStatement(st.getSubject(), st.getPredicate(),
 					st.getObject(), namedGraph);
 			connection.addStatement(st.getSubject(), st.getPredicate(), 
 					st.getObject(), namedGraph2);
 			connection.addStatement(st.getSubject(), st.getPredicate(), 
 					st.getObject(), namedGraph3);
 			lastSt = st;
 			count++;
 		}
 
 		parser = new NTParser(this.getClass().getResourceAsStream(SAMPLE_TRIPLE_FILE));
 		while((st = parser.next()) != null) {
 			assertEquals(connection.removeStatement(st.getSubject(), st.getPredicate(),
 					st.getObject(), namedGraph), 1);
 		}
 		
 		assertEquals(connection.removeStatement(null, null, null, namedGraph2), count);
 		
 		int removed = 0;
 		removed = connection.removeStatement(null, lastSt.getPredicate(), lastSt.getObject(), namedGraph3);
 		assertTrue(removed > 0);
 		count -= removed;
 		removed = connection.removeStatement(lastSt.getSubject(), null,
 				null, namedGraph3);
 		assertTrue(removed > 0);
 		count -= removed;
 		removed = connection.removeStatement(null, null, null, namedGraph3);
 		assertTrue(removed > 0);
 		count -= removed;
 		assertTrue(count == 0);
 		assertEquals(connection.removeStatement(null, null, null, null), 0);
 	}
 	
 	public void testBasicORDIOperationSearch() throws Exception {    
 		TConnection connection = source.getConnection();
 		connection.removeStatement(null, null, null, null);
 		
 		NTParser parser = new NTParser(this.getClass().getResourceAsStream(SAMPLE_TRIPLE_FILE));
 		ValueFactory factory = new ValueFactoryImpl();
 		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
 		URI namedGraph2 = factory.createURI("urn:ordi:compatibilitytest:namedgraph2");
 		URI namedGraph3 = factory.createURI("urn:ordi:compatibilitytest:namedgraph3");
 		URI ts = factory.createURI("urn:ordi:compatibilitytest:tripleset");
 		URI ts2 = factory.createURI("urn:ordi:compatibilitytest:tripleset2");
 		
 		Statement st = null;
 		Statement lastSt = null;
 		while((st = parser.next()) != null) {
 			connection.addStatement(st.getSubject(), st.getPredicate(),
 					st.getObject(), namedGraph);
 			connection.addStatement(st.getSubject(), st.getPredicate(),
 					st.getObject(), namedGraph2, ts);
 			connection.addStatement(st.getSubject(), st.getPredicate(),
 					st.getObject(), namedGraph3, ts, ts2);
 			
 			assertEquals(countIteratorResults(connection.search(st.getSubject(), 
 					st.getPredicate(), st.getObject(), namedGraph, null)), 1);
 			assertEquals(countIteratorResults(connection.search(st.getSubject(), 
 					st.getPredicate(), st.getObject(), namedGraph2, ts)), 1);
 			assertEquals(countIteratorResults(connection.search(st.getSubject(), 
 					st.getPredicate(), st.getObject(), namedGraph2, ts2)), 0);
 			assertEquals(countIteratorResults(connection.search(st.getSubject(), 
 					st.getPredicate(), st.getObject(), null, ts)), 2);
 			lastSt = st;
 		}
 		
 		int result = countIteratorResults(connection.search(null, lastSt.getPredicate(), 
 				lastSt.getObject(), namedGraph, null));
 		assertEquals(connection.removeStatement(null, lastSt.getPredicate(), 
 				lastSt.getObject(), namedGraph), result);
 		
 		result = countIteratorResults(connection.search(null, lastSt.getPredicate(), 
 				lastSt.getObject(), namedGraph2, ts2));
 		assertEquals(0, result);
 		
 		result = countIteratorResults(connection.search(lastSt.getSubject(), null, 
 				lastSt.getObject(), namedGraph2, null));
 		assertEquals(connection.removeStatement(lastSt.getSubject(), null, 
 				lastSt.getObject(), namedGraph2), result);
 		
 		result = countIteratorResults(connection.search(lastSt.getSubject(), lastSt.getPredicate(), 
 				null, namedGraph3, null));
 		assertEquals(connection.removeStatement(lastSt.getSubject(), lastSt.getPredicate(), 
 				null, namedGraph3), result);
 		
 		connection.removeStatement(null, null, null, null);
 	}
 	
 	/*****************************************************************
 	 * Test: Listeners 
 	 ****************************************************************/	
 	public void testListeners() throws Exception {
 /*		TConnection connection = source.getConnection();
 		final List<TStatement> added = new ArrayList<TStatement>();
 		final List<TStatement> removed = new ArrayList<TStatement>();
 		final List<TStatement> associated = new ArrayList<TStatement>();
 		final List<TStatement> deassociated = new ArrayList<TStatement>();
 		final List<Listener> commited = new ArrayList<Listener>();
 		final List<Listener> rollback = new ArrayList<Listener>();
 		final List<Listener> closed = new ArrayList<Listener>();
 		
 		connection.addListener(new Listener() {
 			public void statementAdded(TStatement statement) {
 				added.add(statement);
 			}
 			
 			public void statementInferred(TStatement statement) {
 				added.add(statement);
 			}
 
 			public void statementRemoved(TStatement statement) {
 				removed.add(statement);
 			}
 
 			public void statementAssociated(TStatement statement) {
 				associated.add(statement);
 			}
 
 			public void statementDeassociated(TStatement statement) {
 				deassociated.add(statement);
 			}
 
 			public void onCommit() {
 				commited.add(this);
 			}
 
 			public void onRollback() {
 				rollback.add(this);
 			}
 
 			public void onClose() {
 				closed.add(this);
 			}
 		});
 		assertEquals(connection.listListeners().size(), 1);
 		
 		ValueFactory factory = new ValueFactoryImpl();
 		Resource subj = factory.createBNode();
 		URI pred = factory.createURI("urn:ordi:compatibilitytest:predicate");
 		Literal obj = factory.createLiteral("Comaptibilitytest Literal)");
 		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
 		URI namedGraph2 = factory.createURI("urn:ordi:compatibilitytest:namedgraph2");
 		URI ts = factory.createURI("urn:ordi:compatibilitytest:tripleset");
 		
 		TStatement statement = connection.addStatement(subj, pred, obj, namedGraph);
 		assertEquals(added.size(), 1);
 		assertEquals(statement, added.get(0));
 		statement = connection.addStatement(subj, pred, obj, namedGraph2);
 		assertEquals(added.size(), 2);
 		assertEquals(statement, added.get(1));
 		
 		assertEquals(connection.associateTripleset(null, null, null, null, ts), 2);
 		assertEquals(associated.size(), 2);
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph, ts),
 				associated.get(0));
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph2, ts), 
 				associated.get(1));
 		
 		assertEquals(connection.deassociateTripleset(null, null, null, null, ts), 2);
 		assertEquals(deassociated.size(), 2);
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph),
 				deassociated.get(0));
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph2), 
 				deassociated.get(1));
 		
 		assertEquals(connection.removeStatement(null, null, null, null), 2);
 		assertEquals(removed.size(), 2);
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph),
 				removed.get(0));
 		assertEquals(connection.addStatement(subj, pred, obj, namedGraph2), 
 				removed.get(1));
 		assertEquals(connection.removeStatement(null, null, null, null), 2);
 		
 		connection.commit();
 		assertEquals(commited.size(), 1);
 		connection.rollback();
 		assertEquals(rollback.size(), 1);
 		connection.close();
 		assertEquals(closed.size(), 1);
 		
 		for(Iterator<Listener> iter = connection.listListeners().iterator(); iter.hasNext();) {
 			connection.removeListener(iter.next());
 		}
 		assertEquals(connection.listListeners().size(), 0);
 */	}
 	
 	/*****************************************************************
 	 * Test: SPARQL Querying
 	 ****************************************************************/
 	public void testSPARQLSupport() throws Exception {
 		/*TConnection connection = source.getConnection();
 		NTParser parser = new NTParser(this.getClass().getResourceAsStream(SAMPLE_TRIPLE_FILE));
 		ValueFactory factory = new ValueFactoryImpl();
 		URI defaultGraph = factory.createURI(ORDIConst.DEFAULT_GRAPH);
 		URI namedGraph = factory.createURI("urn:ordi:compatibilitytest:namedgraph");
 		URI namedGraph2 = factory.createURI("urn:ordi:compatibilitytest:namedgraph2");
 		Statement st = null;
 		
 		while ((st = parser.next()) != null) {
 			connection.addStatement(st.getSubject(), st.getPredicate(), 
 					st.getObject(), defaultGraph);
 			connection.addStatement(st.getSubject(), st.getPredicate(), 
 					st.getObject(), namedGraph);
 			connection.addStatement(st.getSubject(), st.getPredicate(), 
 					st.getObject(), namedGraph2);
 		}
 		
 		SPARQLQueryIterator iter = new SPARQLQueryIterator(
 				this.getClass().getResourceAsStream(SAMPLE_SPARQL_FILE));
 		while (iter.hasNext()) {
 			Object[] queryData = iter.next();
 			if (queryData[2].toString().trim().length() == 0) {
 				throw new RuntimeException(String.format("Query [%s] has no query text assigned.", queryData[2]));
 			}
 			SPARQLParser sparqlParser = new SPARQLParser();
 			ParsedQuery query = sparqlParser.parseQuery("SELECT * WHERE {?s ?p ?o. ?o ?p1 ?o2.} ", namedGraph.toString());
 			CloseableIterator<? extends BindingSet> result = 
 				connection.evaluate(query.getTupleExpr(), new EmptyBindingSet(), true);
 
 			int count = 0;
 			while (result.hasNext()) {
 				BindingSet solution = result.next();
 				count++;
 				for (Iterator<Binding> i = solution.iterator(); i.hasNext();) {
 					Binding binding = i.next();
 					binding.getName();
 					binding.getValue();
 				}
 			}
 			
 			assertEquals(queryData[1], count);
 		}*/
 	}
 	
 	/*****************************************************************
 	 * Test: Concurrent access
 	 ****************************************************************/
 	//TODO: Add methods to test the concurrent access
 	
 	
 	/*****************************************************************
 	 * Helper methods and classes
 	 ****************************************************************/
 	private int countIteratorResults(Iterator<?> iterator) {
 		int count = 0;
 		while (iterator.hasNext()) {
 			iterator.next();
 			count++;
 		}
 		return count;
 	}
 	
 	private class SPARQLQueryIterator implements Iterator<Object> {
 		
 		private BufferedReader reader;
 		private Pattern regexp;
 		private Object[] next;
 		private int lineNumber = 1;
 		private String line;
 		
 		public SPARQLQueryIterator(InputStream stream) {
 			reader = new BufferedReader(new InputStreamReader(stream));
 			regexp = Pattern.compile("\\[(.+):(\\d+)\\]");
 			try {
 				line = reader.readLine();
 			}
 			catch (IOException e) {
 				throw new RuntimeException("Could not process file!", e);
 			}
 		}
 		
 		public Object[] next() {
 			if (hasNext()) {
 				Object[] result = next;
 				next = null;
 				return result;
 			}
 			throw new NoSuchElementException();
 		}
 		
 		public boolean hasNext() {
 			if (next != null) {
 				return true;
 			}
 			try {
 				while (line != null) {
 					if (line.startsWith("#") || line.trim().length() == 0) {
 					}
 					else if (regexp.matcher(line).matches()) {
 						if (next != null) {
 							return true;
 						}
 						next = new Object[3];
 						Matcher match = regexp.matcher(line);
 						match.matches();
 						next[0] = match.group(1);
 						next[1] = Integer.parseInt(match.group(2));
 						next[2] = new StringBuffer();
 					}
 					else {
 						if (next == null) {
 							next = null;
 						}
 						((StringBuffer) next[2]).append(line);
 						((StringBuffer) next[2]).append('\n');
 					}
 					line = reader.readLine();
 					lineNumber++;
 				}
 				return next != null;
 			}
 			catch (Exception e) {
 				throw new RuntimeException("Format problem on line " + lineNumber);
 			}
 		}
 		
 		public void remove() {
 			throw new UnsupportedOperationException(
 					"Remove is not allowed for this iterator!");
 		}
 	}
 }