/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * 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 org.springframework.extensions.webscripts.servlet.mvc;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.servlet.RequestDispatcher;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.core.io.Resource;
  import org.springframework.util.ClassUtils;
  import org.springframework.web.context.support.ServletContextResource;
  import org.springframework.web.servlet.HandlerMapping;
  import org.springframework.web.servlet.ModelAndView;
  import org.springframework.web.servlet.mvc.AbstractController;
  
  /**
   * Default Spring controller for retrieving and serving resources.
   * 
   * This controller retrieves content by interrogating resource providers
   * in the following order:
   * 
   * 1) Web application path
   * 2) Web application context resources (classpath)
   * 3) Delegation to a default url handler
   * 
   * The following URL format is supported:
   * 
   *    /resource/<path>
   *
   * @author muzquiano
   */
  public class ResourceController extends AbstractController
  {
      private static Log logger = LogFactory.getLog(ResourceController.class);
      
      private static final String HTTP_CONTENT_LENGTH_HEADER = "Content-Length";
      private static final String HTTP_LAST_MODIFIED_HEADER = "Last-Modified";
      private static final String HTTP_EXPIRES_HEADER = "Expires";
      private static final String HTTP_CACHE_CONTROL_HEADER = "Cache-Control";
      
      private static int BUFFER_SIZE = 1024;
          
      private Map<String, String> defaultMimeTypes = new HashMap<String, String>();
      {
          defaultMimeTypes.put(".css", "text/css");
          defaultMimeTypes.put(".gif", "image/gif");
          defaultMimeTypes.put(".ico", "image/vnd.microsoft.icon");
          defaultMimeTypes.put(".jpeg", "image/jpeg");
          defaultMimeTypes.put(".jpg", "image/jpeg");
          defaultMimeTypes.put(".js", "text/javascript");
          defaultMimeTypes.put(".png", "image/png");
      }
      
      // allow for a default redirection url to be provided
      private String defaultUrl;
          
      /**
       * Sets the default url.
       * 
       * @param defaultUrl the new default url
       */
      public void setDefaultUrl(String defaultUrl)
      {
          this.defaultUrl = defaultUrl;
      }
      
      /**
       * Gets the default url.
       * 
       * @return the default url
       */
      public String getDefaultUrl()
     {
         return this.defaultUrl;
     }
 
     /* (non-Javadoc)
      * @see org.alfresco.web.framework.mvc.AbstractWebFrameworkController#getLogger()
      */
     public Log getLogger()
     {
         return logger;        
     }
     
     /* (non-Javadoc)
      * @see org.alfresco.web.framework.mvc.AbstractController#createModelAndView(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
      */
     public ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)
         throws Exception
     {
         // get the path to the resource (resolved by Spring for us)
         String path = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
         
         dispatchResource(path, request, response);
         
         return null;
     }
     
     /**
      * Dispatches to the resource with the given path
      * 
      * @param path the path
      * @param request the request
      * @param response the response
      * 
      * @return true, if the dispatch succeeded
      */
     public boolean dispatchResource(String path, HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException
     {
         boolean resolved = false;
         
         // serve back the resource from the web application (if it exists)
         ServletContextResource resource = new ServletContextResource(getServletContext(), "/" + path);
         if (resource.exists())
         {
             // dispatch to resource
             RequestDispatcher rd = this.getServletContext().getRequestDispatcher("/" + path);
             rd.include(request, response);
             
             resolved = true;
         }
         
         if (!resolved)
         {
             // look up the resource in the resource provider
             // (application context resources / classpath)
             
             // check the class path
             Resource r = getApplicationContext().getResource("classpath*:" + path);
             if (r != null && r.exists())
             {
                 URL resourceUrl = r.getURL();
                 
                 // attempt to stream this back
                 try
                 {
                     commitResponse(resourceUrl, response);
                     resolved = true;
                 }
                 catch (IOException ioe)
                 {
                     ioe.printStackTrace();
                 }
             }
         }
 
         if (!resolved)
         {
             // check JAR files
             URL resourceUrl = ClassUtils.getDefaultClassLoader().getResource("META-INF/" + path);
             if (resourceUrl != null)
             {
                 // attempt to stream this back
                 try
                 {
                     commitResponse(resourceUrl, response);
                     resolved = true;
                 }
                 catch (IOException ioe)
                 {
                     ioe.printStackTrace();
                     // TODO: silent fail
                 }
             }
         }            
         
         if (!resolved && defaultUrl != null)
         {
             // try to hand off to a default servlet context (compatibility with Spring JS resource servlet)
             // use a forward here because the new servlet context may be different than the current servlet context 
             RequestDispatcher rd = this.getServletContext().getRequestDispatcher(defaultUrl + "/" + path);
             rd.forward(request, response);
             
             resolved = true;            
         }
         
         return resolved;
     }
     
     public void commitResponse(URL resourceUrl, HttpServletResponse response)
         throws IOException
     {
         long lastModified = -1;
         
         // determine properties of the resource being served back
         URLConnection resourceConn = resourceUrl.openConnection();
         if (resourceConn.getLastModified() > lastModified)
         {
             lastModified = resourceConn.getLastModified();
         }
         String mimetype = getServletContext().getMimeType(resourceUrl.getPath());
         if (mimetype == null) 
         {
             String extension = resourceUrl.getPath().substring(resourceUrl.getPath().lastIndexOf('.'));
             mimetype = (String) defaultMimeTypes.get(extension);
         }
         int contentLength = resourceConn.getContentLength();
     
         // set response headers
         response.setContentType(mimetype);
         response.setHeader(HTTP_CONTENT_LENGTH_HEADER, Long.toString(contentLength));
         response.setDateHeader(HTTP_LAST_MODIFIED_HEADER, lastModified);
 
         // stream back to response
         copyStream(resourceUrl.openStream(), response.getOutputStream(), true);
     }
     
     /**
      * Copy stream.
      * 
      * @param in
      *            the in
      * @param out
      *            the out
      * @param closeStreams
      *            the close streams
      * 
      * @return the int
      * 
      * @throws IOException
      *             Signals that an I/O exception has occurred.
      */
     public static int copyStream(final InputStream in, final OutputStream out, final boolean closeStreams)
         throws IOException
     {
         try
         {
             int byteCount = 0;
             final byte[] buffer = new byte[BUFFER_SIZE];
             int bytesRead = -1;
             while ((bytesRead = in.read(buffer)) != -1)
             {
                 out.write(buffer, 0, bytesRead);
                 byteCount += bytesRead;
             }
             out.flush();
             return byteCount;
         }
         finally
         {
             if (closeStreams)
             {
                 try
                 {
                     in.close();
                 }
                 catch (IOException ex)
                 {
                 }
                 try
                 {
                     out.close();
                 }
                 catch (IOException ex)
                 {
                 }
             }
         }
     }
     
 }