// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.servlet.versionedstaticcontentfilter;

import org.litesoft.servlet.*;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

/**
 * This is a filter which enforces proper caching of a "LiteSoft Versioned" web app
 * w/ "common" redirection.  It requires that you serve your GWT application via a
 * Java servlet container.
 * <p/>
 * Many thanks to Mat Gessel <mat.gessel@gmail.com> for providing an implementation of
 * the standard GWT Caching mechanism as a basis.
 * <p/>
 * To use, add the jar to <code>WEB-INF/lib</code> and add the
 * following to your deployment descriptor (web.xml):
 * <p/>
 * <pre>
 * &lt;filter&gt;
 *   &lt;filter-name&gt;VersionedStaticContentFilter&lt;/filter-name&gt;
 *   &lt;filter-class&gt;org.litesoft.servlet.versionedstaticcontentfilter.VersionedStaticContentFilter&lt;/filter-class&gt;
 * &lt;/filter&gt;
 *
 * &lt;filter-mapping&gt;
 *   &lt;filter-name&gt;VersionedStaticContentFilter&lt;/filter-name&gt;
 *   &lt;url-pattern&gt;/*&lt;/url-pattern&gt;
 * &lt;/filter-mapping&gt;</pre>
 *
 * A "LiteSoft Versioned" web app is one where the majority of the DOM is built via
 * JavaScript (e.g. a GWT app) and that the path has a version number in it (e.g. /v1/).
 * This means that everything can be cached "forever" EXCEPT certain JavaScript (e.g.
 * the versioned bootstrap JavaScript).  So this code set the caching headers to "forever"
 * for everything EXCEPT files that end with ".nocache.js".
 *
 * Additionally, it maps requests to a common path under the versioned path to just the
 * common path (e.g. "/v1/common/images/fred.jpg" becomes "/common/images/fred.jpg").  This
 * makes it so that when the app is "versioned", all the common resources do not need to be
 * duplicated for each version.  Note: this also means that older versions will be accessing
 * the newer resources, but as the proper behavior of the older versions (in a "LiteSoft
 * Versioned" web app) are to immediately forward to the current version, there should be
 * little to no deleterious effects.
 *
 * Usage notes
 * <ul>
 * <li>You can verify that the filter is being applied with Firefox's Web
 * Developer Extension. Click Tools > Web Developer > Information > View
 * Response Headers.
 * <li>If you are running an Apache httpd/Jk/Tomcat server configuration you
 * need to ensure that Tomcat is serving HTML files, otherwise the filter will
 * not be applied.
 * <li>One reason that this filter exists is that you cannot use <code>*.nocache.html</code> or
 * <code>*.cache.html</code> for url patterns. According to the 2.3 servlet
 * spec, an extension is defined as the characters after the <strong>last</strong>
 * period.
 * <li>The header is modified <em>before</em> passing control down the filter chain.
 * </ul>
 *
 * @see <a
 * href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9">Cache-control
 * directive</a>
 * @see <a
 * href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.21">Expires
 * directive</a>
 * @see <a
 * href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.32">Pragma
 * directive</a>
 */
public class VersionedStaticContentFilter implements Filter
{
    public static final String VERSION_PATH_ID = "/ver";

    @Override
    public void init( FilterConfig filterConfig )
            throws ServletException
    {
        mServletContext = filterConfig.getServletContext();
        String zLocationAnchorPath = WebInfLocator.getLocationAnchorPath();
        String zDevMode = System.getProperty( "DevMode" );
        if ( zDevMode == null )
        {
            mMode = new Production();
        }
        else
        {
            File[] zStaticFileSearchPaths = createStaticFileSearchPaths( zDevMode, zLocationAnchorPath );
            mMode = (zStaticFileSearchPaths == null) ? new DevMode() : new DevModeDirect( zStaticFileSearchPaths );
        }
        System.out.println( "VersionedStaticContentFilter.init: " + zLocationAnchorPath + "\n  Mode: " + mMode );
    }

    private File[] createStaticFileSearchPaths( String pDevMode, String pLocationAnchorPath )
    {
        File zDir = WebInfLocator.extractDir( pLocationAnchorPath );
        if ( zDir == null )
        {
            return null;
        }
        File zWarDir = zDir.getParentFile();
        List<File> zStaticFileSearchPaths = new ArrayList<File>();
        zStaticFileSearchPaths.add( zWarDir );
        int from = 0;
        for ( int at; -1 != (at = pDevMode.indexOf( '|', from )); from = at + 1 )
        {
            addPath( zStaticFileSearchPaths, zWarDir, pDevMode.substring( from, at ) );
        }
        addPath( zStaticFileSearchPaths, zWarDir, pDevMode.substring( from ) );
        return (zStaticFileSearchPaths.size() > 1) ? zStaticFileSearchPaths.toArray( new File[zStaticFileSearchPaths.size()] ) : null;
    }

