/*
 * This library is part of OpenCms -
 * the Open Source Content Management System
 *
 * Copyright (c) Alkacon Software GmbH & Co. KG (http://www.alkacon.com)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * For further information about Alkacon Software, please see the
 * company website: http://www.alkacon.com
 *
 * For further information about OpenCms, please see the
 * project website: http://www.opencms.org
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package org.opencms.main;

import org.opencms.util.CmsStringUtil;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;

/**
 * Handles the requests for static resources located in the classpath.<p>
 */
public class CmsStaticResourceHandler implements I_CmsRequestHandler {

    /** The handler name. */
    public static final String HANDLER_NAME = "Static";

    /** The static resource prefix '/handleStatic'. */
    public static final String STATIC_RESOURCE_PREFIX = OpenCmsServlet.HANDLE_PATH + HANDLER_NAME;

    /** The default output buffer size. */
    private static final int DEFAULT_BUFFER_SIZE = 32 * 1024;

    /** Default cache lifetime in seconds. */
    private static final int DEFAULT_CACHE_TIME = 3600;

    /** The handler names. */
    private static final String[] HANDLER_NAMES = new String[] {HANDLER_NAME};

    /** The log object for this class. */
    private static final Log LOG = CmsLog.getLog(CmsStaticResourceHandler.class);

    /** The regular expression to remove the static resource path prefix. */
    private static String m_removePrefixRegex;

    /** The regular expression to identify static resource paths. */
    private static String m_staticResourceRegex;

    /** The opencms path prefix for static resources. */
    private static final String OPENCMS_PATH_PREFIX = "OPENCMS/";

    /**
     * Returns the context for static resources served from the class path, e.g. "/opencms/handleStatic/v5976v".<p>
     *
     * @param opencmsContext the OpenCms context
     * @param opencmsVersion the OpenCms version
     *
     * @return the static resource context
     */
    public static String getStaticResourceContext(String opencmsContext, String opencmsVersion) {

        return opencmsContext + STATIC_RESOURCE_PREFIX + "/v" + opencmsVersion.hashCode() + "v";
    }

    /**
     * Returns the URL to a static resource.<p>
     *
     * @param resourcePath the static resource path
     *
     * @return the resource URL
     */
    public static URL getStaticResourceURL(String resourcePath) {

        URL resourceURL = null;
        if (isStaticResourceUri(resourcePath)) {
            String path = removeStaticResourcePrefix(resourcePath);
            path = CmsStringUtil.joinPaths(OPENCMS_PATH_PREFIX, path);
            resourceURL = OpenCms.getSystemInfo().getClass().getClassLoader().getResource(path);
        }
        return resourceURL;
    }

    /**
     * Returns if the given URI points to a static resource.<p>
     *
     * @param path the path to test
     *
     * @return <code>true</code> in case the given URI points to a static resource
     */
    public static boolean isStaticResourceUri(String path) {

        return (path != null) && path.matches(getStaticResourceRegex());

    }

    /**
     * Returns if the given URI points to a static resource.<p>
     *
     * @param uri the URI to test
     *
     * @return <code>true</code> in case the given URI points to a static resource
     */
    public static boolean isStaticResourceUri(URI uri) {

        return (uri != null) && isStaticResourceUri(uri.getPath());

    }

    /**
     * Removes the static resource path prefix.<p>
     *
     * @param path the path
     *
     * @return the modified path
     */
    public static String removeStaticResourcePrefix(String path) {

        return path.replaceFirst(getRemovePrefixRegex(), "");
    }

    /**
     * Returns the regular expression to remove the static resource path prefix.<p>
     *
     * @return the regular expression to remove the static resource path prefix
     */
    private static String getRemovePrefixRegex() {

        if (m_removePrefixRegex == null) {
            m_removePrefixRegex = "^("
                + OpenCms.getStaticExportManager().getVfsPrefix()
                + ")?"
                + STATIC_RESOURCE_PREFIX
                + "(/v-?\\d+v/)?";
        }
        return m_removePrefixRegex;
    }

    /**
     * Returns the regular expression to identify static resource paths.<p>
     *
     * @return the regular expression to identify static resource paths
     */
    private static String getStaticResourceRegex() {

        if (m_staticResourceRegex == null) {
            m_staticResourceRegex = getRemovePrefixRegex() + ".*";
        }
        return m_staticResourceRegex;
    }

