/*
    * Copyright (c) 2007, James Leigh All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.dynabean.helpers;
  
  import info.aduna.iteration.CloseableIteration;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.openrdf.elmo.exceptions.ElmoCompositionException;
  import org.openrdf.model.Literal;
  import org.openrdf.model.Resource;
  import org.openrdf.model.Statement;
  import org.openrdf.model.URI;
  import org.openrdf.model.Value;
  import org.openrdf.model.vocabulary.OWL;
  import org.openrdf.model.vocabulary.RDF;
  import org.openrdf.model.vocabulary.RDFS;
  import org.openrdf.query.BindingSet;
  import org.openrdf.query.MalformedQueryException;
  import org.openrdf.query.QueryEvaluationException;
  import org.openrdf.query.QueryLanguage;
  import org.openrdf.query.TupleQuery;
  import org.openrdf.query.TupleQueryResult;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  
  /**
   * Reads class properties form the repository for a new DynaClass.
   * 
   * @author James Leigh
   * 
   */
  public class RdfsClassInterpreter {
  
  	private ContextAwareConnection conn;
  
  	public RdfsClassInterpreter(ContextAwareConnection conn) {
  		this.conn = conn;
  	}
  
  	public void interpetRdfClass(Collection<URI> types,
  			OntologyDigester digester) throws RepositoryException,
  			QueryEvaluationException {
  		Collection<URI> rdfTypes = types;
  		rdfTypes = includeSubclasses(rdfTypes);
  		digestDeclaredProperties(rdfTypes, digester);
  		for (Resource restriction : getRestrictions(rdfTypes)) {
  			digestRestrictionProperties(restriction, digester);
  		}
  		cleanup(digester);
  	}
  
  	private void digestDeclaredProperties(Collection<URI> rdfTypes,
  			OntologyDigester digester) throws RepositoryException,
  			QueryEvaluationException {
  		TupleQueryResult result = null;
  		StringBuilder query = null;
  		try {
  			for (URI rdfType : rdfTypes) {
  				if (query == null) {
  					query = new StringBuilder();
  					query.append("SELECT p FROM {p} rdfs:domain {c}");
  					query.append(" WHERE c = <");
  					query.append(rdfType);
  					query.append(">");
  				} else {
  					query.append(" OR c = <");
  					query.append(rdfType);
  					query.append(">");
 				}
 			}
 			assert query != null;
 			TupleQuery preparedQuery = conn.prepareTupleQuery(
 					QueryLanguage.SERQL, query.toString());
 			result = preparedQuery.evaluate();
 			while (result.hasNext()) {
 				BindingSet sol = result.next();
 				URI pred = (URI) sol.getValue("p");
 				digester.addPredicate(pred);
 				CloseableIteration<? extends Statement, RepositoryException> iter2 = null;
 				try {
 					iter2 = conn.getStatements(pred, RDFS.RANGE, null, true);
 					while (iter2.hasNext()) {
 						Value val = iter2.next().getObject();
 						assert val instanceof URI : val;
 						digester.addRdfType(pred, (URI) val);
 					}
 				} finally {
 					if (iter2 != null)
 						iter2.close();
 				}
 				// maxCardinality
 				if (conn.hasStatement(pred, RDF.TYPE, OWL.FUNCTIONALPROPERTY,
 						true))
 					digester.setFunctional(pred, true);
 			}
 		} catch (MalformedQueryException e) {
 			throw new ElmoCompositionException(e);
 		} finally {
 			if (result != null)
 				result.close();
 		}
 	}
 
 	private Iterable<Resource> getRestrictions(Collection<URI> rdfTypes)
 			throws RepositoryException, QueryEvaluationException {
 		Set<Resource> classes = new HashSet<Resource>();
 		TupleQueryResult result = null;
 		try {
 			StringBuilder query = null;
 			for (URI rdfType : rdfTypes) {
 				if (query == null) {
 					query = new StringBuilder();
 					query
 							.append("SELECT r FROM {c} rdfs:subClassOf {r} rdf:type {<");
 					query.append(OWL.RESTRICTION);
 					query.append(">}");
 					query.append(" WHERE c = <");
 					query.append(rdfType);
 					query.append(">");
 				} else {
 					query.append(" OR c = <");
 					query.append(rdfType);
 					query.append(">");
 				}
 			}
 			assert query != null;
 			TupleQuery preparedQuery = conn.prepareTupleQuery(
 					QueryLanguage.SERQL, query.toString());
 			result = preparedQuery.evaluate();
 			while (result.hasNext()) {
 				BindingSet sol = result.next();
 				classes.add((Resource) sol.getValue("r"));
 			}
 		} catch (MalformedQueryException e) {
 			throw new ElmoCompositionException(e);
 		} finally {
 			if (result != null)
 				result.close();
 		}
 		return classes;
 	}
 
 	private void digestRestrictionProperties(Resource restriction,
 			OntologyDigester digester) throws RepositoryException {
 		URI pred = (URI) getFirstValue(restriction, OWL.ONPROPERTY);
 		if (pred == null)
 			return;
 		digester.addPredicate(pred);
 		CloseableIteration<? extends Statement, RepositoryException> iter = null;
 		try {
 			iter = conn.getStatements(restriction, OWL.ALLVALUESFROM, null,
 					true);
 			while (iter.hasNext()) {
 				Value val = iter.next().getObject();
 				assert val instanceof URI;
 				digester.addRdfType(pred, (URI) val);
 			}
 		} finally {
 			if (iter != null)
 				iter.close();
 		}
 		int cardinality = getFirstInt(restriction, OWL.CARDINALITY);
 		if (cardinality == 1)
 			digester.setFunctional(pred, true);
 		cardinality = getFirstInt(restriction, OWL.MAXCARDINALITY);
 		if (cardinality == 1)
 			digester.setFunctional(pred, true);
 	}
 
 	private void cleanup(OntologyDigester digester) throws RepositoryException {
 		for (URI pred : digester.getPredicates()) {
 			List<URI> rdfTypes = digester.getRdfTypes(pred);
 			if (rdfTypes == null)
 				continue;
 			rdfTypes = filterOutSuperclasses(rdfTypes);
 			digester.setRdfTypes(pred, rdfTypes);
 		}
 		digester.end();
 	}
 
 	private List<URI> filterOutSuperclasses(List<URI> types)
 			throws RepositoryException {
 		if (types.size() < 2)
 			return types;
 		ArrayList<URI> list = new ArrayList<URI>(types.size());
 		for (int i = 0, n = types.size(); i < n; i++) {
 			URI c = types.get(i);
 			boolean isSubClass = false;
 			for (int j = 0, m = types.size(); j < m; j++) {
 				if (i == j)
 					continue;
 				URI d = types.get(j);
 				if (c.equals(d)) {
 					isSubClass = true;
 					break;
 				}
 				boolean subclass = conn.hasStatement(d, RDFS.SUBCLASSOF, c,
 						true);
 				if (subclass) {
 					isSubClass = true;
 					break;
 				}
 			}
 			if (!isSubClass)
 				list.add(c);
 		}
 		return list;
 	}
 
 	private Collection<URI> includeSubclasses(Collection<URI> rdfTypes)
 			throws RepositoryException {
 		Set<URI> classes = new HashSet<URI>();
 		for (URI rdfType : rdfTypes) {
 			includeSubclasses(rdfType, classes);
 		}
 		return classes;
 	}
 
 	private Collection<URI> includeSubclasses(URI rdfType, Set<URI> result)
 			throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> iter = null;
 		try {
 			result.add(rdfType);
 			iter = conn.getStatements(rdfType, RDFS.SUBCLASSOF, null, true);
 			while (iter.hasNext()) {
 				Value uri = iter.next().getObject();
 				if (uri instanceof URI && !result.contains(uri)) {
 					includeSubclasses((URI) uri, result);
 				}
 			}
 		} finally {
 			if (iter != null)
 				iter.close();
 		}
 		return result;
 	}
 
 	private Value getFirstValue(Resource subj, URI pred)
 			throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> iter = null;
 		try {
 			iter = conn.getStatements(subj, pred, null, false);
 			if (iter.hasNext())
 				return iter.next().getObject();
 			return null;
 		} finally {
 			if (iter != null)
 				iter.close();
 		}
 	}
 
 	private int getFirstInt(Resource subj, URI pred) throws RepositoryException {
 		Literal lit = (Literal)getFirstValue(subj, pred);
 		if (lit == null)
 			return 0;
 		return Integer.parseInt(lit.getLabel());
 	}
 }