package com.qrsx.exam.web.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.context.ThreadLocalSessionContext;

import com.qrsx.exam.dao.util.HibernateUtil;

/**
 * A servlet filter that disconnects and reconnects a Hibernate Session for each
 * request.
 * <p>
 * This filter should be used if your
 * <tt>hibernate.current_session_context_class</tt> configuration is set to
 * <tt>thread</tt>
 * <p>
 * This filter guarantees a sane state, committing any pending database
 * transaction once all other filters (and servlets) have executed.
 * <p>
 * Use this filter for the <b>session-per-application-transaction</b> pattern
 * with a <i>Long Session</i>. Don't forget to set conversation boundaries in
 * your code, as described in Hibernate in Action. One way to do this is to put
 * a marker attribute in the request, and let the filter handle flushing and
 * closing of the Session at the end of a conversation. Another way is to not
 * use this filter at all but the Seam framework with built-in support for
 * conversations.
 * <p>
 * This filter only works in resource-local environments and should not be used
 * with CMT/JTA or BMT/JTA. You need to subclass the <tt>JTASessionContext</tt>
 * for this, not use <tt>ThreadLocalSessionContext</tt>.
 * 
 * @see org.hibernate.context.ThreadLocalSessionContext
 * @see org.hibernate.context.JTASessionContext
 * 
 * @author Christian Bauer <christian@hibernate.org>
 */
public class HibernateFilterLong implements Filter {

    private static Log log = LogFactory.getLog(HibernateFilterLong.class);

    private SessionFactory sf = HibernateUtil.getSessionFactory();

    private static final String HTTPSESSIONKEY = "HibernateSession";

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

        // Try to get a Hibernate Session from the HttpSession
        HttpSession userSession = ((HttpServletRequest) request).getSession();
        Session hibernateSession = (Session) userSession
                .getAttribute(HTTPSESSIONKEY);

        if (hibernateSession != null) {
            log.debug("Binding stored Session to thread.");
            ThreadLocalSessionContext.bind(hibernateSession);
        }

        // Always disable flushing for Long Session pattern
        log.debug("Disabling automatic flushing of the current Session.");
        sf.getCurrentSession().setFlushMode(FlushMode.NEVER);

        try {
            // Do the work...
            chain.doFilter(request, response);

            if (request.getAttribute("END_OF_APP_TX_MARKER") != null) {

                // Begin a database transaction if none is active
                sf.getCurrentSession().beginTransaction();

                log.debug("Flushing Session.");
                sf.getCurrentSession().flush();

                log.debug("Committing the database transaction");
                sf.getCurrentSession().getTransaction().commit();

                log.debug("Removing Session from HttpSession.");
                userSession.setAttribute(HTTPSESSIONKEY, null);

            } else {

                // Commit any pending database transaction
                log.debug("Committing database transaction.");
                sf.getCurrentSession().getTransaction().commit();

                // Disconnect the Session from the thread
                log.debug("Unbinding Session from thread");
                hibernateSession = ThreadLocalSessionContext.unbind(sf);

                // and store it in the users HttpSession.
                userSession.setAttribute(HTTPSESSIONKEY, hibernateSession);

            }

        } catch (Throwable ex) {
            // Rollback only
            try {
                log
                        .debug("Trying to rollback database transaction after exception");
                sf.getCurrentSession().getTransaction().rollback();
            } catch (Throwable rbEx) {
                log.error("Could not rollback transaction after exception!",
                        rbEx);
            }

            // Let others handle it... maybe another interceptor for exceptions?
            throw new ServletException(ex);

        } finally {

            // Cleanup
            log.debug("Closing and unbinding Session from thread");
            sf.getCurrentSession().close(); // Unbind is automatic here

            log.debug("Removing Session from HttpSession.");
            userSession.setAttribute(HTTPSESSIONKEY, null);
        }

    }

    public void init(FilterConfig filterConfig) throws ServletException {
    }

    public void destroy() {
    }

}