/*
    * 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 java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.Set;
  
  import javax.persistence.EntityManager;
  import javax.persistence.EntityTransaction;
  import javax.persistence.FlushModeType;
  import javax.persistence.LockModeType;
  import javax.persistence.Query;
  import javax.persistence.TransactionRequiredException;
  import javax.xml.namespace.QName;
  
  import org.openrdf.elmo.ElmoEntityResolver;
  import org.openrdf.elmo.ElmoManager;
  import org.openrdf.elmo.Entity;
  import org.openrdf.elmo.LiteralManager;
  import org.openrdf.elmo.Memento;
  import org.openrdf.elmo.Mergeable;
  import org.openrdf.elmo.Refreshable;
  import org.openrdf.elmo.ResourceManager;
  import org.openrdf.elmo.RoleMapper;
  import org.openrdf.elmo.exceptions.ElmoCompositionException;
  import org.openrdf.elmo.exceptions.ElmoIOException;
  import org.openrdf.elmo.exceptions.ElmoMementoException;
  import org.openrdf.elmo.exceptions.ElmoPersistException;
  import org.openrdf.elmo.sesame.iterators.ElmoIteration;
  import org.openrdf.elmo.sesame.roles.SesameEntity;
  import org.openrdf.elmo.sesame.roles.SesameManagerAware;
  import org.openrdf.model.Literal;
  import org.openrdf.model.Resource;
  import org.openrdf.model.URI;
  import org.openrdf.model.Value;
  import org.openrdf.query.MalformedQueryException;
  import org.openrdf.query.QueryLanguage;
  import org.openrdf.query.TupleQuery;
  import org.openrdf.repository.DelegatingRepositoryConnection;
  import org.openrdf.repository.RepositoryConnection;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  import org.openrdf.repository.flushable.FlushableConnection;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Handles operations of ElmoManager and EntityManager.
   * 
   * @author James Leigh
   * 
   */
  public class SesameManager implements ElmoManager, EntityManager {
  
  	final Logger logger = LoggerFactory.getLogger(SesameManager.class);
  
  	private ContextAwareConnection conn;
  
  	private SesameTransaction trans;
  
  	private Locale locale;
  
  	private String language;
  
  	private ResourceManager<Resource> resources;
  
  	private LiteralManager<URI, Literal> lm;
  
  	private ElmoEntityResolver resolver;
  
 	private RoleMapper<URI> mapper;
 
 	public ContextAwareConnection getConnection() {
 		if (!isOpen())
 			throw new IllegalStateException("Connection has been closed");
 		return conn;
 	}
 
 	public void setConnection(ContextAwareConnection connection) {
 		this.conn = connection;
 		this.trans = new SesameTransaction(conn);
 	}
 
 	public EntityTransaction getTransaction() {
 		return trans;
 	}
 
 	public void joinTransaction() {
 		if (!isOpen())
 			throw new TransactionRequiredException();
 	}
 
 	public Locale getLocale() {
 		return locale;
 	}
 
 	public void setLocale(Locale locale) {
 		this.locale = locale;
 		if (locale != null) {
 			String lang = locale.toString().replace('_', '-');
 			language = lang.toLowerCase();
 		}
 	}
 
 	public String getLanguage() {
 		return language;
 	}
 
 	public void setResourceManager(ResourceManager<Resource> manager) {
 		this.resources = manager;
 	}
 
 	public void setLiteralManager(LiteralManager<URI, Literal> manager) {
 		this.lm = manager;
 	}
 
 	public void setElmoClassResolver(ElmoEntityResolver resolver) {
 		this.resolver = resolver;
 	}
 
 	public void setRoleMapper(RoleMapper<URI> mapper) {
 		this.mapper = mapper;
 	}
 
 	public boolean isOpen() {
 		try {
 			return conn != null && conn.isOpen();
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public void close() {
 		try {
 			if (conn != null && !trans.isActive())
 				conn.close();
 			conn = null;
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public void flush() {
 		try {
 			FlushableConnection flusher;
 			flusher = findFlushableConnection(getConnection());
 			if (flusher != null) {
 				flusher.flush();
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public void clear() {
 		try {
 			FlushableConnection flusher;
 			flusher = findFlushableConnection(getConnection());
 			if (flusher != null) {
 				flusher.clear();
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public FlushModeType getFlushMode() {
 		try {
 			FlushableConnection flusher;
 			flusher = findFlushableConnection(getConnection());
 			if (flusher == null || flusher.isAutoFlush())
 				return FlushModeType.AUTO;
 			return FlushModeType.COMMIT;
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public void setFlushMode(FlushModeType mode) {
 		try {
 			FlushableConnection flusher;
 			flusher = findFlushableConnection(getConnection());
 			if (flusher != null) {
 				flusher.setAutoFlush(mode.equals(FlushModeType.AUTO));
 			}
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 	}
 
 	public Object getDelegate() {
 		return this;
 	}
 
 	public Memento createMemento() {
 		try {
 			return new SesameMemento(getConnection());
 		} catch (RepositoryException e) {
 			throw new ElmoMementoException(e);
 		} catch (IllegalArgumentException e) {
 			throw new UnsupportedOperationException(e);
 		}
 	}
 
 	public void undoMemento(Memento memento) {
 		if (!(memento instanceof SesameMemento))
 			throw new IllegalArgumentException();
 		SesameMemento m = (SesameMemento) memento;
 		try {
 			m.undo(getConnection());
 		} catch (RepositoryException e) {
 			throw new ElmoMementoException(e);
 		}
 	}
 
 	public void redoMemento(Memento memento) {
 		if (!(memento instanceof SesameMemento))
 			throw new IllegalArgumentException();
 		SesameMemento m = (SesameMemento) memento;
 		try {
 			m.redo(getConnection());
 		} catch (RepositoryException e) {
 			throw new ElmoMementoException(e);
 		}
 	}
 
 	public Object getInstance(Value value) {
 		if (value instanceof Resource) {
 			SesameEntity bean = this.find((Resource) value);
 			if (logger.isDebugEnabled()) {
 				try {
 					if (!getConnection().hasStatement((Resource) value, null,
 							null))
 						logger.debug("Warning: Unknown entity: " + value);
 				} catch (RepositoryException e) {
 					throw new ElmoIOException(e);
 				}
 			}
 			return bean;
 		}
 		return lm.getObject((Literal) value);
 	}
 
 	public Value getValue(Object instance) {
 		if (instance instanceof SesameEntity) {
 			return ((SesameEntity) instance).getSesameResource();
 		} else if (instance instanceof Entity) {
 			return getValue(merge(instance));
 		}
 		Class<?> type = instance.getClass();
 		if (lm.isTypeOfLiteral(type))
 			return lm.getLiteral(instance);
 		// is it a resource or a literal?
 		Class<?>[] interfaces = type.getInterfaces();
 		if (interfaces.length > 0) {
 			for (Class<?> face : interfaces) {
 				if (mapper.findType(face) != null)
 					return getValue(merge(instance));
 			}
 		}
 		// must be a literal
 		return lm.getLiteral(instance);
 	}
 
 	public Value getLocalizedValue(Object instance) {
 		return lm.getLiteral(instance.toString(), language);
 	}
 
 	public boolean contains(Object entity) {
 		if (entity instanceof SesameEntity) {
 			SesameEntity se = (SesameEntity) entity;
 			return this.equals(se.getSesameManager());
 		}
 		return false;
 	}
 
 	/**
 	 * @deprecated Use {@link #designate(Class<T>)} instead
 	 */
 	public <T> T create(Class<T> concept) {
 		return designate(concept);
 	}
 
 	/**
 	 * @deprecated Use {@link #designate(Class<T>,QName)} instead
 	 */
 	public <T> T create(Class<T> concept, QName qname) {
 		return designate(concept, qname);
 	}
 
 	/**
 	 * @deprecated Use {@link #designate(Resource,Class<T>)} instead
 	 */
 	@SuppressWarnings("unchecked")
 	public <T> T create(Resource resource, Class<T> concept) {
 		return designate(resource, concept);
 	}
 
 	public <T> T designate(Class<T> concept) {
 		Resource resource = resources.createResource(null);
 		return designate(resource, concept);
 	}
 
 	public <T> T designate(Class<T> concept, QName qname) {
 		Resource resource = resources.createResource(qname);
 		return designate(resource, concept);
 	}
 
 	@SuppressWarnings("unchecked")
 	public <T> T designate(Resource resource, Class<T> concept) {
 		Class[] roles = resources.mergeRole(resource, concept);
 		Entity bean = createBean(resource, roles);
 		assert !concept.isInterface()
 				|| concept.isAssignableFrom(bean.getClass()) : "Concept has not bean recorded: "
 				+ concept.getSimpleName();
 		return (T) bean;
 	}
 
 	public <T> T designateEntity(Class<T> concept, Object entity) {
 		assert entity instanceof SesameEntity : entity;
 		Resource resource = ((SesameEntity) entity).getSesameResource();
 		return designate(resource, concept);
 	}
 
 	public Entity removeDesignation(Class<?> concept, Object entity) {
 		assert entity instanceof SesameEntity : entity;
 		Resource resource = ((SesameEntity) entity).getSesameResource();
 		Class[] roles = resources.removeRole(resource, concept);
 		return createBean(resource, roles);
 	}
 
 	public <T> T rename(T bean, QName qname) {
 		Resource after = resources.createResource(qname);
 		return rename(bean, after);
 	}
 
 	@SuppressWarnings("unchecked")
 	public <T> T rename(T bean, Resource destination) {
 		assert bean instanceof SesameEntity;
 		Resource before = ((SesameEntity) bean).getSesameResource();
 		Class[] roles = resources.getRoles(before);
 		resources.renameResource(before, destination);
 		return (T) createBean(destination, roles);
 	}
 
 	public SesameEntity find(QName qname) {
 		return find(resources.createResource(qname));
 	}
 
 	public QName getSesameBeanQName(SesameEntity bean) {
 		Resource resource = bean.getSesameResource();
 		return resources.createQName(resource);
 	}
 
 	public SesameEntity find(Resource resource) {
 		Class<?>[] roles = resources.getRoles(resource);
 		return createBean(resource, roles);
 	}
 
 	public <T> T find(Class<T> concept, Object qname) {
 		assert qname instanceof QName : qname;
 		SesameEntity entity = find((QName) qname);
 		if (concept.isInstance(entity))
 			return concept.cast(entity);
 		return null;
 	}
 
 	public <T> T getReference(Class<T> concept, Object qname) {
 		return find(concept, qname);
 	}
 
 	public void refresh(Object entity) {
 		if (entity instanceof Refreshable) {
 			((Refreshable) entity).refresh();
 		}
 	}
 
 	public <T> T merge(T bean) {
 		Object result;
 		if (bean instanceof Entity) {
 			Entity eb = (Entity) bean;
 			QName name = eb.getQName();
 			result = designate(bean.getClass(), name);
 		} else {
 			result = designate(bean.getClass());
 		}
 		assert result instanceof Mergeable;
 		((Mergeable) result).merge(bean);
 		return (T) result;
 	}
 
 	public void persist(Object bean) {
 		merge(bean);
 	}
 
 	public SesameQuery createQuery(String query) {
 		try {
 			TupleQuery qry = getConnection().prepareTupleQueryWithinContext(
 					query);
 			return new SesameQuery(this, qry);
 		} catch (MalformedQueryException e) {
 			throw new ElmoIOException(e);
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public SesameQuery createNativeQuery(String serql) {
 		try {
 			TupleQuery qry = getConnection().prepareTupleQueryWithinContext(
 					QueryLanguage.SERQL, serql, "");
 			return new SesameQuery(this, qry);
 		} catch (MalformedQueryException e) {
 			throw new ElmoIOException(e);
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public SesameQuery createNativeQuery(String serql, Class concept) {
 		try {
 			TupleQuery qry = getConnection().prepareTupleQueryWithinContext(
 					QueryLanguage.SERQL, serql, "");
 			return new SesameQuery(this, qry);
 		} catch (MalformedQueryException e) {
 			throw new ElmoIOException(e);
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public SesameQuery createNativeQuery(String serql, String nil) {
 		try {
 			TupleQuery qry = getConnection().prepareTupleQueryWithinContext(
 					QueryLanguage.SERQL, serql, "");
 			return new SesameQuery(this, qry);
 		} catch (MalformedQueryException e) {
 			throw new ElmoIOException(e);
 		} catch (RepositoryException e) {
 			throw new ElmoIOException(e);
 		}
 	}
 
 	public Query createNamedQuery(String name) {
 		throw new UnsupportedOperationException(
 				"Named queries are not supported");
 	}
 
 	public <T> Set<T> findAll(final Class<T> javaClass) {
 		Set<T> set = new HashSet<T>();
 		Iterator<Resource> iter = resources.createRoleQuery(javaClass);
 		try {
 			for (int count = 0; iter.hasNext(); count++) {
 				set.add(javaClass.cast(find(iter.next())));
 			}
 			return Collections.unmodifiableSet(set);
 		} finally {
 			ElmoIteration.close(iter);
 		}
 	}
 
 	public void remove(Object entity) {
 		assert entity instanceof SesameEntity : entity;
 		Resource resource = ((SesameEntity) entity).getSesameResource();
 		resources.removeResource(resource);
 	}
 
 	Value createResource(QName qname) {
 		return resources.createResource(qname);
 	}
 
 	private SesameEntity createBean(Resource resource, Class<?>[] roles) {
 		Class<?> type = resolver.resolveRoles(roles);
 		try {
 			Object obj = type.newInstance();
 			assert obj instanceof SesameManagerAware : "core roles are not registered, check your deployed classpath";
 			SesameManagerAware bean = (SesameManagerAware) obj;
 			bean.initSesameManager(this);
 			bean.initSesameResource(resource);
 			return bean;
 		} catch (InstantiationException e) {
 			throw new ElmoCompositionException(e);
 		} catch (IllegalAccessException e) {
 			throw new ElmoCompositionException(e);
 		}
 	}
 
 	private FlushableConnection findFlushableConnection(
 			RepositoryConnection conn) throws RepositoryException {
 		if (conn instanceof FlushableConnection)
 			return (FlushableConnection) conn;
 		if (conn instanceof DelegatingRepositoryConnection) {
 			DelegatingRepositoryConnection dconn = (DelegatingRepositoryConnection) conn;
 			return findFlushableConnection((dconn).getDelegate());
 		}
 		return null;
 	}
 
 	public void lock(Object entity, LockModeType mode) {
 		throw new UnsupportedOperationException("locking is not supported");
 	}
 
 }