// Created on 13.12.2003
   package com.pnpconsult.zeiterfassung.helper;
   
   import java.io.Serializable;
   import java.util.Date;
   import java.util.IdentityHashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.SortedSet;
  import java.util.TreeSet;
  
  import jface.util.factory.FactoryException;
  import net.sf.hibernate.HibernateException;
  import net.sf.hibernate.Session;
  import net.sf.hibernate.Transaction;
  import net.sf.hibernate.UnresolvableObjectException;
  import net.sf.hibernate.type.Type;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.pnpconsult.zeiterfassung.model.TimestampedObject;
  import com.pnpconsult.zeiterfassung.util.SingletonManager;
  
  /***
   * @author <a href="mailto:powerpete@users.sf.net">M. Petersen</a>
   * @version $Id: AbstractObjectManager.java,v 1.7 2004/05/23 16:59:42 powerpete Exp $
   */
  public class AbstractObjectManager extends SingletonManager
  {
  	private static final Log LOG = LogFactory
  		.getLog(AbstractObjectManager.class);
  
  	private Map txSessions = new IdentityHashMap();
  
  	protected AbstractObjectManager()
  	{}
  
  	protected Session openSession() throws HibernateException, FactoryException
  	{
  		return SessionManager.Factory.getInstance().openSession();
  	}
  
  	public Object load(Class clazz, Serializable key)
  		throws HibernateException, FactoryException
  	{
  		Session session = openSession();
  		try
  		{
  			return session.load(clazz, key);
  		}
  		catch (UnresolvableObjectException e)
  		{
  			if (e.getPersistentClass() != clazz)
  			{
  				throw e;
  			}
  			return null;
  		}
  		catch (HibernateException e)
  		{
  			throw e;
  		}
  		finally
  		{
  			session.close();
  		}
  	}
  
  	protected SortedSet loadAllSorted(Class clazz) throws HibernateException,
  		FactoryException
  	{
  		return new TreeSet(find(clazz, null));
  	}
  
  	protected List find(Class clazz, String clause) throws HibernateException,
  		FactoryException
  	{
  		Session session = openSession();
  		try
  		{
  			String query = "from " + clazz.getName();
  			if (clause != null)
  			{
  				query += " " + clause;
  			}
  			return session.find(query);
  		}
  		catch (HibernateException e)
  		{
  			throw e;
  		}
  		finally
  		{
  			session.close();
  		}
  	}
  
  	/***
 	 * Searches the database using the given {@link Class}. The claus is a 
 	 * Hibernate Query without the class name and should not start with a 
 	 * leading whitespace.
 	 * 
 	 * @param clazz     The type of the return values.
 	 * @param clause    The Hibernate Query to refine the search.
 	 * @param objects   The values of the placeholders inside the query.
 	 * @param types     The types of the placeholder values inside the query.
 	 * 
 	 * @return A {@link List} containing the search results.
 	 * 
 	 * @throws HibernateException If an Hibernate error occured.
 	 * @throws FactoryException If the SessionManager could not be used.
 	 */
 	protected List find(
 		Class clazz,
 		String clause,
 		Object[] objects,
 		Type[] types) throws HibernateException, FactoryException
 	{
 		Session session = openSession();
 		try
 		{
 			return session.find(
 				"from " + clazz.getName() + " " + clause,
 				objects,
 				types);
 		}
 		catch (HibernateException e)
 		{
 			throw e;
 		}
 		finally
 		{
 			session.close();
 		}
 	}
 
 	protected boolean exists(Class clazz, Serializable key)
 		throws HibernateException, FactoryException
 	{
 		Session session = openSession();
 		try
 		{
 			session.load(clazz, key);
 			return true;
 		}
 		catch (UnresolvableObjectException e)
 		{
 			if (e.getPersistentClass() == clazz)
 			{
 				return false;
 			}
 			throw e;
 		}
 		catch (HibernateException e)
 		{
 			throw e;
 		}
 		finally
 		{
 			session.close();
 		}
 	}
 
 	public Serializable save(Object obj, Serializable key)
 		throws HibernateException, FactoryException
 	{
 		Session session = openSession();
 		Transaction tx = session.beginTransaction();
 		try
 		{
 			checkTimestamps(obj);
 			if (key == null)
 			{
 				key = session.save(obj);
 			}
 			else
 			{
 				session.save(obj, key);
 			}
 			tx.commit();
 		}
 		catch (HibernateException e)
 		{
 			tx.rollback();
 			throw e;
 		}
 		finally
 		{
 			session.close();
 		}
 		return key;
 	}
 
 	protected static void checkTimestamps(Object obj)
 	{
 		if (obj instanceof TimestampedObject)
 		{
 			TimestampedObject t = (TimestampedObject) obj;
 			if (t.getDateCreated() == null)
 			{
 				t.setDateCreated(new Date());
 			}
 			t.setDateModified(new Date());
 		}
 	}
 
 	public Object open(Class clazz, Serializable key)
 		throws HibernateException, FactoryException
 	{
 		Session session = openSession();
 		Transaction tx = session.beginTransaction();
 		try
 		{
 			Object obj = session.load(clazz, key);
 			txSessions.put(obj, new TxSession(session, tx));
 			return obj;
 		}
 		catch (UnresolvableObjectException e)
 		{
             tx.rollback();
             session.close();
 			if (e.getPersistentClass() == clazz)
 			{
 				return null;
 			}
 			throw e;
 		}
 		catch (HibernateException e)
 		{
             tx.rollback();
             session.close();
 			throw e;
 		}
 	}
 
 	public void close(Object obj) throws HibernateException
 	{
 		TxSession txSession = (TxSession) txSessions.get(obj);
 		if (txSession == null)
 		{
 			return;
 		}
 		try
 		{
 			txSession.session.save(obj);
 			txSession.tx.commit();
 		}
 		catch (HibernateException e)
 		{
 		    LOG.fatal("Error while closing object " + obj, e);
 			txSession.tx.rollback();
 			throw e;
 		}
 		finally
 		{
 			txSession.session.close();
 		}
 	}
 
 	public void delete(Object obj) throws HibernateException
 	{
 		if (obj == null)
 		{
 			return;
 		}
 		TxSession txSession = (TxSession) txSessions.get(obj);
 		if (txSession == null)
 		{
 			return;
 		}
 		try
 		{
 			txSession.session.delete(obj);
 			txSession.tx.commit();
 		}
 		catch (HibernateException e)
 		{
 			txSession.tx.rollback();
 			throw e;
 		}
 		finally
 		{
 			txSession.session.close();
 		}
 	}
 
 	public void dispose(Object obj)
 	{
 		TxSession txSession = (TxSession) txSessions.get(obj);
 		if (txSession == null)
 		{
 			return;
 		}
 		try
 		{
 			txSession.tx.rollback();
 		}
 		catch (HibernateException e)
 		{
 			LOG.fatal("Error while rolling back " + obj, e);
 		}
 		finally
 		{
 			try
 			{
 				txSession.session.close();
 			}
 			catch (HibernateException e1)
 			{
 				LOG.fatal("Error while closing session", e1);
 			}
 		}
 	}
 
 	private class TxSession
 	{
 		Session session;
 
 		Transaction tx;
 
 		public TxSession(Session session, Transaction tx)
 		{
 			this.session = session;
 			this.tx = tx;
 		}
 	}
 }