package com.atlassian.plugin.servlet;
   
   import com.atlassian.plugin.Plugin;
   import com.atlassian.plugin.elements.ResourceLocation;
   import com.atlassian.plugin.servlet.util.LastModifiedHandler;
   import com.atlassian.plugin.util.PluginUtils;
   import org.apache.commons.io.IOUtils;
   import org.apache.commons.lang3.StringUtils;
   import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Date;
  
  /**
   * This base class is used to provide the ability to server minified versions of
   * files if required and available.
   *
   * @since 2.2
   */
  abstract class AbstractDownloadableResource implements DownloadableResource {
      private static final Logger log = LoggerFactory.getLogger(AbstractDownloadableResource.class);
  
      /**
       * This is a the system environment variable to set to disable the
       * minification naming strategy used to find web resources.
       */
      private static final String ATLASSIAN_WEBRESOURCE_DISABLE_MINIFICATION = "atlassian.webresource.disable.minification";
  
      /* the following protected fields are marked final since 2.5 */
  
      protected final Plugin plugin;
      protected final String extraPath;
      protected final ResourceLocation resourceLocation;
  
      // PLUG-538 cache this so we don't recreate the string every time it is
      // called
      private final String location;
      private final boolean disableMinification;
  
      public AbstractDownloadableResource(final Plugin plugin, final ResourceLocation resourceLocation, final String extraPath) {
          this(plugin, resourceLocation, extraPath, false);
      }
  
      public AbstractDownloadableResource(final Plugin plugin, final ResourceLocation resourceLocation, String extraPath, final boolean disableMinification) {
          if ((extraPath != null) && !"".equals(extraPath.trim()) && !resourceLocation.getLocation().endsWith("/")) {
              extraPath = "/" + extraPath;
          }
          this.disableMinification = disableMinification;
          this.plugin = plugin;
          this.extraPath = extraPath;
          this.resourceLocation = resourceLocation;
          this.location = resourceLocation.getLocation() + extraPath;
      }
  
      public void serveResource(final HttpServletRequest request, final HttpServletResponse response) throws DownloadException {
          log.debug("Serving: {}", this);
  
          final InputStream resourceStream = getResourceAsStreamViaMinificationStrategy();
          if (resourceStream == null) {
              log.warn("Resource not found: {}", this);
              return;
          }
  
          final String contentType = getContentType();
          if (StringUtils.isNotBlank(contentType)) {
              response.setContentType(contentType);
          }
  
          final OutputStream out;
          try {
              out = response.getOutputStream();
          } catch (final IOException e) {
              throw new DownloadException(e);
          }
  
          streamResource(resourceStream, out);
          log.debug("Serving file done.");
      }
  
      public void streamResource(final OutputStream out) throws DownloadException {
          final InputStream resourceStream = getResourceAsStreamViaMinificationStrategy();
          if (resourceStream == null) {
              log.warn("Resource not found: {}", this);
              return;
          }
  
          streamResource(resourceStream, out);
      }
  
      /**
       * Copy from the supplied OutputStream to the supplied InputStream. Note
       * that the InputStream will be closed on completion.
       *
       * @param in  the stream to read from
      * @param out the stream to write to
      * @throws DownloadException if an IOException is encountered writing to the
      *                           out stream
      */
     private void streamResource(final InputStream in, final OutputStream out) throws DownloadException {
         try {
             IOUtils.copy(in, out);
         } catch (final IOException e) {
             throw new DownloadException(e);
         } finally {
             IOUtils.closeQuietly(in);
             try {
                 out.flush();
             } catch (final IOException e) {
                 log.debug("Error flushing output stream", e);
             }
         }
     }
 
     @Override
     public boolean isResourceModified(final HttpServletRequest httpServletRequest, final HttpServletResponse httpServletResponse) {
         final Date resourceLastModifiedDate = (plugin.getDateLoaded() == null) ? new Date() : plugin.getDateLoaded();
         final LastModifiedHandler lastModifiedHandler = new LastModifiedHandler(resourceLastModifiedDate);
         return !lastModifiedHandler.checkRequest(httpServletRequest, httpServletResponse);
     }
 
     public String getContentType() {
         return resourceLocation.getContentType();
     }
 
     /**
      * Returns an {@link InputStream} to stream the resource from based on
      * resource name.
      *
      * @param resourceLocation the location of the resource to try and load
      * @return an InputStream if the resource can be found or null if cant be
      * found
      */
     protected abstract InputStream getResourceAsStream(String resourceLocation);
 
     /**
      * This is called to return the location of the resource that this object
      * represents.
      *
      * @return the location of the resource that this object represents.
      */
     protected String getLocation() {
         return location;
     }
 
     @Override
     public String toString() {
         final String pluginKey = plugin != null ? plugin.getKey() : "";
         return "Resource: " + pluginKey + " " + getLocation() + " (" + getContentType() + ")";
     }
 
     /**
      * This is called to use a minification naming strategy to find resources.
      * If a minified file cant by found then the base location is used as the
      * fall back
      *
      * @return an InputStream r null if nothing can be found for the resource
      * name
      */
     private InputStream getResourceAsStreamViaMinificationStrategy() {
 
         InputStream inputStream = null;
         final String location = getLocation();
         if (minificationStrategyInPlay(location)) {
             final String minifiedLocation = getMinifiedLocation(location);
             inputStream = getResourceAsStream(minifiedLocation);
         }
         if (inputStream == null) {
             inputStream = getResourceAsStream(location);
         }
         return inputStream;
     }
 
     /**
      * Returns true if the minification strategy should be applied to a given
      * resource name
      *
      * @param resourceLocation the location of the resource
      * @return true if the minification strategy should be used.
      */
     private boolean minificationStrategyInPlay(final String resourceLocation) {
         // check if minification has been turned off for this resource (at the
         // module level)
         if (disableMinification) {
             return false;
         }
 
         // secondly CHECK if we have a System property set to true that DISABLES
         // the minification
         try {
             if (Boolean.getBoolean(ATLASSIAN_WEBRESOURCE_DISABLE_MINIFICATION) || PluginUtils.isAtlassianDevMode()) {
                 return false;
             }
         } catch (final SecurityException se) {
             // some app servers might have protected access to system
             // properties. Unlikely but lets be defensive
         }
         // We only minify .js or .css files
         if (resourceLocation.endsWith(".js")) {
             // Check if it is already the minified version of the file
             return !(resourceLocation.endsWith("-min.js") || resourceLocation.endsWith(".min.js"));
         }
         if (resourceLocation.endsWith(".css")) {
             // Check if it is already the minified version of the file
             return !(resourceLocation.endsWith("-min.css") || resourceLocation.endsWith(".min.css"));
         }
         // Not .js or .css, don't bother trying to find a minified version (may
         // save some file operations)
         return false;
     }
 
     private String getMinifiedLocation(final String location) {
         final int lastDot = location.lastIndexOf(".");
         // this can never but -1 since the method call is protected by a call to
         // minificationStrategyInPlay() first
         return location.substring(0, lastDot) + "-min" + location.substring(lastDot);
     }
 }