/*
    * 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.codegen;
  
  import info.aduna.iteration.CloseableIteration;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeSet;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.xml.namespace.QName;
  
  import org.openrdf.concepts.owl.AllDifferent;
  import org.openrdf.concepts.owl.Class;
  import org.openrdf.concepts.owl.DatatypeProperty;
  import org.openrdf.concepts.owl.ObjectProperty;
  import org.openrdf.concepts.owl.Ontology;
  import org.openrdf.concepts.rdf.List;
  import org.openrdf.concepts.rdf.Property;
  import org.openrdf.concepts.rdfs.Datatype;
  import org.openrdf.elmo.ElmoModule;
  import org.openrdf.elmo.Entity;
  import org.openrdf.elmo.exceptions.ElmoIOException;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.sesame.SesameManagerFactory;
  import org.openrdf.elmo.sesame.roles.SesameEntity;
  import org.openrdf.model.BNode;
  import org.openrdf.model.Literal;
  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.OWL;
  import org.openrdf.model.vocabulary.RDF;
  import org.openrdf.model.vocabulary.RDFS;
  import org.openrdf.model.vocabulary.XMLSchema;
  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.Repository;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.RepositoryResult;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Applies a series of rules against the ontology, making it easier to convert
   * into Java classes. This includes appling some OWL reasoning on properties,
   * renaming anonymous and foriegn classes.
   * 
   * @author James Leigh
   * 
   */
  public class OwlNormalizer {
  	private final Logger logger = LoggerFactory.getLogger(OwlNormalizer.class);
  
  	private static final String PREFIX = "PREFIX rdf: <" + RDF.NAMESPACE
  			+ "> PREFIX rdfs: <" + RDFS.NAMESPACE + "> ";
  
  	private static final String SELECT_DEFINED = PREFIX + "SELECT ?bean "
  			+ "WHERE { ?bean rdfs:isDefinedBy ?ont "
  			+ "FILTER ( ?bean != ?ont ) } ";
  
 	private static final String SELECT_ORPHANS = PREFIX
 			+ "SELECT DISTINCT ?bean" + " WHERE { ?bean rdf:type ?type"
 			+ " OPTIONAL { ?bean rdfs:isDefinedBy ?ont }"
 			+ " FILTER ( isURI(?bean) && ! bound(?ont) ) }";
 
 	private static final String BEAN_DEFINED_BY = PREFIX
 			+ "SELECT ?bean WHERE { ?bean rdfs:isDefinedBy ?ont }";
 
 	private SesameManagerFactory factory;
 
 	private SesameManager manager;
 
 	private Set<URI> anonymousClasses = new HashSet<URI>();
 
 	private Map<URI, URI> aliases = new HashMap<URI, URI>();
 
 	private Map<String, Ontology> ontologies;
 
 	private Set<String> commonNS = new HashSet<String>(Arrays.asList(
 			RDF.NAMESPACE, RDFS.NAMESPACE, OWL.NAMESPACE));
 
 	private static final Pattern NS_PREFIX = Pattern
 			.compile("^.*[/#](\\w+)[/#]?$");
 
 	public void setRepository(Repository repository) {
 		this.factory = new SesameManagerFactory(new ElmoModule(), repository);
 	}
 
 	public URI getOriginal(URI alias) {
 		if (anonymousClasses.contains(alias))
 			return null;
 		if (aliases.containsKey(alias))
 			return aliases.get(alias);
 		return alias;
 	}
 
 	public void normalize() throws Exception {
 		infer(factory.getRepository());
 		this.manager = factory.createElmoManager();
 		try {
 			manager.getTransaction().begin();
 			ontologies = findOntologies();
 			commit();
 			checkNamespacePrefixes();
 			commit();
 			checkPropertyDomains(Property.class);
 			checkPropertyDomains(ObjectProperty.class);
 			checkPropertyDomains(DatatypeProperty.class);
 			commit();
 			renameAnonymousClasses();
 			commit();
 			mergeUnionClasses();
 			commit();
 			processAllDifferent();
 			commit();
 			moveForiegnDomains(manager.getConnection());
 			manager.getTransaction().commit();
 		} finally {
 			manager.close();
 		}
 	}
 
 	private void commit() {
 		manager.getTransaction().commit();
 		manager.getTransaction().begin();
 	}
 
 	private void infer(Repository rep) throws RepositoryException {
 		logger.debug("inferring");
 		ValueFactory vf = rep.getValueFactory();
 		ContextAwareConnection conn = new ContextAwareConnection(rep);
 		conn.setAutoCommit(false);
 		symmetric(conn, OWL.INVERSEOF);
 		symmetric(conn, OWL.EQUIVALENTCLASS);
 		symmetric(conn, OWL.EQUIVALENTPROPERTY);
 		symmetric(conn, OWL.DISJOINTWITH);
 		setSubjectType(conn, RDF.FIRST, null, RDF.LIST);
 		setSubjectType(conn, RDF.REST, null, RDF.LIST);
 		setSubjectType(conn, OWL.UNIONOF, null, OWL.CLASS);
 		setSubjectType(conn, OWL.DISJOINTWITH, null, OWL.CLASS);
 		setSubjectType(conn, OWL.COMPLEMENTOF, null, OWL.CLASS);
 		setSubjectType(conn, OWL.EQUIVALENTCLASS, null, OWL.CLASS);
 		setSubjectType(conn, OWL.INTERSECTIONOF, null, OWL.CLASS);
 		setSubjectType(conn, RDF.TYPE, RDFS.CLASS, OWL.CLASS);
 		setObjectType(conn, OWL.UNIONOF, RDF.LIST);
 		setObjectType(conn, RDFS.ISDEFINEDBY, OWL.ONTOLOGY);
 		setSubjectType(conn, OWL.INVERSEOF, null, OWL.OBJECTPROPERTY);
 		setObjectType(conn, OWL.INVERSEOF, OWL.OBJECTPROPERTY);
 		setDatatype(vf, conn, OWL.CARDINALITY, XMLSchema.NON_NEGATIVE_INTEGER);
 		setDatatype(vf, conn, OWL.MINCARDINALITY,
 				XMLSchema.NON_NEGATIVE_INTEGER);
 		setDatatype(vf, conn, OWL.MAXCARDINALITY,
 				XMLSchema.NON_NEGATIVE_INTEGER);
 		conn.commit();
 		conn.close();
 	}
 
 	private Map<String, Ontology> findOntologies()
 			throws MalformedQueryException, RepositoryException,
 			QueryEvaluationException {
 		Map<String, Ontology> ontologies = new HashMap<String, Ontology>();
 		ContextAwareConnection conn = manager.getConnection();
 		TupleQuery query = conn.prepareTupleQuery(BEAN_DEFINED_BY);
 		for (Ontology ont : manager.findAll(Ontology.class)) {
 			logger.debug("found ontology {}", ont);
 			ontologies.put(ont.toString(), ont);
 			ontologies.put(ont.getQName().getNamespaceURI(), ont);
 			ontologies.put(ont.toString() + '#', ont);
 			Set<String> spaces = new HashSet<String>();
 			query.setBinding("ont", ((SesameEntity) ont).getSesameResource());
 			TupleQueryResult result = query.evaluate();
 			try {
 				while (result.hasNext()) {
 					BindingSet tuple = result.next();
 					Value bean = tuple.getBinding("bean").getValue();
 					if (bean instanceof URI)
 						spaces.add(((URI) bean).getNamespace());
 				}
 			} finally {
 				result.close();
 			}
 			if (spaces.size() > 0) {
 				for (String ns : spaces) {
 					ontologies.put(ns, ont);
 				}
 			} else {
 				ontologies.put(guessNamespace(ont), ont);
 			}
 		}
 		query = conn.prepareTupleQuery(SELECT_ORPHANS);
 		TupleQueryResult result = query.evaluate();
 		try {
 			while (result.hasNext()) {
 				BindingSet tuple = result.next();
 				URI uri = (URI) tuple.getBinding("bean").getValue();
 				String ns = uri.getNamespace();
 				Ontology ont = findOntology(ns, ontologies);
 				logger.debug("assigning {} {}", uri, ont);
 				conn.add(uri, RDFS.ISDEFINEDBY, ((SesameEntity) ont)
 						.getSesameResource());
 			}
 		} finally {
 			result.close();
 		}
 		return ontologies;
 	}
 
 	private String guessNamespace(Entity bean) {
 		QName qname = bean.getQName();
 		String ns = qname.getNamespaceURI();
 		String local = qname.getLocalPart();
 		if (local.endsWith("#") || local.endsWith("/")) {
 			return ns + local;
 		}
 		if (ns.endsWith("#")) {
 			return ns;
 		}
 		return ns + local + "#";
 	}
 
 	private Ontology findOntology(String ns, Map<String, Ontology> ontologies) {
 		if (ontologies.containsKey(ns)) {
 			return ontologies.get(ns);
 		}
 		for (Map.Entry<String, Ontology> e : ontologies.entrySet()) {
 			String key = e.getKey();
 			if (ns.startsWith(key.substring(0, key.length() - 1)))
 				return e.getValue();
 		}
 		QName qname = new QName(ns);
 		if (ns.endsWith("#")) {
 			qname = new QName(ns.substring(0, ns.length() - 1));
 		}
 		Ontology ont = manager.designate(Ontology.class, qname);
 		ontologies.put(ns, ont);
 		return ont;
 	}
 
 	private void processAllDifferent() {
 		for (AllDifferent different : manager.findAll(AllDifferent.class)) {
 			for (Class c : different.getOwlDistinctMembers()) {
 				for (Class d : different.getOwlDistinctMembers()) {
 					if (!c.equals(d))
 						c.getOwlDisjointWith().add(d);
 				}
 			}
 		}
 	}
 
 	private void symmetric(ContextAwareConnection conn, URI pred)
 			throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, pred, null);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				Resource subj = (Resource) stmt.getObject();
 				conn.add(subj, pred, stmt.getSubject());
 			}
 		} finally {
 			stmts.close();
 		}
 	}
 
 	private void setSubjectType(ContextAwareConnection conn, URI pred,
 			Value obj, URI type) throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, pred, obj);
 		try {
 			while (stmts.hasNext()) {
 				conn.add(stmts.next().getSubject(), RDF.TYPE, type);
 			}
 		} finally {
 			stmts.close();
 		}
 	}
 
 	private void setObjectType(ContextAwareConnection conn, URI pred, URI type)
 			throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, pred, null);
 		try {
 			while (stmts.hasNext()) {
 				Resource subj = (Resource) stmts.next().getObject();
 				conn.add(subj, RDF.TYPE, type);
 			}
 		} finally {
 			stmts.close();
 		}
 	}
 
 	private <C extends org.openrdf.concepts.rdfs.Class> void addBaseClass(
 			Class base, java.lang.Class<C> type) {
 		String ns = base.getQName().getNamespaceURI();
 		for (C c : manager.findAll(type)) {
 			if (c.equals(base))
 				continue;
 			QName qname = c.getQName();
 			if (qname != null && qname.getNamespaceURI().equals(ns)) {
 				boolean isBase = true;
 				for (org.openrdf.concepts.rdfs.Class e : c.getRdfsSubClassOf()) {
 					QName bname = e.getQName();
 					if (bname != null && bname.getNamespaceURI().equals(ns))
 						isBase = false;
 				}
 				if (isBase) {
 					logger.debug("extending {} {}", c, base);
 					c.getRdfsSubClassOf().add(base);
 				}
 			}
 		}
 	}
 
 	private void setDatatype(ValueFactory vf, ContextAwareConnection conn,
 			URI pred, URI datatype) throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, pred, null);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				String label = ((Literal) stmt.getObject()).getLabel();
 				Literal literal = vf.createLiteral(label, datatype);
 				conn.remove(stmt);
 				conn.add(stmt.getSubject(), stmt.getPredicate(), literal);
 			}
 		} finally {
 			stmts.close();
 		}
 	}
 
 	private void checkPropertyDomains(java.lang.Class<? extends Property> type) {
 		for (Property p : manager.findAll(type)) {
 			if (p.getRdfsDomains().isEmpty()) {
 				boolean found = false;
 				for (Property sup : p.getRdfsSubPropertyOf()) {
 					if (!sup.getRdfsDomains().isEmpty()) {
 						found = true;
 						p.getRdfsDomains().addAll(sup.getRdfsDomains());
 					}
 				}
 				if (!found) {
 					Class res = manager.designate(RDFS.RESOURCE, Class.class);
 					p.getRdfsDomains().add(res);
 				}
 			}
 		}
 	}
 
 	private void moveForiegnDomains(ContextAwareConnection conn)
 			throws RepositoryException {
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, RDFS.DOMAIN, null);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				if (stmt.getSubject() instanceof URI
 						&& stmt.getObject() instanceof URI) {
 					URI subj = (URI) stmt.getSubject();
 					URI obj = (URI) stmt.getObject();
 					for (Map.Entry<String, Ontology> e : ontologies.entrySet()) {
 						String ns = e.getKey();
 						Ontology ont = e.getValue();
 						if (subj.getNamespace().equals(ns)
 								&& !subj.getNamespace().equals(
 										obj.getNamespace())) {
 							URI nc = createLocalClass(ns, obj);
 							logger.debug("moving {} {}", subj, nc);
 							conn.remove(stmt);
 							conn.add(subj, RDFS.DOMAIN, nc);
 							conn.add(nc, RDF.TYPE, OWL.CLASS);
 							conn.add(nc, RDFS.SUBCLASSOF, obj);
 							conn.add(nc, RDFS.ISDEFINEDBY, ((SesameEntity) ont)
 									.getSesameResource());
 						}
 					}
 				}
 			}
 		} finally {
 			stmts.close();
 		}
 	}
 
 	private URI createLocalClass(String ns, URI obj) throws RepositoryException {
 		String localName = obj.getLocalName();
 		ValueFactory vf = factory.getRepository().getValueFactory();
 		String prefix = findPrefix(ns);
 		if (prefix == null)
 			return vf.createURI(ns, localName);
 		return vf.createURI(ns, initcap(prefix) + initcap(localName));
 	}
 
 	private String findPrefix(String ns) throws RepositoryException {
 		RepositoryResult<Namespace> spaces;
 		spaces = manager.getConnection().getNamespaces();
 		try {
 			while (spaces.hasNext()) {
 				Namespace next = spaces.next();
 				if (next.getName().equals(ns))
 					return next.getPrefix();
 			}
 		} finally {
 			spaces.close();
 		}
 		return null;
 	}
 
 	private void renameClass(ContextAwareConnection conn, URI obj, URI nc)
 			throws RepositoryException {
 		logger.debug("renaming {} {}", obj, nc);
 		aliases.put(nc, obj);
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		stmts = conn.getStatements(null, null, obj);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				if (isLocal(nc.getNamespace(), stmt.getSubject())) {
 					if (!stmt.getPredicate().equals(RDFS.RANGE)
 							|| !stmt.getObject().equals(RDFS.RESOURCE)) {
 						if (!stmt.getPredicate().equals(RDF.TYPE))
 							conn.remove(stmt);
 						conn.add(stmt.getSubject(), stmt.getPredicate(), nc);
 					}
 				}
 			}
 		} finally {
 			stmts.close();
 		}
 		if (obj.equals(RDFS.RESOURCE)) {
 			Class base = manager.designate(nc, Class.class);
 			addBaseClass(base, org.openrdf.concepts.rdfs.Class.class);
 			addBaseClass(base, Class.class);
 		}
 	}
 
 	private boolean isLocal(String ns, Value obj) {
 		if (obj instanceof BNode)
 			return true;
 		URI uri = (URI) obj;
 		return uri.getNamespace().equals(ns);
 	}
 
 	private void renameAnonymousClasses() throws RepositoryException {
 		Iterable<Class> classes = manager.findAll(Class.class);
 		for (Class clazz : classes) {
 			Resource res = ((SesameEntity) clazz).getSesameResource();
 			if (res instanceof URI)
 				continue;
 			List<Class> unionOf = clazz.getOwlUnionOf();
 			if (unionOf != null) {
 				renameClass(clazz, "Or", unionOf);
 			}
 			List<Class> intersectionOf = clazz.getOwlIntersectionOf();
 			if (intersectionOf != null) {
 				renameClass(clazz, "And", intersectionOf);
 			}
 		}
 		commit();
 		for (Class clazz : classes) {
 			Resource res = ((SesameEntity) clazz).getSesameResource();
 			if (res instanceof URI)
 				continue;
 			Class complement = clazz.getOwlComplementOf();
 			if (complement != null) {
 				QName comp = complement.getQName();
 				String name = "Not" + comp.getLocalPart();
 				QName qname = new QName(comp.getNamespaceURI(), name);
 				rename(clazz, qname);
 			}
 		}
 	}
 
 	private void mergeUnionClasses() throws RepositoryException {
 		Iterable<Class> classes = manager.findAll(Class.class);
 		for (Class clazz : classes) {
 			List<? extends Entity> unionOf = clazz.getOwlUnionOf();
 			if (unionOf != null) {
 				Value clazzValue = ((SesameEntity) clazz).getSesameResource();
 				if (clazzValue instanceof URI) {
 					anonymousClasses.add((URI) clazzValue);
 				}
 				QName qName = clazz.getQName();
 				for (Entity bean : unionOf) {
 					Class of = manager.designate(Class.class, bean.getQName());
 					Value ofValue = ((SesameEntity) of).getSesameResource();
 					if (bean instanceof Datatype) {
 						// don't use anonymous class for datatypes
 						rename(clazz, bean.getQName());
 					} else if (isLocal(qName.getNamespaceURI(), ofValue)) {
 						of.getRdfsSubClassOf().add(clazz);
 					} else {
 						URI nc = createLocalClass(qName.getNamespaceURI(),
 								(URI) ofValue);
 						ContextAwareConnection conn = manager.getConnection();
 						conn.add(nc, RDF.TYPE, OWL.CLASS);
 						conn.add(nc, RDFS.SUBCLASSOF, ofValue);
 						conn.add(nc, RDFS.SUBCLASSOF, clazzValue);
 						Ontology ont = findOntology(nc.getNamespace(),
 								ontologies);
 						conn.add(nc, RDFS.ISDEFINEDBY, ((SesameEntity) ont)
 								.getSesameResource());
 						renameClass(conn, (URI) ofValue, nc);
 					}
 				}
 			}
 		}
 	}
 
 	private Class renameClass(Class clazz, String and, List<? extends Entity> list)
 			throws RepositoryException {
 		String namespace = null;
 		Set<String> names = new TreeSet<String>();
 		for (Entity of : list) {
 			QName qname = of.getQName();
 			if (namespace == null || commonNS.contains(namespace)) {
 				namespace = qname.getNamespaceURI();
 			}
 			names.add(qname.getLocalPart());
 		}
 		StringBuilder sb = new StringBuilder();
 		for (String localPart : names) {
 			sb.append(initcap(localPart));
 			sb.append(and);
 		}
 		sb.setLength(sb.length() - and.length());
 		return rename(clazz, new QName(namespace, sb.toString()));
 	}
 
 	private Class rename(Class clazz, QName qname) throws RepositoryException {
 		logger.debug("renaming {} {}", clazz, qname);
 		Class copy = manager.designate(clazz.getClass(), qname);
 		Ontology ont = findOntology(qname.getNamespaceURI(), ontologies);
 		copy.getRdfsIsDefinedBy().add(ont);
 		ContextAwareConnection conn = manager.getConnection();
 		CloseableIteration<? extends Statement, RepositoryException> stmts;
 		org.openrdf.model.Resource orig = ((SesameEntity) clazz)
 				.getSesameResource();
 		org.openrdf.model.Resource dest = ((SesameEntity) copy)
 				.getSesameResource();
 		stmts = conn.getStatements(orig, null, null);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				conn.add(dest, stmt.getPredicate(), stmt.getObject());
 				conn.remove(stmt);
 			}
 		} finally {
 			stmts.close();
 		}
 		stmts = conn.getStatements(null, null, orig);
 		try {
 			while (stmts.hasNext()) {
 				Statement stmt = stmts.next();
 				conn.add(stmt.getSubject(), stmt.getPredicate(), dest);
 				conn.remove(stmt);
 			}
 		} finally {
 			stmts.close();
 		}
 		return copy;
 	}
 
 	private String initcap(String str) {
 		return str.substring(0, 1).toUpperCase() + str.substring(1);
 	}
 
 	private void checkNamespacePrefixes() throws Exception {
 		ContextAwareConnection conn;
 		conn = manager.getConnection();
 		TupleQuery query = conn.prepareTupleQuery(SELECT_DEFINED);
 		TupleQueryResult result = query.evaluate();
 		try {
 			while (result.hasNext()) {
 				BindingSet tuple = result.next();
 				Value value = tuple.getBinding("bean").getValue();
 				if (value instanceof BNode)
 					continue;
 				String ns = ((URI) value).getNamespace();
 				String prefix = getPrefix(ns);
 				if (prefix == null) {
 					Matcher matcher = NS_PREFIX.matcher(ns);
 					if (matcher.find()) {
 						prefix = matcher.group(1);
 						logger.debug("creating prefix {} {}", prefix, ns);
 						conn.setNamespace(prefix, ns);
 					}
 				}
 			}
 		} finally {
 			result.close();
 		}
 	}
 
 	private String getPrefix(String namespace) {
 		CloseableIteration<? extends Namespace, RepositoryException> namespaces = null;
 		try {
 			try {
 				ContextAwareConnection conn;
 				conn = manager.getConnection();
 				namespaces = conn.getNamespaces();
 				while (namespaces.hasNext()) {
 					Namespace ns = namespaces.next();
 					if (namespace.equals(ns.getName()))
 						return ns.getPrefix();
 				}
 				return null;
 			} finally {
 				if (namespaces != null)
 					namespaces.close();
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 }