/*
    * 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.tapestry;
  
  import java.util.Collection;
  import java.util.Locale;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import org.apache.hivemind.service.ThreadCleanupListener;
  import org.apache.hivemind.service.ThreadEventNotifier;
  import org.apache.hivemind.service.ThreadLocale;
  import org.openrdf.elmo.Entity;
  import org.openrdf.elmo.RoleMapper;
  import org.openrdf.elmo.dynacode.ClassFactory;
  import org.openrdf.elmo.exceptions.ElmoPersistException;
  import org.openrdf.elmo.impl.ElmoEntityCompositor;
  import org.openrdf.elmo.impl.ElmoMapperClassFactory;
  import org.openrdf.elmo.impl.InstanceBehaviourFactory;
  import org.openrdf.elmo.sesame.SesameEntitySupport;
  import org.openrdf.elmo.sesame.SesameLiteralManager;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.sesame.SesamePropertyFactory;
  import org.openrdf.elmo.sesame.SesameResourceManager;
  import org.openrdf.elmo.sesame.SesameRoleMapperFactory;
  import org.openrdf.model.URI;
  import org.openrdf.model.ValueFactory;
  import org.openrdf.query.QueryLanguage;
  import org.openrdf.repository.Repository;
  import org.openrdf.repository.RepositoryException;
  import org.openrdf.repository.contextaware.ContextAwareConnection;
  
  /**
   * Convents the properties used in a HiveMind repository to SesameBeanManager's
   * properties. This class converts repository -> connection, threadLocale ->
   * locale, QueryLanguageName -> QueryLanguage. This class also closesthe
   * connection when the thread is discarded.
   * 
   * @author James Leigh
   * 
   */
  public class HiveMindSesameManager extends SesameManager implements
  		ThreadCleanupListener {
  
  	private ConcurrentMap<Locale, String> languages;
  
  	private Repository repository;
  
  	private ThreadEventNotifier threadEventNotifier;
  
  	private ThreadLocale threadLocale;
  
  	private QueryLanguage ql = QueryLanguage.SPARQL;
  
  	private Collection<Class<?>> roles;
  
  	@SuppressWarnings("unchecked")
  	public HiveMindSesameManager() {
  		languages = new ConcurrentHashMap<Locale, String>();
  	}
  
  	/**
  	 * Registers all the given roles with their default subject type.
  	 * 
  	 * @param roles
  	 */
  	public void setRoles(Collection<Class<?>> roles) {
  		this.roles = roles;
  	}
  
  	public void setRepository(Repository repository) throws RepositoryException {
  		this.repository = repository;
  		ContextAwareConnection conn = new ContextAwareConnection(repository);
 		conn.setQueryLanguage(ql);
 		setConnection(conn);
 	}
 
 	public void setQueryLanguageName(String ql) {
 		this.ql = QueryLanguage.valueOf(ql);
 		if (getConnection() != null) {
 			getConnection().setQueryLanguage(this.ql);
 		}
 	}
 
 	public void setThreadEventNotifier(ThreadEventNotifier threadEventNotifier) {
 		this.threadEventNotifier = threadEventNotifier;
 		threadEventNotifier.addThreadCleanupListener(this);
 	}
 
 	public void setThreadLocale(ThreadLocale threadLocale) {
 		this.threadLocale = threadLocale;
 	}
 
 	public void init() throws RepositoryException {
 		ClassLoader cl = Thread.currentThread().getContextClassLoader();
 		if (cl == null)
 			cl = getClass().getClassLoader();
 		ClassFactory definer = new ClassFactory(cl);
 		ValueFactory vf = repository.getValueFactory();
 		SesameLiteralManager literalManager = new SesameLiteralManager(vf);
 		literalManager.setClassLoader(cl);
 		SesameRoleMapperFactory factory = new SesameRoleMapperFactory(vf);
 		factory.setClassLoader(cl);
 		RoleMapper<URI> mapper = factory.createRoleMapper();
 		mapper.recordRole(SesameEntitySupport.class);
 		ElmoMapperClassFactory propertyMapper = new ElmoMapperClassFactory();
 		propertyMapper.setElmoPropertyFactoryClass(SesamePropertyFactory.class);
 		propertyMapper.setClassDefiner(definer);
 		ElmoEntityCompositor resolver = new ElmoEntityCompositor();
 		resolver.setClassDefiner(definer);
 		resolver.setBehaviourClassResolver(propertyMapper);
 		resolver.addFactoryClass(InstanceBehaviourFactory.class);
 		resolver.addFactoryClass(InstanceBehaviourFactory.class, Entity.class);
 		if (roles != null) {
 			for (Class<?> r : roles) {
 				mapper.recordRole(r);
 			}
 		}
 		ContextAwareConnection conn = new ContextAwareConnection(repository);
 		conn.setQueryLanguage(ql);
 		SesameResourceManager rolesManager = new SesameResourceManager();
 		rolesManager.setConnection(conn);
 		rolesManager.setValueFactory(repository.getValueFactory());
 		rolesManager.setRoleMapper(mapper);
 		super.setConnection(conn);
 		super.setElmoClassResolver(resolver);
 		super.setLiteralManager(literalManager);
 		super.setResourceManager(rolesManager);
 	}
 
 	public void threadDidCleanup() {
 		clear();
 		try {
 			ContextAwareConnection connection = getConnection();
 			if (connection != null)
 				connection.close();
 		} catch (RepositoryException e) {
 			throw new ElmoPersistException(e);
 		}
 		threadEventNotifier.addThreadCleanupListener(this);
 	}
 
 	@Override
 	public Locale getLocale() {
 		if (threadLocale == null)
 			return super.getLocale();
 		return threadLocale.getLocale();
 	}
 
 	@Override
 	public String getLanguage() {
 		if (threadLocale == null)
 			return super.getLanguage();
 		Locale locale = threadLocale.getLocale();
 		if (languages.containsKey(locale))
 			return languages.get(locale);
 		String l = convertLocaleToLanguage(locale);
 		String o = languages.putIfAbsent(locale, l);
 		if (o != null) {
 			l = o;
 		}
 		return l;
 	}
 
 	@Override
 	public boolean isOpen() {
 		return true;
 	}
 
 	private String convertLocaleToLanguage(Locale locale) {
 		String l = locale.toString().replace('_', '-');
 		return l.toLowerCase(locale);
 	}
 
 }