    private void addPath( List<File> pStaticFileSearchPaths, File pWarDir, String pPossiblePath )
    {
        if ( (pPossiblePath = pPossiblePath.trim()).length() == 0 )
        {
            return;
        }
        File zDir = new File( pWarDir, pPossiblePath );
        if ( !zDir.isDirectory() )
        {
            System.out.println( "VersionedStaticContentFilter.addPath, Not a Directory: " + zDir.getPath() );
            return;
        }
        try
        {
            pStaticFileSearchPaths.add( zDir.getCanonicalFile() );
        }
        catch ( IOException e )
        {
            System.out.println( "VersionedStaticContentFilter.addPath, Could not Canonicalize: " + zDir.getPath() );
        }
    }

    private interface Mode
    {
        void processGetRequest( String pRequestURI, HttpServletRequest pRequest, HttpServletResponse pResponse, ServletContext pServletContext,
                                FilterChain pChain )
                throws IOException, ServletException;
    }

    private Mode mMode;
    private ServletContext mServletContext;

    @Override
    public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain )
            throws IOException, ServletException
    {
        if ( (request instanceof HttpServletRequest) && (response instanceof HttpServletResponse) )
        {
            HttpServletRequest zRequest = (HttpServletRequest) request;
            if ( "GET".equals( zRequest.getMethod() ) )
            {
                String zURI = zRequest.getRequestURI();
                HttpServletResponse zResponse = (HttpServletResponse) response;
                mMode.processGetRequest( zURI, zRequest, zResponse, mServletContext, chain );
                return;
            }
        }
        chain.doFilter( request, response ); // Goes to default servlet.
    }

    @Override
    public void destroy()
    {
    }

    public static class Production implements Mode
    {
        @Override
        public final void processGetRequest( String pRequestURI, HttpServletRequest pRequest, HttpServletResponse pResponse, ServletContext pServletContext,
                                             FilterChain pChain )
                throws IOException, ServletException
        {
            String zURI = cleanRequest( pRequestURI = pRequestURI.trim() );
            if ( shouldCacheExtensions( getLowerCaseExtension( zURI ) ) && isVersionedPath( zURI ) )
            {
                cacheForever( pResponse );
            }
            else
            {
                noCache( pResponse );
            }
            delegate( pRequestURI, pRequest, pResponse, pServletContext, pChain );
        }

        private boolean isVersionedPath( String pCleanedRequestURI )
        {
            if ( pCleanedRequestURI.startsWith( VERSION_PATH_ID ) ) // Starts w/ == Happy Case!
            {
                return true;
            }
            int zAt = pCleanedRequestURI.indexOf( VERSION_PATH_ID );
            return (zAt != -1) && // Has it in path
                   (0 == pCleanedRequestURI.substring( 0, zAt ).lastIndexOf( '/' )); // AND is first sub-path (first being the WAR/directory name)
        }

        protected boolean shouldCacheExtensions( String pLowerCaseExtension )
        {
            return !"html".equals( pLowerCaseExtension );
        }

        protected String cleanRequest( String pRequestURI )
        {
            int at;
            if ( -1 != (at = pRequestURI.indexOf( '?' )) )
            {
                return pRequestURI.substring( 0, at );
            }
            if ( -1 != (at = pRequestURI.indexOf( '#' )) )
            {
                return pRequestURI.substring( 0, at );
            }
            return pRequestURI;
        }

        protected String getLowerCaseExtension( String pCleanedRequestURI )
        {
            int at = pCleanedRequestURI.lastIndexOf( '.' );
            return (-1 == at) ? "" : pCleanedRequestURI.substring( at + 1 ).toLowerCase();
        }

        protected void delegate( String pRequestURI, HttpServletRequest pRequest, HttpServletResponse pResponse,
                                 ServletContext pServletContext, FilterChain pChain )
                throws ServletException, IOException
        {
            pChain.doFilter( pRequest, pResponse ); // Goes to default servlet.
        }

        @Override
        public String toString()
        {
            return "Production";
        }
    }

    public static class DevMode extends Production
    {
        @Override
        protected boolean shouldCacheExtensions( String pLowerCaseExtension )
        {
            return super.shouldCacheExtensions( pLowerCaseExtension ) && !"js".equals( pLowerCaseExtension ) && !"css".equals( pLowerCaseExtension );
        }

        @Override
        public String toString()
        {
            return "Dev";
        }
    }

    public static class DevModeDirect extends DevMode
    {
        private File[] mStaticFileSearchPaths;

        public DevModeDirect( File[] pStaticFileSearchPaths )
        {
            mStaticFileSearchPaths = pStaticFileSearchPaths;
        }

        @Override
        protected void delegate( String pRequestURI, HttpServletRequest pRequest, HttpServletResponse pResponse,
                                 ServletContext pServletContext, FilterChain pChain )
                throws ServletException, IOException
        {
            File zFoundFile = findFile( pRequestURI );
            if ( zFoundFile == null )
            {
                pResponse.sendError( HttpServletResponse.SC_NOT_FOUND );
                return;
            }
            // Get the MIME type of the image
            String mimeType = pServletContext.getMimeType( zFoundFile.getName().toLowerCase() );
            if ( mimeType == null )
            {
                pServletContext.log( "Could not get MIME type of " + zFoundFile.getName() );
                pResponse.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR );
                return;
            }

            // Set content type
            pResponse.setContentType( mimeType );

            // Set content size
            pResponse.setContentLength( (int) zFoundFile.length() );

            // Open the file and output streams
            InputStream in = new FileInputStream( zFoundFile );
            try
            {
                OutputStream out = pResponse.getOutputStream();
                try
                {
                    copyStream( in, out );

                    Closeable zCloseable = out;
                    out = null;
                    zCloseable.close();
                }
                finally
                {
                    closeQuietly( out );
                }
            }
            finally
            {
                closeQuietly( in );
            }
        }

        private File findFile( String pRequestURI )
        {
            for ( File zPath : mStaticFileSearchPaths )
            {
                File zFound = checkPath( zPath, pRequestURI );
                if ( zFound != null )
                {
                    System.out.println( "VersionedStaticContentFilter.FindFile (200): " + pRequestURI + " -> " + zFound.getPath() );
                    return zFound;
                }
            }
            System.out.println( "VersionedStaticContentFilter.FindFile (404): " + pRequestURI );
            return null;
        }

        @Override
        public String toString()
        {
            StringBuilder sb = new StringBuilder().append( super.toString() ).append( ':' );
            for ( File zPath : mStaticFileSearchPaths )
            {
                sb.append( "\n    " ).append( zPath.getPath() );
            }
            return sb.toString();
        }
    }

    private static void closeQuietly( Closeable pClosable )
    {
        if ( pClosable != null )
        {
            try
            {
                pClosable.close();
            }
            catch ( IOException e )
            {
                // Whatever
            }
        }
    }

    private static void copyStream( InputStream pIn, OutputStream pOut )
            throws IOException
    {
        // Copy the contents of the file to the output stream
        byte[] buf = new byte[1024];
        for ( int count; (count = pIn.read( buf )) > 0; )
        {
            pOut.write( buf, 0, count );
        }
    }

    private static File checkPath( File pPath, String pSubPath )
    {
        if ( pSubPath == null || pSubPath.length() == 0 )
        {
            return null;
        }
        File zFile = new File( pPath, pSubPath );
        if ( !zFile.isFile() )
        {
            return null;
        }
        try
        {
            return zFile.getCanonicalFile();
        }
        catch ( IOException e )
        {
            e.printStackTrace();
            return null;
        }
    }

    private static void cacheForever( HttpServletResponse pResponse )
    {
        // the w3c spec requires a maximum age of 1 year
        // Firefox 3+ needs 'public' to cache this resource when received via SSL
        pResponse.setHeader( "Cache-Control", "public max-age=31536000" );

        // necessary to overwrite "Pragma: no-cache" header
        pResponse.setHeader( "Pragma", "temp" );
        pResponse.setHeader( "Pragma", "" );
        pResponse.setDateHeader( "Expires", System.currentTimeMillis() + 31536000000l );
    }

    private static void noCache( HttpServletResponse pResponse )
    {
        pResponse.setHeader( "Cache-Control", "no-cache no-store must-revalidate" );
        pResponse.setHeader( "Pragma", "no-cache" ); // HTTP/1.0
        pResponse.setDateHeader( "Expires", 86400000 ); // January 2, 1970
    }
}