package ie.gov.agriculture.dpcs.hibernate;

import java.io.FileInputStream;
import java.util.Properties;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.exception.ConstraintViolationException;

public class HibernateUtil {

   private static final SessionFactory sessionFactory;
   
    private static final ThreadLocal threadSession = new ThreadLocal();
   
    private static final ThreadLocal threadTransaction = new ThreadLocal();
   
    private static Log log = LogFactory.getLog(HibernateUtil.class);
   

   
    static {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
           sessionFactory = new Configuration().configure().buildSessionFactory();
           log.debug("Created Hibernate Session Factory");
          
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            log.debug("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }


    /**
     *
     * @return
     */
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    /**
     * Create a new Session if no session exists
     * and add it to the current thread.
     *
     * @return the current session
     */
    public static Session getSession() {

       Session s = (Session)threadSession.get();
       // Open a new Session, it this thread has none yet
       
       try {
          if(s== null) {
             log.debug("SessionFactory is closed = " + sessionFactory.isClosed());
             s = sessionFactory.openSession();
             log.debug("Session is connected = " + s.isConnected()+ " And is open = " + s.isOpen());
             log.debug("HibernateUtil::Opening new Hibernate Session");
             threadSession.set(s);
             log.debug("HibernateUtil::Added Session to current Thread");
             

          }
          
       } catch (HibernateException e) {
                    
          log.debug("HibernateException Getting Session::" + e.getMessage());
          e.printStackTrace();
       }
       
       return s;
    }
   
    /**
     * Remove the session from the current thread
     * and if it is open, close it.
     *
     */
    public static void closeSession() {
       
       try {
          Session s = (Session)threadSession.get();
          threadSession.set(null);
         log.debug("HibernateUtil::Closing Hibernate Session");
          if( s != null && s.isOpen()) {
             s.close();
          }
          
       } catch (HibernateException e) {
          
          log.debug("HibernateException Closing Session::" + e.getMessage());
          e.printStackTrace();
       }
    }
   
    /**
     * If no transaction exists, create a new one and add it to
     * this thread
     *
     */
    public static void beginTransaction() {


       Transaction tx = (Transaction)threadTransaction.get();
       try{
          if(tx == null) {
             log.debug("HibernateUtil::Starting new Hibernate Transaction");
             tx = getSession().beginTransaction();
             threadTransaction.set(tx);
             log.debug("HibernateUtil::Added Hibernate Transaction to local thread:: tx is Active= " + tx.isActive());
          }
          
       } catch (HibernateException e) {
          
          log.debug("HibernateException Beginning Transaction::" + e.getMessage());
          e.printStackTrace();

       }
    }
   
    /**
     * Commit the Transaction if it has not been comitted or
     * rolled back already.
     *
     */
    public static void commitTransaction() {
       
       Transaction tx = (Transaction)threadTransaction.get();
   
       try {
         threadTransaction.set(null);
          if(tx != null && !tx.wasCommitted()
                     && !tx.wasRolledBack()) {
             log.debug("HibernateUtil::Commiting Hibernate Transaction");
             tx.commit();
          }
          
       } catch (ConstraintViolationException e) {
          
          log.debug("HibernateException Rolling Back Transaction::" + e.getMessage());
          rollbackTransaction();
          throw e;

       } catch (HibernateException e) {
          
          log.debug("HibernateException Rolling Back Transaction::" + e.getMessage());
          rollbackTransaction();
          e.printStackTrace();
          
       }
    }
   
    public static void attemptCommitTransaction() {
       
       Transaction tx = (Transaction)threadTransaction.get();
   
      threadTransaction.set(null);
         if(tx != null && !tx.wasCommitted()
                    && !tx.wasRolledBack()) {
           log.debug("HibernateUtil::Attempting to Commit Hibernate Transaction");
            tx.commit();
         }
          
    }
   
    /**
     * Roll back transaction if it has not been comitted
     * or rolled back already
     *
     */
    public static void rollbackTransaction() {
       
       Transaction tx = (Transaction)threadTransaction.get();
       
      log.debug("HibernateUtil::About to Rollback Hibernate Transaction:: tx is Active= " + tx.isActive());          
       try {
         threadTransaction.set(null);
         if(tx != null && !tx.wasCommitted()
                    && !tx.wasRolledBack()) {
            log.debug("HibernateUtil::Rollingback Hibernate Transaction");          
            tx.rollback();
         }
      
       } catch (HibernateException e) {
          
          log.debug("HibernateException Rolling Back Transaction::" + e.getMessage());
          e.printStackTrace();
      
      } finally {
         
         closeSession();
      }
       
    }
}

public class HibernateFilter implements Filter {
   
    private static Log log = LogFactory.getLog(HibernateFilter.class);

   public void destroy() {
      // TODO Auto-generated method stub

   }

   public void doFilter(ServletRequest request, ServletResponse response,
         FilterChain filterChain) throws IOException, ServletException {

      try{
         // We are using Tiles and so have to explicitly put our action errors
         // into the session instead of the request. We remove any errors here
         // from a previous request.
         HttpServletRequest req = (HttpServletRequest)request;
         req.getSession().removeAttribute(Globals.ERROR_KEY);
         filterChain.doFilter(request,response);
         HibernateUtil.commitTransaction();
         
         // catch all exception for any uncaught
      } catch (Exception e) {
         
         log.debug("HibernateFilter::" + e.getMessage());
         System.out.println("HibernateFilter::" + e.getMessage());
         e.printStackTrace();
         
      } finally {
         
         HibernateUtil.closeSession();
      }
   }

   public void init(FilterConfig arg0) throws ServletException {
      // TODO Auto-generated method stub

   }