/*
    * 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.sesame;
  
  import static org.openrdf.query.QueryLanguage.SERQL;
  import info.aduna.iteration.CloseableIteration;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  
  import javax.xml.XMLConstants;
  import javax.xml.namespace.QName;
  
  import org.openrdf.elmo.ResourceManager;
  import org.openrdf.elmo.RoleMapper;
  import org.openrdf.elmo.annotations.disjointWith;
  import org.openrdf.elmo.exceptions.ElmoIOException;
  import org.openrdf.elmo.exceptions.ElmoPersistException;
  import org.openrdf.elmo.sesame.iterators.ElmoIteration;
  import org.openrdf.model.Namespace;
  import org.openrdf.model.Resource;
  import org.openrdf.model.Statement;
  import org.openrdf.model.URI;
  import org.openrdf.model.Value;
  import org.openrdf.model.ValueFactory;
  import org.openrdf.model.vocabulary.RDF;
  import org.openrdf.query.Binding;
  import org.openrdf.query.BindingSet;
  import org.openrdf.query.MalformedQueryException;
  import org.openrdf.query.QueryEvaluationException;
  import org.openrdf.query.TupleQuery;
  import org.openrdf.query.TupleQueryResult;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.RepositoryResult;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  
  /**
   * Determine the rdf:types of a Sesame Resource.
   * 
   * @author James Leigh
   * 
   */
  public class SesameResourceManager implements ResourceManager<Resource> {
  
  	private static final String DEFAULT_PREFIX = XMLConstants.DEFAULT_NS_PREFIX;
  
  	private ContextAwareConnection conn;
  
  	private ValueFactory vf;
  
  	private RoleMapper<URI> mapper;
  
  	public void setConnection(ContextAwareConnection conn) {
  		this.conn = conn;
  	}
  
  	public void setRoleMapper(RoleMapper<URI> mapper) {
  		this.mapper = mapper;
  	}
  
  	public void setValueFactory(ValueFactory vf) {
  		this.vf = vf;
  	}
  
  	public Resource createResource(QName qname) {
  		if (qname == null)
  			return vf.createBNode();
 		String ns = qname.getNamespaceURI();
 		String name = qname.getLocalPart();
 		if (ns.equals(XMLConstants.NULL_NS_URI)) {
 			String prefix = qname.getPrefix();
 			if (prefix.equals(DEFAULT_PREFIX))
 				return vf.createURI(name);
 			try {
 				ns = conn.getNamespace(prefix);
 				return vf.createURI(ns, name);
 			} catch (RepositoryException e) {
 				throw new ElmoIOException(e);
 			}
 		}
 		return vf.createURI(ns, name);
 	}
 
 	public QName createQName(Resource res) {
 		if (res instanceof URI) {
 			URI uri = (URI) res;
 			String prefix = getPrefix(uri.getNamespace());
 			return new QName(uri.getNamespace(), uri.getLocalName(), prefix);
 		}
 		return null;
 	}
 
 	public Iterator<Resource> createRoleQuery(Class<?> concept) {
 		StringBuilder query = new StringBuilder();
 		query.append("SELECT DISTINCT subj FROM");
 		Collection<URI> types = new HashSet<URI>();
 		mapper.findSubTypes(concept, types);
 		Iterator<URI> iter = types.iterator();
 		while (iter.hasNext()) {
 			query.append(" {subj} rdf:type {<");
 			query.append(iter.next()).append(">}");
 			if (iter.hasNext())
 				query.append(" UNION SELECT subj FROM");
 		}
 		try {
 			TupleQuery q = conn.prepareTupleQueryWithinContext(SERQL, query
 					.toString(), null);
 			TupleQueryResult result;
 			result = q.evaluate();
 			final List<String> bindings = result.getBindingNames();
 			return new ElmoIteration<BindingSet, Resource>(result) {
 				@Override
 				protected Resource convert(BindingSet sol) {
 					String b0 = bindings.get(0);
 					Binding binding = sol.getBinding(b0);
 					assert binding.getValue() instanceof Resource : binding
 							.getValue();
 					return (Resource) binding.getValue();
 				}
 			};
 		} catch (QueryEvaluationException e) {
 			throw new ElmoIOException(e);
 		} catch (MalformedQueryException e) {
 			throw new ElmoIOException(e);
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	public Class<?>[] getRoles(Resource res) {
 		CloseableIteration<? extends Statement, RepositoryException> stmts = null;
 		try {
 			try {
 				stmts = conn.getStatements(res, RDF.TYPE, null);
 				List<Class<?>> roles = null;
 				if (res instanceof URI
 						&& mapper.isIndividualRolesPresent((URI) res)) {
 					roles = new ArrayList<Class<?>>();
 					mapper.findIndividualRoles((URI) res, roles);
 				}
 				if (stmts.hasNext()) {
 					Value obj = stmts.next().getObject();
 					assert obj instanceof URI : obj;
 					if (roles == null && !stmts.hasNext())
 						return mapper.findRoles((URI) obj);
 					List<URI> types = new ArrayList<URI>();
 					types.add((URI) obj);
 					while (stmts.hasNext()) {
 						obj = stmts.next().getObject();
 						assert obj instanceof URI;
 						types.add((URI) obj);
 					}
 					if (roles == null) {
 						roles = new ArrayList<Class<?>>();
 					}
 					mapper.findRoles(types, roles);
 				} else if (roles == null) {
 					return mapper.findBaseRoles();
 				} else {
 					mapper.findRoles(Collections.EMPTY_SET, roles);
 				}
 				return roles.toArray(new Class<?>[roles.size()]);
 			} finally {
 				if (stmts != null)
 					stmts.close();
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public Class<?>[] mergeRole(Resource resource, Class<?> role) {
 		try {
 			Class<?>[] currently = getRoles(resource);
 			for (int i = 0; i < currently.length; i++) {
 				if (role.equals(currently[i]))
 					return currently;
 			}
 			if (role.isInterface()) {
 				URI type = mapper.findType(role);
 				if (type == null)
 					throw new ElmoPersistException("Concept not registered: "
 							+ role.getSimpleName());
 				conn.add(resource, RDF.TYPE, type);
 				if (currently.length == 0)
 					return mapper.findRoles(type);
 				Set<Class<?>> roles = new HashSet<Class<?>>();
 				roles.addAll(Arrays.asList(currently));
 				roles.addAll(Arrays.asList(mapper.findRoles(type)));
 				assert isDisjointWith(role, roles);
 				return roles.toArray(new Class<?>[roles.size()]);
 			}
 			Collection<URI> types = mapper.findTypes(role, new HashSet<URI>());
 			assert types.size() > 0 : "Role not registered";
 			for (URI type : types) {
 				conn.add(resource, RDF.TYPE, type);
 			}
 			if (types.size() == 1 && currently.length == 0)
 				return mapper.findRoles(types.iterator().next());
 			Set<Class<?>> roles = new HashSet<Class<?>>();
 			if (currently.length > 0)
 				roles.addAll(Arrays.asList(currently));
 			mapper.findRoles(types, roles);
 			assert isDisjointWith(role, roles);
 			return roles.toArray(new Class<?>[roles.size()]);
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public Class<?>[] removeRole(Resource resource, Class<?> role) {
 		try {
 			URI type = mapper.findType(role);
 			if (type == null)
 				throw new ElmoPersistException("Concept not registered: "
 						+ role.getSimpleName());
 			conn.remove(resource, RDF.TYPE, type);
 			return getRoles(resource);
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public void removeResource(Resource resource) {
 		try {
 			boolean autoCommit = conn.isAutoCommit();
 			conn.setAutoCommit(false);
 			conn.remove(resource, (URI) null, null);
 			conn.remove(null, (URI) null, resource);
 			conn.setAutoCommit(autoCommit);
 		} catch (Exception e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public void renameResource(Resource before, Resource after) {
 		try {
 			RepositoryResult<Statement> stmts;
 			boolean autoCommit = conn.isAutoCommit();
 			conn.setAutoCommit(false);
 			stmts = conn.getStatements(before, null, null, false);
 			try {
 				while (stmts.hasNext()) {
 					Statement stmt = stmts.next();
 					URI pred = stmt.getPredicate();
 					Value obj = stmt.getObject();
 					conn.remove(before, pred, obj);
 					conn.add(after, pred, obj);
 				}
 			} finally {
 				stmts.close();
 			}
 			stmts = conn.getStatements(null, null, before);
 			try {
 				while (stmts.hasNext()) {
 					Statement stmt = stmts.next();
 					Resource subj = stmt.getSubject();
 					URI pred = stmt.getPredicate();
 					conn.remove(subj, pred, before);
 					conn.add(subj, pred, after);
 				}
 			} finally {
 				stmts.close();
 			}
 			conn.setAutoCommit(autoCommit);
 		} catch (Exception e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	private String getPrefix(String namespace) {
 		CloseableIteration<? extends Namespace, RepositoryException> namespaces = null;
 		try {
 			try {
 				namespaces = conn.getNamespaces();
 				while (namespaces.hasNext()) {
 					Namespace ns = namespaces.next();
 					if (namespace.equals(ns.getName()))
 						return ns.getPrefix();
 				}
 				return DEFAULT_PREFIX;
 			} finally {
 				if (namespaces != null)
 					namespaces.close();
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	private boolean isDisjointWith(Class<?> role, Set<Class<?>> roles) {
 		disjointWith dist = role.getAnnotation(disjointWith.class);
 		if (dist == null)
 			return true;
 		for (Class<?> c : dist.value()) {
 			for (Class<?> r : roles) {
 				if (c.isAssignableFrom(r))
 					throw new AssertionError(role.getSimpleName()
 							+ " cannot be assigned to a " + r.getSimpleName());
 			}
 		}
 		return true;
 	}
 
 }