package net.sf.cantina.datasource;
   
   import net.sf.cantina.DataSource;
   import net.sf.cantina.Document;
   import net.sf.cantina.Realm;
   import net.sf.cantina.exceptions.DuplicateKeyException;
   import net.sf.hibernate.*;
   import net.sf.hibernate.type.Type;
   import org.apache.log4j.Logger;
  
  import java.util.Collection;
  import java.util.List;
  
  /***
   * This class configures hibernate and provides access to sessions.
   *
   * @author Stephane JAIS
   */
  
  public abstract class HibernateDataSource
    extends DataSource
  {
    private static final Logger logger = Logger.getLogger(HibernateDataSource.class);
  
    //---------------------------------- Session Factory
  
    public abstract SessionFactory getSessionFactory();
  
    public abstract void closeSessionFactory()
      throws Exception;
    //---------------------------------- Session
    /***
     * The hibernate session is stored in a ThreadLocal.
     */
  
    protected abstract ThreadLocal getThreadLocalSession();
  
    /***
     * Gets/create the hibernate session.
     *
     * @see #closeSession()
     */
  
    public Session getSession() throws HibernateException
    {
      Session s = (Session) getThreadLocalSession().get();
      // Open a new Session, if this Thread has none yet
      if (s == null || !(s.isOpen()))
      {
        logger.debug("Opening hibernate session.");
        s = getSessionFactory().openSession();
        getThreadLocalSession().set(s);
        return s;
      }
      return s;
    }
  
    /***
     * Close the hibernate (SQL) connection.
     *
     * @see #getSession()
     */
  
    public void closeSession()
    {
      try
      {
        Session s = (Session) getThreadLocalSession().get();
        if (s != null && s.isOpen())
        {
          logger.debug("Closing hibernate session.");
          s.close();
        }
      } catch (HibernateException e)
      {
        logger.warn("Problem closing session.", e);
      }
    }
  
    /***
     * Releases all the hibernate resources.
     */
  
    //------------------------------ DataSource implementation
    public void release()
    {
      try
      {
  
        closeSession();
        closeSessionFactory();
      } catch (Exception e)
      {
        logger.warn("Problem releasing datasource.", e);
      }
    }
  
    public Object load(String id, Class clazz) throws Exception
    {
     try
     {
       return getSession().load(clazz, id);
     } catch (net.sf.hibernate.ObjectNotFoundException e)
     {
       throw new net.sf.cantina.exceptions.ObjectNotFoundException("not found.", e);
     }
   }
 
 
   public void createDocument(String documentId)
     throws DuplicateKeyException, Exception
   {
     boolean documentIsNew = false;
     // check if document already exists in db.
     try
     {
       loadDocument(documentId);
     } catch (net.sf.cantina.exceptions.ObjectNotFoundException e1)
     {
       documentIsNew = true;
     }
     if (!documentIsNew)
       throw new DuplicateKeyException("Document [" + documentId + "] already exists");
 
     PersistentDocument doc = new PersistentDocument();
     doc.setDocumentId(documentId);
     Session session = getSession();
     Transaction tx = session.beginTransaction();
     session.save(doc);
     tx.commit();
   }
 
   public Document loadDocument(String documentId)
     throws Exception
   {
     logger.debug("Loading document [" + documentId + "]");
     List results = getSession().find("from PersistentDocument as doc where doc.documentId = ?",
       new Object[]{documentId},
       new Type[]{Hibernate.STRING});
     if (results.size() == 0)
       throw new net.sf.cantina.exceptions.ObjectNotFoundException("No matching record.");
     return (PersistentDocument) results.get(0);
   }
 
   public void saveDocument(Document d) throws Exception
   {
     Session session = getSession();
     Transaction tx = session.beginTransaction();
     session.saveOrUpdate(d);
     tx.commit();
   }
 
   public void removeDocument(String documentId) throws Exception
   {
     Session session = getSession();
     Transaction tx = session.beginTransaction();
     session.delete("from PersistentDocument as d where d.documentId = ?",
       documentId, Hibernate.STRING);
     tx.commit();
   }
 
   public Realm loadRealm(String name)
     throws net.sf.cantina.exceptions.ObjectNotFoundException, Exception
   {
     return (PersistentRealm) load(name, PersistentRealm.class);
   }
 
   public void saveRealm(Realm r) throws Exception
   {
     Session session = getSession();
     Transaction tx = session.beginTransaction();
     session.update(r);
     tx.commit();
   }
 
   public void createRealm(String name) throws Exception
   {
     boolean realmIsNew = false;
     // check if document already exists in db.
     try
     {
       loadRealm(name);
     } catch (net.sf.cantina.exceptions.ObjectNotFoundException e1)
     {
       realmIsNew = true;
     }
     if (!realmIsNew)
       throw new DuplicateKeyException("Realm [" + name + "] already exists");
 
     Session session = getSession();
     PersistentRealm realm = new PersistentRealm();
     realm.setName(name);
     Transaction tx = session.beginTransaction();
     session.save(realm);
     tx.commit();
   }
 
   public void removeRealm(String name) throws Exception
   {
     Session session = getSession();
     Transaction tx = session.beginTransaction();
     session.delete("from PersistentRealm as realm where realm.name = ?",
       name,
       Hibernate.STRING);
     tx.commit();
   }
 
   public Collection findAllRealms() throws Exception
   {
     List results = getSession().find("from PersistentRealm as realm");
     return results;
   }
 
   public Collection selectAllDocumentIds() throws Exception
   {
     return getSession().find("select d.documentId from PersistentDocument as d");
   }
 }