package com.atlassian.plugin.webresource;
   
   import static com.atlassian.plugin.servlet.AbstractFileServerServlet.PATH_SEPARATOR;
   import static com.atlassian.plugin.servlet.AbstractFileServerServlet.SERVLET_PATH;
   import static com.google.common.base.Suppliers.ofInstance;
   import static com.google.common.collect.ImmutableList.copyOf;
   import static com.google.common.collect.Iterables.any;
   
   import com.atlassian.plugin.Plugin;
  import com.atlassian.plugin.servlet.DownloadException;
  import com.atlassian.plugin.servlet.DownloadableResource;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.base.Predicate;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.Iterables;
  
  import java.io.IOException;
  import java.io.OutputStream;
  import java.io.UnsupportedEncodingException;
  import java.net.URLEncoder;
  import java.util.Collections;
  import java.util.Map;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  /**
   * Represents a batch of plugin resources. <p/>
   * <p/>
   * It provides methods to parse and generate urls to locate a batch of plugin resources. <p/>
   * <p/>
   * Note BatchPluginResource is also a type of {@link DownloadableResource}. The underlying implementation simply
   * keeps a list of {@link DownloadableResource} of which this batch represents and delegates method calls.
   *
   * @since 2.2
   */
  public class BatchPluginResource implements DownloadableResource, PluginResource, BatchResource
  {
      private static final Logger log = LoggerFactory.getLogger(BatchPluginResource.class);
  
      private static final ResourceContentAnnotator[] DEFAULT_ANNOTATORS = new ResourceContentAnnotator[] {
          new NewlineResourceContentAnnotator()
      };
  
      private static final ResourceContentAnnotator[] JS_WRAP_ANNOTATORS = new ResourceContentAnnotator[] {
          new NewlineResourceContentAnnotator(), new TryCatchJsResourceContentAnnotator()
      };
  
      /**
       * The url prefix for a batch of plugin resources: "/download/batch/"
       */
      static final String URL_PREFIX = PATH_SEPARATOR + SERVLET_PATH + PATH_SEPARATOR + "batch";
  
      private final ResourceKey resource;
      private final Map<String, String> params;
      private final Iterable<DownloadableResource> resources;
  
      // not thread-safe but a safe race on setting as hash function is referentially transparent
      private int hash = 0;
  
      /**
       * A constructor that creates a default resource name for the batch in the format: moduleCompleteKey.type
       * For example: test.plugin:resources.js
       * <p/>
       * Note that name of the batch does not identify what the batch includes and could have been static e.g. batch.js
       *
       * @param moduleCompleteKey - the key of the plugin module
       * @param type - the type of resource (CSS/JS)
       * @param params - the parameters of the resource (ieonly, media, etc)
       */
      public BatchPluginResource(final String moduleCompleteKey, final String type, final Map<String, String> params)
      {
          this(ResourceKey.Builder.lazy(moduleCompleteKey, ofInstance(type)), params, Collections.<DownloadableResource>emptyList());
      }
  
      /**
       * A constructor that creates a default resource name for the batch in the format: moduleCompleteKey.type
       * For example: test.plugin:resources.js
       * <p/>
       * This constructor includes the resources that are contained in the batch, and so is primarily for use
       * when serving the resource.
       *
       * @param moduleCompleteKey - the key of the plugin module
       * @param type - the type of resource (CSS/JS)
       * @param params - the parameters of the resource (ieonly, media, etc)
       * @param resources - the resources included in the batch.
       */
      public BatchPluginResource(final String moduleCompleteKey, final String type, final Map<String, String> params,
                                 final Iterable<DownloadableResource> resources)
      {
          this(ResourceKey.Builder.lazy(moduleCompleteKey, ofInstance(type)), params, resources);
      }
  
      /**
       * This constructor should only ever be used internally within this class. It does not ensure that the resourceName's
       * file extension is the same as the given type. It is up to the calling code to ensure this.
      *
      * @param resource - the resource key
      * @param params - the parameters of the resource (ieonly, media, etc)
      * @param resources - the resources included in the batch.
      */
     BatchPluginResource(final ResourceKey resource, final Map<String, String> params,
                         final Iterable<DownloadableResource> resources)
     {
         this.resource = resource;
         this.params = ImmutableMap.copyOf(params);
         this.resources = copyOf(resources);
     }
 
     /**
      * @return true if there are no resources included in this batch
      */
     public boolean isEmpty()
     {
         return Iterables.isEmpty(resources);
     }
 
     public boolean isResourceModified(final HttpServletRequest request, final HttpServletResponse response)
     {
         return any(resources, new Predicate<DownloadableResource>()
         {
             public boolean apply(final DownloadableResource resource)
             {
                 return resource.isResourceModified(request, response);
             }
         });
     }
 
     public void serveResource(final HttpServletRequest request, final HttpServletResponse response)
         throws DownloadException
     {
         if (log.isDebugEnabled())
         {
             log.debug("Start to serve batch " + toString());
         }
 
         ResourceContentAnnotator[] annotators = getAnnotators(request);
         for (final DownloadableResource resource : resources)
         {
             try
             {
                 applyBeforeAnnotators(response.getOutputStream(), annotators);
                 resource.serveResource(request, response);
                 applyAfterAnnotators(response.getOutputStream(), annotators);
             }
             catch (IOException ex)
             {
                 throw new DownloadException(ex);
             }
         }
     }
 
     public void streamResource(final OutputStream out) throws DownloadException
     {
         ResourceContentAnnotator[] annotators = getAnnotators(null);
 
         for (final DownloadableResource resource : resources)
         {
             try
             {
                 applyBeforeAnnotators(out, annotators);
                 resource.streamResource(out);
                 applyAfterAnnotators(out, annotators);
             }
             catch (IOException ex)
             {
                 throw new DownloadException(ex);
             }
         }
     }
 
     public String getContentType()
     {
         final String contentType = params.get("content-type");
         if (contentType != null)
         {
             return contentType;
         }
         return null;
     }
 
     /**
      * Returns a url string in the format: /download/batch/MODULE_COMPLETE_KEY/resourceName?PARAMS
      * <p/>
      * e.g. /download/batch/example.plugin:webresources/example.plugin:webresources.css?ie=true
      * <p/>
      * It is important for the url structure to be:
      * 1. the same number of sectioned paths as the SinglePluginResource
      * 2. include the module completey key in the path before the resource name
      * This is due to css resources referencing other resources such as images in relative path forms.
      */
     public String getUrl()
     {
         final StringBuilder sb = new StringBuilder();
         sb.append(URL_PREFIX).append(PATH_SEPARATOR).append(resource.key()).append(PATH_SEPARATOR).append(
             resource.name());
         addParamsToUrl(sb, params);
         return sb.toString();
     }
 
     protected void addParamsToUrl(final StringBuilder sb, final Map<String, String> params)
     {
         if (params.size() > 0)
         {
             sb.append("?");
             int count = 0;
 
             for (final Map.Entry<String, String> entry : params.entrySet())
             {
                 try
                 {
                     sb.append(URLEncoder.encode(entry.getKey(), "UTF-8")).append("=").append(URLEncoder.encode(
                         entry.getValue(), "UTF-8"));
 
                     if (++count < params.size())
                     {
                         sb.append("&");
                     }
                 }
                 catch (final UnsupportedEncodingException e)
                 {
                     log.error("Could not encode parameter to url for [" + entry.getKey() + "] with value [" +
                         entry.getValue() + "]", e);
                 }
             }
         }
     }
 
     public String getResourceName()
     {
         return resource.name();
     }
 
     public Map<String, String> getParams()
     {
         return params;
     }
 
     public String getVersion(final WebResourceIntegration integration)
     {
         final Plugin plugin = integration.getPluginAccessor().getEnabledPluginModule(
             getModuleCompleteKey()).getPlugin();
         return plugin.getPluginInformation().getVersion();
     }
 
     public String getModuleCompleteKey()
     {
         return resource.key();
     }
 
     public boolean isCacheSupported()
     {
         return !"false".equals(params.get("cache"));
     }
 
     @Override
     public String getType()
     {
         return resource.suffix();
     }
 
     private void applyBeforeAnnotators(OutputStream str, ResourceContentAnnotator[] annotators) throws IOException
     {
         for (ResourceContentAnnotator annotator : annotators)
         {
             annotator.before(str);
         }
     }
 
     /**
      * Apply the after annotators in reverse order.
      *
      * @param str
      * @throws IOException
      */
     private void applyAfterAnnotators(OutputStream str, ResourceContentAnnotator[] annotators) throws IOException
     {
         for (int i = annotators.length - 1; i >= 0; i--)
         {
             annotators[i].after(str);
         }
     }
 
     @Override
     public boolean equals(final Object o)
     {
         if (this == o)
         {
             return true;
         }
         if ((o == null) || (getClass() != o.getClass()))
         {
             return false;
         }
 
         final BatchPluginResource that = (BatchPluginResource) o;
 
         if (params != null ? !params.equals(that.params) : that.params != null)
         {
             return false;
         }
         return resource.equals(that.resource);
     }
 
     @Override
     public int hashCode()
     {
         if (hash == 0)
         {
             int result;
             result = resource.hashCode();
             result = 31 * result + (params != null ? params.hashCode() : 0);
             hash = result;
         }
         return hash;
     }
 
     @Override
     public String toString()
     {
         return "[moduleCompleteKey=" + resource.key() + ", type=" + resource.suffix() + ", params=" + params + "]";
     }
 
     /**
      * @param request may be null if not available
      * @return the annotators to use when writing the requested Batch resource.
      */
     private ResourceContentAnnotator[] getAnnotators(HttpServletRequest request)
     {
         if (request == null || !"js".equals(this.getType()) || !"true".equals(request.getParameter("trycatchwrap")))
         {
             return DEFAULT_ANNOTATORS;
         }
         else
         {
             return JS_WRAP_ANNOTATORS;
         }
     }
 }