    /**
     * @see org.opencms.main.I_CmsRequestHandler#getHandlerNames()
     */
    public String[] getHandlerNames() {

        return HANDLER_NAMES;
    }

    /**
     * @see org.opencms.main.I_CmsRequestHandler#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
     */
    public void handle(HttpServletRequest request, HttpServletResponse response, String name) throws IOException {

        String path = OpenCmsCore.getInstance().getPathInfo(request);
        URL resourceURL = getStaticResourceURL(path);
        if (resourceURL != null) {
            setResponseHeaders(request, response, path, resourceURL);
            writeStaticResourceResponse(request, response, resourceURL);
        } else {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        }
    }

    /**
     * Returns whether this servlet should attempt to serve a precompressed
     * version of the given static resource. If this method returns true, the
     * suffix {@code .gz} is appended to the URL and the corresponding resource
     * is served if it exists. It is assumed that the compression method used is
     * gzip. If this method returns false or a compressed version is not found,
     * the original URL is used.<p>
     *
     * The base implementation of this method returns true if and only if the
     * request indicates that the client accepts gzip compressed responses and
     * the filename extension of the requested resource is .js, .css, or .html.<p>
     *
     * @param request the request for the resource
     * @param url the URL of the requested resource
     *
     * @return true if the servlet should attempt to serve a precompressed version of the resource, false otherwise
     */
    protected boolean allowServePrecompressedResource(HttpServletRequest request, String url) {

        String accept = request.getHeader("Accept-Encoding");
        return (accept != null)
            && accept.contains("gzip")
            && (url.endsWith(".js") || url.endsWith(".css") || url.endsWith(".html"));
    }

    /**
     * Calculates the cache lifetime for the given filename in seconds. By
     * default filenames containing ".nocache." return 0, filenames containing
     * ".cache." return one year, all other return the value defined in the
     * web.xml using resourceCacheTime (defaults to 1 hour).<p>
     *
     * @param filename the file name
     *
     * @return cache lifetime for the given filename in seconds
     */
    protected int getCacheTime(String filename) {

        /*
         * GWT conventions:
         *
         * - files containing .nocache. will not be cached.
         *
         * - files containing .cache. will be cached for one year.
         *
         * https://developers.google.com/web-toolkit/doc/latest/
         * DevGuideCompilingAndDebugging#perfect_caching
         */
        if (filename.contains(".nocache.")) {
            return 0;
        }
        if (filename.contains(".cache.")) {
            return 60 * 60 * 24 * 365;
        }
        /*
         * For all other files, the browser is allowed to cache for 1 hour
         * without checking if the file has changed. This forces browsers to
         * fetch a new version when the Vaadin version is updated. This will
         * cause more requests to the servlet than without this but for high
         * volume sites the static files should never be served through the
         * servlet.
         */
        return DEFAULT_CACHE_TIME;
    }

    /**
     * Sets the response headers.<p>
     *
     * @param request the request
     * @param response the response
     * @param filename the file name
     * @param resourceURL the resource URL
     */
    protected void setResponseHeaders(
        HttpServletRequest request,
        HttpServletResponse response,
        String filename,
        URL resourceURL) {

        String cacheControl = "public, max-age=0, must-revalidate";
        int resourceCacheTime = getCacheTime(filename);
        if (resourceCacheTime > 0) {
            cacheControl = "max-age=" + String.valueOf(resourceCacheTime);
        }
        response.setHeader("Cache-Control", cacheControl);
        response.setDateHeader("Expires", System.currentTimeMillis() + (resourceCacheTime * 1000));

        // Find the modification timestamp
        long lastModifiedTime = 0;
        URLConnection connection = null;
        try {
            connection = resourceURL.openConnection();
            lastModifiedTime = connection.getLastModified();
            // Remove milliseconds to avoid comparison problems (milliseconds
            // are not returned by the browser in the "If-Modified-Since"
            // header).
            lastModifiedTime = lastModifiedTime - (lastModifiedTime % 1000);
            response.setDateHeader("Last-Modified", lastModifiedTime);

            if (browserHasNewestVersion(request, lastModifiedTime)) {
                response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                return;
            }
        } catch (Exception e) {
            // Failed to find out last modified timestamp. Continue without it.
            LOG.debug("Failed to find out last modified timestamp. Continuing without it.", e);
        } finally {
            try {
                if (connection != null) {
                    // Explicitly close the input stream to prevent it
                    // from remaining hanging
                    // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4257700
                    InputStream is = connection.getInputStream();
                    if (is != null) {
                        is.close();
                    }
                }
            } catch (Exception e) {
                LOG.info("Error closing URLConnection input stream", e);
            }
        }

        // Set type mime type if we can determine it based on the filename
        String mimetype = OpenCms.getResourceManager().getMimeType(filename, "UTF-8");
        if (mimetype != null) {
            response.setContentType(mimetype);
        }
    }

