/*
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package gr.abiss.mvn.plugins.jstools.web;
  
  import gr.abiss.mvn.plugins.jstools.utils.ClasspathResourceUtils;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.util.Collections;
  import java.util.zip.GZIPOutputStream;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  import javax.servlet.Filter;
  import javax.servlet.FilterChain;
  import javax.servlet.FilterConfig;
  import javax.servlet.ServletException;
  import javax.servlet.ServletOutputStream;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import org.apache.commons.lang.BooleanUtils;
  import org.apache.log4j.Logger;
  
  /***
   * A Servlet Filter that loads Javascript files or other static resources from
   * the runtime classpath and uses them to build an HTTP response. Web
   * applications can, for example, include JS dependencies in their Maven POM and
   * the filter will resolve those at runtime, cache them and produce the
   * appropriate HTTP response.
   * 
   * The filter will only serve classpath resource types with file extentions you
   * configure it to, (see the <code>allowedExtentions</code> init-param) and
   * with the Cache-Control HTTP header you specify (see the
   * <code>cacheControl</code> init-param).
   * 
   * Note that the filter will only handle HTTP GET and HTTP HEAD requests. All
   * other HTTP request methods will be server with a "Non Implemented" (501) HTTP
   * response error.
   * 
   * To add the filter in your application, add the folowing in your web.xml or,
   * in case you use XDoclet (webdoclet), your filters.xml merge file:
   * 
   * <pre>
   *    &lt;filter&gt; 
   *       &lt;filter-name&gt;JavascriptDependencyFilter&lt;/filter-name&gt;
   *       &lt;filter-class&gt;gr.abiss.mvn.plugins.jstools.web.JavascriptDependencyFilter&lt;/filter-class&gt;
   *       &lt;init-param&gt; 
   *          &lt;!-- 
   *             Optional, tells the filter which file extentions are allowed.
   *             The default are the sample values below (if you just want those,
   *             you don't have to configure the filter).
   *             Note that the Filter will NOT load resources from META-INF.
   *          --&gt; 
   *          &lt;param-name&gt;<strong>allowedExtentions</strong>&lt;/param-name&gt;
   *          &lt;param-value&gt;js png jpg gif txt html htm xml xsl xslt svg svgz swf&lt;/param-value&gt; 
   *      &lt;/init-param&gt;
   *       &lt;init-param&gt; 
   *          &lt;!-- 
   *             Optional, used to configure the Cache-Control HTTP header. 
   *             Default is &quot;max-age=86400&quot; 
   *          --&gt; 
   *          &lt;param-name&gt;<strong>cacheControl</strong>&lt;/param-name&gt;
   *          &lt;param-value&gt;max-age=86400&lt;/param-value&gt; 
   *      &lt;/init-param&gt;
   *       &lt;init-param&gt; 
   *          &lt;!-- 
   *             Optional, enable gzip compression for browsers that support it
   *             (based on HTTP request headers). Default is true.
   *          --&gt; 
   *          &lt;param-name&gt;<strong>enableGzip</strong>&lt;/param-name&gt;
   *          &lt;param-value&gt;true&lt;/param-value&gt; 
   *      &lt;/init-param&gt;
   *       &lt;init-param&gt; 
   *          &lt;!-- 
   *             Optional, control whether resources are cached to
   *             avoid I/O overhead every time they are requested. Default is true.
   *          --&gt; 
   *          &lt;param-name&gt;<strong>enableCache</strong>&lt;/param-name&gt;
   *          &lt;param-value&gt;true&lt;/param-value&gt; 
   *      &lt;/init-param&gt;
   *       &lt;init-param&gt; 
   *          &lt;!-- 
   *             Optional, control whether gzipped resources are cached to
   *             avoid GZIPing overhead every time they are requested. Default is true.
   *          --&gt; 
  *          &lt;param-name&gt;<strong>enableGzipedCache</strong>&lt;/param-name&gt;
  *          &lt;param-value&gt;true&lt;/param-value&gt; 
  *      &lt;/init-param&gt;
  *      &lt;init-param&gt;
  *          &lt;!-- 
  *             Optional, tells the filter whether to send an HTTP 404 (&quot;not found&quot;) code 
  *             or let go of the filter chain to the application if no matching resource
  *             is found in the classpath. Possible values are {true, false}.
  *             The default is to send a 404 (true). 
  *          --&gt; 
  *          &lt;param-name&gt;<strong>send404</strong>&lt;/param-name&gt;
  *          &lt;param-value&gt;true&lt;/param-value&gt; 
  *      &lt;/init-param&gt;
  *       &lt;init-param&gt; 
  *          &lt;!--
  *             Optional (mandatory for arbitary url-pattern in filter-mapping). 
  *             Used to tell the plugin what base URL fragment to ignore when looking 
  *             for Javascript resources. Must match the url-pattern in filter-mapping, 
  *             see below. Default is /lib/js
  *          --&gt; 
  *          &lt;param-name&gt;<strong>basePath</strong>&lt;/param-name&gt;
  *          &lt;param-value&gt;/lib/js/&lt;/param-value&gt; 
  *      &lt;/init-param&gt; 
  *    &lt;/filter&gt;
  * </pre>
  * 
  * The servlet container also needs a mapping for the filter. You really don't
  * want the filter intercepting all HTTP requests! The URL pattern in the filter
  * mapping <strong>must</strong> be exactly the same with the value of the
  * <code>basePath</code> inialization parameter:
  * 
  * <pre>
  *    &lt;filter-mapping&gt;
  *      &lt;filter-name&gt;JavascriptDependencyFilter&lt;/filter-name&gt;
  *      &lt;!-- matches the default value of the <strong>basePath</strong>
  * <code>
  * init - param
  * </code>
  *      &lt;url-pattern&gt;/lib/js/&lt;/url-pattern&gt;
  *    &lt;/filter-mapping&gt;
  * </pre>
  * 
  * This helps in inly invoking the filter for resources that are actually in the
  * classpath. To clarify, suppose an HTML response has a script tag like this:
  * 
  * <pre>
  *    &lt;script type=&quot;text/javascript&quot; 
  *       src=&quot;/lib/js/gr/abiss/js/sarissa/sarissa.js&quot;&gt; 
  *    &lt;script&amp;gt
  * </pre>
  * 
  * The browser will try to load the script making an HTTP GET for that URL. The
  * server will have the filter intercept the request since it matches the URL
  * pattern of the filter mapping. The filter will then do the following:
  * <ol>
  * <li>Obtain the request URI</li>
  * <li>Substring the URL removing the part that matches the value of the
  * <code>basePath</code> initialization parameter</li>
  * <li>Use the result to lookup the corresponding resource in it's cache. Load
  * the resource and put it in the cache if not already there</li>
  * <li>If the resource exists make an HTTP response with it, otherwise let the
  * filter chain go or send a 404 depending on the value of the
  * <code>send404</code> initialization parameter.</li>
  * 
  * @version $Id$
  * @author manos
  */
 public class JavascriptDependencyFilter implements Filter {
 	private static Logger log = Logger
 			.getLogger(JavascriptDependencyFilter.class);
 
 	/***
 	 * The knwon MIME types map for this filter (file extention, MIME type)
 	 */
 	protected static Map<String, String> MIME_TYPE_MAPPINGS = new HashMap<String, String>();
 	static {
 		MIME_TYPE_MAPPINGS.put("abs", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("ai", "application/postscript");
 		MIME_TYPE_MAPPINGS.put("aif", "audio/x-aiff");
 		MIME_TYPE_MAPPINGS.put("aifc", "audio/x-aiff");
 		MIME_TYPE_MAPPINGS.put("aiff", "audio/x-aiff");
 		MIME_TYPE_MAPPINGS.put("aim", "application/x-aim");
 		MIME_TYPE_MAPPINGS.put("art", "image/x-jg");
 		MIME_TYPE_MAPPINGS.put("asf", "video/x-ms-asf");
 		MIME_TYPE_MAPPINGS.put("asx", "video/x-ms-asf");
 		MIME_TYPE_MAPPINGS.put("au", "audio/basic");
 		MIME_TYPE_MAPPINGS.put("avi", "video/x-msvideo");
 		MIME_TYPE_MAPPINGS.put("avx", "video/x-rad-screenplay");
 		MIME_TYPE_MAPPINGS.put("bcpio", "application/x-bcpio");
 		MIME_TYPE_MAPPINGS.put("bin", "application/octet-stream");
 		MIME_TYPE_MAPPINGS.put("bmp", "image/bmp");
 		MIME_TYPE_MAPPINGS.put("body", "text/html");
 		MIME_TYPE_MAPPINGS.put("cdf", "application/x-cdf");
 		MIME_TYPE_MAPPINGS.put("cer", "application/x-x509-ca-cert");
 		MIME_TYPE_MAPPINGS.put("class", "application/java");
 		MIME_TYPE_MAPPINGS.put("cpio", "application/x-cpio");
 		MIME_TYPE_MAPPINGS.put("csh", "application/x-csh");
 		MIME_TYPE_MAPPINGS.put("css", "text/css");
 		MIME_TYPE_MAPPINGS.put("dib", "image/bmp");
 		MIME_TYPE_MAPPINGS.put("doc", "application/msword");
 		MIME_TYPE_MAPPINGS.put("dtd", "text/plain");
 		MIME_TYPE_MAPPINGS.put("dv", "video/x-dv");
 		MIME_TYPE_MAPPINGS.put("dvi", "application/x-dvi");
 		MIME_TYPE_MAPPINGS.put("eps", "application/postscript");
 		MIME_TYPE_MAPPINGS.put("etx", "text/x-setext");
 		MIME_TYPE_MAPPINGS.put("exe", "application/octet-stream");
 		MIME_TYPE_MAPPINGS.put("gif", "image/gif");
 		MIME_TYPE_MAPPINGS.put("gtar", "application/x-gtar");
 		MIME_TYPE_MAPPINGS.put("gz", "application/x-gzip");
 		MIME_TYPE_MAPPINGS.put("hdf", "application/x-hdf");
 		MIME_TYPE_MAPPINGS.put("hqx", "application/mac-binhex40");
 		MIME_TYPE_MAPPINGS.put("htc", "text/x-component");
 		MIME_TYPE_MAPPINGS.put("htm", "text/html");
 		MIME_TYPE_MAPPINGS.put("html", "text/html");
 		MIME_TYPE_MAPPINGS.put("hqx", "application/mac-binhex40");
 		MIME_TYPE_MAPPINGS.put("ief", "image/ief");
 		MIME_TYPE_MAPPINGS.put("jad", "text/vnd.sun.j2me.app-descriptor");
 		MIME_TYPE_MAPPINGS.put("jar", "application/java-archive");
 		MIME_TYPE_MAPPINGS.put("java", "text/plain");
 		MIME_TYPE_MAPPINGS.put("jnlp", "application/x-java-jnlp-file");
 		MIME_TYPE_MAPPINGS.put("jpe", "image/jpeg");
 		MIME_TYPE_MAPPINGS.put("jpeg", "image/jpeg");
 		MIME_TYPE_MAPPINGS.put("jpg", "image/jpeg");
 		MIME_TYPE_MAPPINGS.put("js", "text/javascript");
 		MIME_TYPE_MAPPINGS.put("jsf", "text/plain");
 		MIME_TYPE_MAPPINGS.put("jspf", "text/plain");
 		MIME_TYPE_MAPPINGS.put("kar", "audio/x-midi");
 		MIME_TYPE_MAPPINGS.put("latex", "application/x-latex");
 		MIME_TYPE_MAPPINGS.put("m3u", "audio/x-mpegurl");
 		MIME_TYPE_MAPPINGS.put("mac", "image/x-macpaint");
 		MIME_TYPE_MAPPINGS.put("man", "application/x-troff-man");
 		MIME_TYPE_MAPPINGS.put("me", "application/x-troff-me");
 		MIME_TYPE_MAPPINGS.put("mid", "audio/x-midi");
 		MIME_TYPE_MAPPINGS.put("midi", "audio/x-midi");
 		MIME_TYPE_MAPPINGS.put("mif", "application/x-mif");
 		MIME_TYPE_MAPPINGS.put("mov", "video/quicktime");
 		MIME_TYPE_MAPPINGS.put("movie", "video/x-sgi-movie");
 		MIME_TYPE_MAPPINGS.put("mp1", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("mp2", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("mp3", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("mpa", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("mpe", "video/mpeg");
 		MIME_TYPE_MAPPINGS.put("mpeg", "video/mpeg");
 		MIME_TYPE_MAPPINGS.put("mpega", "audio/x-mpeg");
 		MIME_TYPE_MAPPINGS.put("mpg", "video/mpeg");
 		MIME_TYPE_MAPPINGS.put("mpv2", "video/mpeg2");
 		MIME_TYPE_MAPPINGS.put("ms", "application/x-wais-source");
 		MIME_TYPE_MAPPINGS.put("nc", "application/x-netcdf");
 		MIME_TYPE_MAPPINGS.put("oda", "application/oda");
 		MIME_TYPE_MAPPINGS.put("pbm", "image/x-portable-bitmap");
 		MIME_TYPE_MAPPINGS.put("pct", "image/pict");
 		MIME_TYPE_MAPPINGS.put("pdf", "application/pdf");
 		MIME_TYPE_MAPPINGS.put("pgm", "image/x-portable-graymap");
 		MIME_TYPE_MAPPINGS.put("pic", "image/pict");
 		MIME_TYPE_MAPPINGS.put("pict", "image/pict");
 		MIME_TYPE_MAPPINGS.put("pls", "audio/x-scpls");
 		MIME_TYPE_MAPPINGS.put("png", "image/png");
 		MIME_TYPE_MAPPINGS.put("pnm", "image/x-portable-anymap");
 		MIME_TYPE_MAPPINGS.put("pnt", "image/x-macpaint");
 		MIME_TYPE_MAPPINGS.put("ppm", "image/x-portable-pixmap");
 		MIME_TYPE_MAPPINGS.put("ps", "application/postscript");
 		MIME_TYPE_MAPPINGS.put("psd", "image/x-photoshop");
 		MIME_TYPE_MAPPINGS.put("qt", "video/quicktime");
 		MIME_TYPE_MAPPINGS.put("qti", "image/x-quicktime");
 		MIME_TYPE_MAPPINGS.put("qtif", "image/x-quicktime");
 		MIME_TYPE_MAPPINGS.put("ras", "image/x-cmu-raster");
 		MIME_TYPE_MAPPINGS.put("rgb", "image/x-rgb");
 		MIME_TYPE_MAPPINGS.put("rm", "application/vnd.rn-realmedia");
 		MIME_TYPE_MAPPINGS.put("roff", "application/x-troff");
 		MIME_TYPE_MAPPINGS.put("rtf", "application/rtf");
 		MIME_TYPE_MAPPINGS.put("rtx", "text/richtext");
 		MIME_TYPE_MAPPINGS.put("sh", "application/x-sh");
 		MIME_TYPE_MAPPINGS.put("shar", "application/x-shar");
 		MIME_TYPE_MAPPINGS.put("smf", "audio/x-midi");
 		MIME_TYPE_MAPPINGS.put("snd", "audio/basic");
 		MIME_TYPE_MAPPINGS.put("src", "application/x-wais-source");
 		MIME_TYPE_MAPPINGS.put("sv4cpio", "application/x-sv4cpio");
 		MIME_TYPE_MAPPINGS.put("sv4crc", "application/x-sv4crc");
 		MIME_TYPE_MAPPINGS.put("swf", "application/x-shockwave-flash");
 		MIME_TYPE_MAPPINGS.put("t", "application/x-troff");
 		MIME_TYPE_MAPPINGS.put("tar", "application/x-tar");
 		MIME_TYPE_MAPPINGS.put("tcl", "application/x-tcl");
 		MIME_TYPE_MAPPINGS.put("tex", "application/x-tex");
 		MIME_TYPE_MAPPINGS.put("texi", "application/x-texinfo");
 		MIME_TYPE_MAPPINGS.put("texinfo", "application/x-texinfo");
 		MIME_TYPE_MAPPINGS.put("tif", "image/tiff");
 		MIME_TYPE_MAPPINGS.put("tiff", "image/tiff");
 		MIME_TYPE_MAPPINGS.put("tr", "application/x-troff");
 		MIME_TYPE_MAPPINGS.put("tsv", "text/tab-separated-values");
 		MIME_TYPE_MAPPINGS.put("txt", "text/plain");
 		MIME_TYPE_MAPPINGS.put("ulw", "audio/basic");
 		MIME_TYPE_MAPPINGS.put("ustar", "application/x-ustar");
 		MIME_TYPE_MAPPINGS.put("xbm", "image/x-xbitmap");
 		MIME_TYPE_MAPPINGS.put("xml", "text/xml");
 		MIME_TYPE_MAPPINGS.put("xpm", "image/x-xpixmap");
 		MIME_TYPE_MAPPINGS.put("xsl", "text/xml");
 		MIME_TYPE_MAPPINGS.put("xsd", "text/xml");
 		MIME_TYPE_MAPPINGS.put("rng", "text/xml");
 		MIME_TYPE_MAPPINGS.put("xwd", "image/x-xwindowdump");
 		MIME_TYPE_MAPPINGS.put("wav", "audio/x-wav");
 		MIME_TYPE_MAPPINGS.put("svg", "image/svg+xml");
 		MIME_TYPE_MAPPINGS.put("svgz", "image/svg+xml");
 		MIME_TYPE_MAPPINGS.put("wbmp", "image/vnd.wap.wbmp");
 		MIME_TYPE_MAPPINGS.put("wml", "text/vnd.wap.wml");
 		MIME_TYPE_MAPPINGS.put("wmlc", "application/vnd.wap.wmlc");
 		MIME_TYPE_MAPPINGS.put("wmls", "text/vnd.wap.wmlscript");
 		MIME_TYPE_MAPPINGS.put("wmlscriptc", "application/vnd.wap.wmlscriptc");
 		MIME_TYPE_MAPPINGS.put("wrl", "x-world/x-vrml");
 		MIME_TYPE_MAPPINGS.put("Z", "application/x-compress");
 		MIME_TYPE_MAPPINGS.put("z", "application/x-compress");
 		MIME_TYPE_MAPPINGS.put("zip", "application/zip");
 		MIME_TYPE_MAPPINGS = Collections.unmodifiableMap(MIME_TYPE_MAPPINGS);
 	}
 
 	/***
 	 * The Javascript resources cache, used for binrary resources or when client
 	 * does not support a GZIPed response
 	 */
 	protected static Map<String, byte[]> cache = new ConcurrentHashMap<String, byte[]>();
 
 	/***
 	 * The Javascript GZIPed resources cache, used for non-binary resources when
 	 * client supports it
 	 */
 	protected static Map<String, byte[]> gzipedCache = new ConcurrentHashMap<String, byte[]>();
 
 	/***
 	 * <code>init-param</code> accepting a whitespace-seperated list of
 	 * allowed file extentions. The default value is js png jpg gif txt html htm
 	 * xml xsl xslt svg svgz swf initialization parameter.
 	 */
 	protected Set<String> allowedExtentions;
 
 	/***
 	 * <code>init-param</code> for the filter's base mapping path.
 	 * <strong>Must</strong> be the same as the <code>url-pattern</code>
 	 * mapping for the filter, e.g. /lib/js
 	 */
 	protected String basePath = "/lib/js";
 
 	/***
 	 * <code>init-param</code> to control whether to send an HTTP 404 ("not
 	 * found") code or let go of the filter chain to the application in case the
 	 * requested resource cannot be found. Possible values are {true, false} The
 	 * default behaviour is to send a 404 (true)
 	 */
 	protected boolean send404 = true;
 
 	/***
 	 * <code>init-param</code> to control the value used for the Cache-Control
 	 * HTTP header. Default is max-age=86400
 	 */
 	private String cacheControl = "max-age=86400";
 
 	/***
 	 * <code>init-param</code> to control whether to send textual GZIPed
 	 * textual content to increase HTTP performance. Possible values are {true,
 	 * false} The default true
 	 */
 	protected boolean enableGzip = true;
 
 	/***
 	 * <code>init-param</code> to control whether GZIPed resources are cached
 	 * to avoid compression overhead every time they are requested. Default is true.
 	 */
 	private boolean enableGzipCache = true;
 
 	/***
 	 * <code>init-param</code> to control whether resources are cached to
 	 * avoid I/O overhead every time they are requested. Default is true.
 	 */
 	private boolean enableCache = true;
 
 	/***
 	 * Get the MIME type for the given file extention
 	 * 
 	 * @param extention
 	 *            The file extention
 	 * @return The MIME type for the file extention if permitted/known possible.
 	 */
 	protected String getMimeTypeFromFileExtention(String extention) {
 		String mimeType = null;
 		if (extention != null) {
 			mimeType = MIME_TYPE_MAPPINGS.get(extention);
 		}
 		return mimeType;
 	}
 
 	/***
 	 * Get the file extention of the given filename or path.
 	 * 
 	 * @param resourcePath
 	 * @return the extention or <code>null</code>
 	 */
 	private String getFileExtention(String resourcePath) {
 		String extention = null;
 		if (resourcePath != null) {
 			int extensionIndex = resourcePath.lastIndexOf('.');
 			if (extensionIndex != -1
 					&& extensionIndex + 1 < resourcePath.length()) {
 				extention = resourcePath.substring(extensionIndex + 1);
 			}
 		}
 		return extention;
 	}
 
 	/***
 	 * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest,
 	 *      javax.servlet.ServletResponse, javax.servlet.FilterChain)
 	 */
 	public void doFilter(ServletRequest request, ServletResponse response,
 			FilterChain chain) throws IOException, ServletException {
 		HttpServletRequest req = (HttpServletRequest) request;
 		HttpServletResponse res = (HttpServletResponse) response;
 		// only HTTP GET and HEAD for now, sorry :-)
 		String httpMethod = req.getMethod().toUpperCase();
 		if (!(httpMethod.equalsIgnoreCase("GET") || httpMethod.equalsIgnoreCase("HEAD"))) {
 			// send a Non implemented
             if(log.isDebugEnabled()){
                 log.debug("Sent 501: Non Implemented for method: "+httpMethod+", on resource:"+req.getRequestURI() + ", remote host: " +req.getRemoteHost());
             }
 			res.sendError(501);
 		} else {
 			String requestURI = req.getRequestURI();
 			String resourcePath = this.getResourcePath(requestURI);
 			String fileExtention = this.getFileExtention(resourcePath);
 			String mimeType = this.getMimeTypeFromFileExtention(fileExtention);
 			boolean isText = this.getMimeTypeFromFileExtention(fileExtention)
 					.startsWith("text/");
 			boolean sendGziped = false;
 			String ae = req.getHeader("accept-encoding");
 			if (this.enableGzip && isText && ae != null && ae.indexOf("gzip") != -1) {
 				sendGziped = true;
 			}
 			// is the resource allowed?
 			if (this.allowedExtentions.contains(fileExtention.toLowerCase())
 					&& resourcePath.indexOf("META-INF") == -1) {
 				byte[] resourceData = null;
 				if (sendGziped) {
 					resourceData = this.getResourceGziped(resourcePath);
 				}
 				else{
 					resourceData = this.getResource(resourcePath);
 				}
 				// write resource in response
 				if (resourceData != null) {
 					res.setHeader("Cache-Control", this.cacheControl);
 					if (mimeType != null) {
 						res.setContentType(mimeType);
 					}
 					if(sendGziped){
 						res.addHeader("Content-Encoding", "gzip");
 					}
 					res.setContentLength(resourceData.length);
 					ServletOutputStream out = response.getOutputStream();
 					// only write a response body for HTTP GET
 					if (httpMethod.equalsIgnoreCase("GET")) {
                         if(log.isDebugEnabled()){
                             log.debug("Writing resource to response stream, size: "+resourceData.length);
                         }
 						out.write(resourceData);
 					}
 					out.flush();
 					out.close();
 				} else {
 					if (this.send404) {
                         log.warn("Sending 404: Not found, for method: "+httpMethod+", on resource:"+req.getRequestURI() + ", remote host: " +req.getRemoteHost());
 						res.sendError(404);
 					} else {
 						chain.doFilter(request, response);
 					}
 				}
 			} else {
 				// Not allowed, send a 403 Forbidden:
                 log.warn("Sending 501: Forbidden for method: "+httpMethod+", on resource with disallowed extention:"+req.getRequestURI() + ", remote host: " +req.getRemoteHost());
 				((HttpServletResponse) response).sendError(403);
 			}
 		}
 	}
 
 	/***
 	 * Obtain the requsted resource bytes if a match is found in the classpath
 	 * or <code>null</code> otherwise. This method will try to use the caches
 	 * or update them if enabled.
 	 * 
 	 * @param resourcePath
 	 *            the path to match in the classpath
 	 * @return the requsted resource bytes or <code>null</code> if no match is
 	 *         found.
 	 * @throws IOException
 	 */
 	private byte[] getResource(String resourcePath) throws IOException {
 		byte[] resource = null;
 		// load from gzipedCache if enabled and available
 		if (this.enableCache && cache.containsKey(resourcePath)) {
 			resource = cache.get(resourcePath);
             if(log.isDebugEnabled()){
                 log.debug("Resource "+resourcePath+" was loaded from the non-GZIPed cache, size: "+resource.length);
             }
 		} else {
 			// load from classpath
 			resource = ClasspathResourceUtils
 					.getResourceBytesOrNull(resourcePath);
             if(log.isDebugEnabled()){
                 log.debug("Resource "+resourcePath+" was loaded from the classpath, size: "+resource.length);
             }
 			// add a clone to the gzipped cache if enabled
 			if (this.enableCache) {
 				cache.put(resourcePath, resource.clone());
                 if(log.isDebugEnabled()){
                     log.debug("Resource "+resourcePath+" was added to (non-GZIPed) cache, size: "+resource.length);
                 }
 			}
 			// add to normal cache if enabled
 			if (this.enableGzipCache) {
 				gzipedCache.put(resourcePath, resource != null ? this
 						.toGzipedBytes(resource.clone()) : resource);
                 if(log.isDebugEnabled()){
                     log.debug("Resource "+resourcePath+" was added to the GZIP cache");
                 }
 			}
 		}
 		return resource;
 	}
 
 	/***
 	 * Obtain the GZIPed resource bytes if a match is found in the classpath or
 	 * <code>null</code> otherwise. This method will try to use the caches or
 	 * update them if enabled.
 	 * 
 	 * @param resourcePath
 	 *            the path to match in the classpath
 	 * @return the requsted resource bytes or <code>null</code> if no match is
 	 *         found.
 	 * @throws IOException
 	 */
 	private byte[] getResourceGziped(String resourcePath) throws IOException{
 			byte[] resource = null;
 			// load from gzipedCache if enabled and available
 			if(this.enableGzipCache && gzipedCache.containsKey(resourcePath)){
 				resource = gzipedCache.get(resourcePath);
                 if(log.isDebugEnabled()){
                     log.debug("Resource "+resourcePath+" was loaded from the GZIP cache, size: "+resource.length);
                 }
 			}
 			else{
 				// load from normal cache if enabled and available
 				if(this.enableCache && cache.containsKey(resourcePath)){
 					resource = this.toGzipedBytes(cache.get(resourcePath));
 				}
 				else{
 					// load from classpath
 					resource = ClasspathResourceUtils.getResourceBytesOrNull(resourcePath);
                     if(log.isDebugEnabled()){
                         log.debug("Resource "+resourcePath+" was loaded from the classpath, size: "+resource.length);
                     }
 					// add a clone to un-gzipped cache if enabled
 					if(this.enableCache){
 						 cache.put(resourcePath, resource.clone());
                          if(log.isDebugEnabled()){
                                 log.debug("Resource "+resourcePath+" was added to (non-GZIPed) cache, size: "+resource.length);
                             }
 					}
 					
 					// gzip
 					resource = this.toGzipedBytes(resource);
                     if(log.isDebugEnabled()){
                         log.debug("Resource "+resourcePath+" was GZIPed, size: "+resource.length);
                     }
 				}
 				// add to gzipedCache if enabled
 				if(this.enableGzipCache){
 					gzipedCache.put(resourcePath, resource);
                     if(log.isDebugEnabled()){
                         log.debug("Resource "+resourcePath+" was added to the GZIP cache, size: "+resource.length);
                     }
 				}
 			}
 			return resource;
 		}
 
 	/***
 	 * Construct the resource path based on the request information
 	 * 
 	 * @param request
 	 * @return
 	 * @throws ServletException
 	 */
 	private String getResourcePath(String requestURI) throws ServletException {
 		int basePathIndex = requestURI.indexOf(this.basePath);
 		if (basePathIndex == -1) {
 			throw new ServletException(
 					"The value of the basePath init-parameter is incompatible with the filter mapping");
 		}
 		String resPath = requestURI.substring(basePathIndex
 				+ this.basePath.length());
 		// we need to look for "package/name/resource"
 		// instead of "/package/name/resource"
 		if (resPath.startsWith("/")) {
 			resPath = resPath.substring(1);
 		}
 		log.info("Resource path: " + resPath);
 		return resPath;
 	}
 
 	/***
 	 * Get a GZIPed version of the given data (those are kept intact)
 	 * 
 	 * @param data
 	 *            the given data to GZIP
 	 * @return a GZIPed version of the given data or <code>null</code> if the
 	 *         given data are also <code>null</code> or empty
 	 * @throws IOException
 	 */
 	private byte[] toGzipedBytes(byte[] data) throws IOException {
 		byte[] results = null;
 		if (data != null) {
 			ByteArrayOutputStream baos = new ByteArrayOutputStream();
 			GZIPOutputStream out = new GZIPOutputStream(baos);
 			out.write(data, 0, data.length);
 			out.finish();
 			out.close();
 			results = baos.toByteArray();
 			if (log.isDebugEnabled()) {
 				log.debug("Compressed from " + data.length + " to "
 						+ results.length + " bytes");
 			}
 		}
 		return results;
 	}
 
 	/***
 	 * Initialize and configure based on any init parameters available
 	 * 
 	 * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
 	 */
 	public void init(FilterConfig filterConfig) throws ServletException {
 		// configure cache control
 		String _cacheControl = filterConfig.getInitParameter("cacheControl");
 		if (_cacheControl != null) {
 			this.cacheControl = _cacheControl;
 		}
 		// configure gzip
 		String _enableGzip = filterConfig.getInitParameter("enableGzip");
 		if (_enableGzip != null) {
 			this.enableGzip = BooleanUtils.toBoolean(_enableGzip);
 		}
 		// configure gzip cache
 		String _enableGzipCache = filterConfig
 				.getInitParameter("enableGzipCache");
 		if (_enableGzipCache != null) {
 			this.enableGzipCache = BooleanUtils.toBoolean(_enableGzipCache);
 		}
 		// configure cache
 		String _enableCache = filterConfig.getInitParameter("enableCache");
 		if (_enableCache != null) {
 			this.enableCache = BooleanUtils.toBoolean(_enableCache);
 		}
 		// configure 404 flag
 		String _send404 = filterConfig.getInitParameter("send404");
 		if (_send404 != null) {
 			this.send404 = BooleanUtils.toBoolean(_send404);
 		}
 		// configure base path
 		String _basePath = filterConfig.getInitParameter("basePath");
 		if (_basePath != null) {
 			this.basePath = _basePath;
 		}
 		while (this.basePath.endsWith("/")) {
 			// remove any trailing slashes
 			this.basePath = this.basePath.substring(0,
 					this.basePath.length() - 1);
 		}
 		if (this.basePath == null || this.basePath.length() == 0) {
 			throw new ServletException(
 					"Invalid value for init-param basePath: " + _basePath);
 		}
 		this.basePath = _basePath;
 		// configure allowed file extentions
 		String allowedExt = filterConfig.getInitParameter("allowedExtentions");
 		if (allowedExt == null) {
 			allowedExt = "js png jpg gif txt html htm xml xsl xslt svg svgz swf";
 		}
 		String[] allowedArray = allowedExt.replaceAll("//s{2,}", " ").trim()
 				.split(" ");
 		this.allowedExtentions = new HashSet<String>();
 		for (int i = 0; i < allowedArray.length; i++) {
 			this.allowedExtentions.add(allowedArray[i].toLowerCase());
 		}
 		log.info("Configured JavascriptDependencyFilter with send404: "
 				+ this.send404 + ", basePath: " + this.basePath
 				+ ", cacheControl: " + this.cacheControl + ", enableGzip: "
 				+ this.enableGzip + ", enableGzipCache: "
 				+ this.enableGzipCache + ", enableCache: " + this.enableCache
 				+ ", allowedExtentions: " + allowedExt);
 	}
 
 	/***
 	 * Clean up by doing nothing :-)
 	 * 
 	 * @see javax.servlet.Filter#destroy()
 	 */
 	public void destroy() {
 		// do nothing
 	}
 }