    /**
     * Writes the contents of the given resourceUrl in the response. Can be
     * overridden to add/modify response headers and similar.<p>
     *
     * @param request the request for the resource
     * @param response the response
     * @param resourceUrl the url to send
     *
     * @throws IOException in case writing the response fails
     */
    protected void writeStaticResourceResponse(
        HttpServletRequest request,
        HttpServletResponse response,
        URL resourceUrl)
    throws IOException {

        URLConnection connection = null;
        InputStream is = null;
        String urlStr = resourceUrl.toExternalForm();
        try {
            if (allowServePrecompressedResource(request, urlStr)) {
                // try to serve a precompressed version if available
                try {
                    connection = new URL(urlStr + ".gz").openConnection();
                    is = connection.getInputStream();
                    // set gzip headers
                    response.setHeader("Content-Encoding", "gzip");
                } catch (Exception e) {
                    LOG.debug("Unexpected exception looking for gzipped version of resource " + urlStr, e);
                }
            }
            if (is == null) {
                // precompressed resource not available, get non compressed
                connection = resourceUrl.openConnection();
                try {
                    is = connection.getInputStream();
                } catch (FileNotFoundException e) {
                    LOG.debug(e.getMessage(), e);
                    response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                    return;
                }
            }

            try {
                @SuppressWarnings("null")
                int length = connection.getContentLength();
                if (length >= 0) {
                    response.setContentLength(length);
                }
            } catch (Throwable e) {
                LOG.debug(e.getMessage(), e);
                // This can be ignored, content length header is not required.
                // Need to close the input stream because of
                // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4257700 to
                // prevent it from hanging, but that is done below.
            }

            streamContent(response, is);
        } finally {
            if (is != null) {
                is.close();
            }
        }
    }

    /**
     * Checks if the browser has an up to date cached version of requested
     * resource. Currently the check is performed using the "If-Modified-Since"
     * header. Could be expanded if needed.<p>
     *
     * @param request the HttpServletRequest from the browser
     * @param resourceLastModifiedTimestamp the timestamp when the resource was last modified. 0 if the last modification time is unknown
     *
     * @return true if the If-Modified-Since header tells the cached version in the browser is up to date, false otherwise
     */
    private boolean browserHasNewestVersion(HttpServletRequest request, long resourceLastModifiedTimestamp) {

        if (resourceLastModifiedTimestamp < 1) {
            // We do not know when it was modified so the browser cannot have an
            // up-to-date version
            return false;
        }
        /*
         * The browser can request the resource conditionally using an
         * If-Modified-Since header. Check this against the last modification
         * time.
         */
        try {
            // If-Modified-Since represents the timestamp of the version cached
            // in the browser
            long headerIfModifiedSince = request.getDateHeader("If-Modified-Since");

            if (headerIfModifiedSince >= resourceLastModifiedTimestamp) {
                // Browser has this an up-to-date version of the resource
                return true;
            }
        } catch (Exception e) {
            // Failed to parse header. Fail silently - the browser does not have
            // an up-to-date version in its cache.
        }
        return false;
    }

    /**
     * Streams the input stream to the response.<p>
     *
     * @param response the response
     * @param is the input stream
     *
     * @throws IOException in case writing to the response fails
     */
    private void streamContent(HttpServletResponse response, InputStream is) throws IOException {

        OutputStream os = response.getOutputStream();
        try {
            byte buffer[] = new byte[DEFAULT_BUFFER_SIZE];
            int bytes;
            while ((bytes = is.read(buffer)) >= 0) {
                os.write(buffer, 0, bytes);
            }
        } finally {
            os.close();
        }
    }
}