/**
    * This file Copyright (c) 2009-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.imaging.caching;
  
  import info.magnolia.cms.beans.config.MIMEMapping;
  import info.magnolia.context.SystemContext;
  import info.magnolia.imaging.AbstractImageStreamer;
  import info.magnolia.imaging.ImageGenerator;
  import info.magnolia.imaging.ImageResponse;
  import info.magnolia.imaging.ImageStreamer;
  import info.magnolia.imaging.ImagingException;
  import info.magnolia.imaging.OutputFormat;
  import info.magnolia.imaging.ParameterProvider;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Calendar;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.ReentrantLock;
  
  import javax.jcr.InvalidItemStateException;
  import javax.jcr.Node;
  import javax.jcr.Property;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.jackrabbit.JcrConstants;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.cache.CacheBuilder;
  import com.google.common.cache.CacheLoader;
  import com.google.common.cache.LoadingCache;
  import com.google.common.net.MediaType;
  
  /**
   * An ImageStreamer which stores and serves generated images to/from a specific workspace.
   *
   * @param <P> type of ParameterProvider's parameter
   */
  public class CachingImageStreamer<P> extends AbstractImageStreamer<P> {
  
      private static final Logger log = LoggerFactory.getLogger(CachingImageStreamer.class);
  
      private static final String GENERATED_IMAGE_NODE_NAME = "generated-image";
  
      private final Session session;
      private final CachingStrategy<P> cachingStrategy;
      private final ImageStreamer<P> delegate;
      private final SystemContext systemContext;
  
      /**
       * This LoadingCache is the key to understanding how this class works.
       * By using a LoadingCache, we are essentially locking all requests
       * coming in for the same image (ImageGenerationJob) except the first one.
       *
       * CacheBuilder.build() returns a LoadingCache implemented as such that the
       * first call to get(K) will generate the value (by calling <V> Function.apply(<K>).
       * Further calls are blocked until the value is generated, and they all retrieve the same value.
       *
       * TODO: make static if we don't use the exact same instance for all threads ?
      */
     private final LoadingCache<ImageGenerationJob<P>, Property> currentJobs;
 
     /**
      * Despite the currentJobs doing quite a good job at avoiding multiple requests
      * for the same job, we still need to lock around JCR operations, otherwise multiple
      * requests end up creating the same cachePath (or parts of it), thus yielding
      * InvalidItemStateException: "Item cannot be saved because it has been modified externally".
      * TODO - this is currently static because we *know* ImagingServlet uses a different instance
      * of CachingImageStreamer for every request. This is not exactly the most elegant.
      * TODO - see related TODO in currentJobs and info.magnolia.imaging.ImagingServlet#getStreamer
      */
     private static final ReentrantLock lock = new ReentrantLock();
 
     public CachingImageStreamer(Session session, CachingStrategy<P> cachingStrategy, ImageStreamer<P> delegate, SystemContext systemContext) {
         this.session = session;
         this.cachingStrategy = cachingStrategy;
         this.delegate = delegate;
         this.systemContext = systemContext;
 
         CacheBuilder<Object, Object> cb = CacheBuilder.newBuilder();
         this.currentJobs = cb
                 // entries from the LoadingCache will be removed 500ms after their creation,
                 // thus unblocking further requests for an equivalent job.
                 .expireAfterWrite(500, TimeUnit.MILLISECONDS)
 
                 // We're (ab)using CacheLoader -- this is NOT the cache. We're merely using it to schedule concurrent image generation jobs.
                 .build(new CacheLoader<ImageGenerationJob<P>, Property>() {
 
                     @Override
                     public Property load(ImageGenerationJob<P> job) throws Exception {
                         try {
                             return generateAndStore(job.getGenerator(), job.getParams());
                         } catch (IOException | ImagingException e) {
                             // the LoadingCache will further wrap these in ExecutionExceptions, and we will, in turn, unwrap them ...
                             throw new RuntimeException(e);
                         }
                     }
 
                 });
     }
 
     @Override
     public void serveImage(ImageGenerator<ParameterProvider<P>> generator, ParameterProvider<P> params, ImageResponse imageResponse) throws ImagingException, IOException {
         Property imgProp = fetchFromCache(generator, params);
         if (imgProp == null) {
             // image is not in cache or should be regenerated
             try {
                 imgProp = currentJobs.get(new ImageGenerationJob<>(generator, params));
             } catch (ExecutionException e) {
                 // thrown if the LoadingCache's Function failed
                 unwrapRuntimeException(e);
             }
         }
         serve(imgProp, imageResponse);
     }
 
     /**
      * @deprecate Since Imaging 3.3 (Magnolia 5.5) use {@link CachingImageStreamer#serveImage(ImageGenerator, ParameterProvider, ImageResponse)} instead.
      */
     @Deprecated
     public void serveImage(ImageGenerator<ParameterProvider<P>> generator, ParameterProvider<P> params, OutputStream out) throws IOException, ImagingException {
         serveImage(generator, params, new TemporaryImageResponse(out));
     }
 
     /**
      * Gets the binary property (NodeData) for the appropriate image, ready to be served,
      * or null if the image should be regenerated.
      */
     protected Property fetchFromCache(ImageGenerator<ParameterProvider<P>> generator, ParameterProvider<P> parameterProvider) {
         final String cachePath = cachingStrategy.getCachePath(generator, parameterProvider);
         if (cachePath == null) {
             // the CachingStrategy decided it doesn't want us to cache :(
             return null;
         }
         try {
             if (!session.itemExists(cachePath)) {
                 return null;
             }
             final Node imageNode = session.getNode(cachePath);
             if (!imageNode.hasNode(GENERATED_IMAGE_NODE_NAME)) {
                 return null;
             }
             final Property property = imageNode.getNode(GENERATED_IMAGE_NODE_NAME).getProperty(JcrConstants.JCR_DATA);
             InputStream in;
             try {
                 in = property.getBinary().getStream();
             } catch (RepositoryException e) {
                 // will happen, when stream is not yet stored properly (generateAndStore)
                 // we prefer this handling over having to lock because of better performance especially with big images
                 return null;
             }
             IOUtils.closeQuietly(in);
 
             if (cachingStrategy.shouldRegenerate(property, parameterProvider)) {
                 return null;
             }
             return property;
         } catch (RepositoryException e) {
             throw new RuntimeException(e); // TODO
         }
     }
 
     protected void serve(Property binary, ImageResponse imageResponse) throws IOException {
         final InputStream in;
         try {
             in = binary.getBinary().getStream();
         } catch (RepositoryException e) {
             throw new IllegalStateException("Can't get InputStream from " + binary);
         }
         final String contentType;
         try {
             contentType = binary.getParent().getProperty(JcrConstants.JCR_MIMETYPE).getString();
         } catch (RepositoryException e) {
             throw new IllegalStateException("Can't get content-type from " + binary);
         }
         imageResponse.setMediaType(MediaType.parse(contentType));
 
         final OutputStream out = imageResponse.getOutputStream();
         IOUtils.copy(in, out);
         IOUtils.closeQuietly(in);
     }
 
     protected Property generateAndStore(final ImageGenerator<ParameterProvider<P>> generator, final ParameterProvider<P> parameterProvider) throws IOException, ImagingException {
         // generate
         final ByteArrayOutputStream tempOut = new ByteArrayOutputStream();
         delegate.serveImage(generator, parameterProvider, new TemporaryImageResponse(tempOut));
 
         // it's time to lock now, we can only save one node at a time, since we'll be working on the same nodes as other threads
         lock.lock();
         try {
             final OutputFormat outputFormat = generator.getOutputFormat(parameterProvider);
             final MediaType contentType = getMediaType(outputFormat);
 
             final Session systemSession = systemContext.getJCRSession(session.getWorkspace().getName());
             // create cachePath if needed
             final String cachePath = cachingStrategy.getCachePath(generator, parameterProvider);
             final Node cacheNode = NodeUtil.createPath(session.getRootNode(), cachePath, NodeTypes.Content.NAME);
             final Node resourceNode = NodeUtil.createPath(cacheNode, GENERATED_IMAGE_NODE_NAME, NodeTypes.Resource.NAME);
             // store generated image
             final ByteArrayInputStream tempIn = new ByteArrayInputStream(tempOut.toByteArray());
             Property imageData = resourceNode.setProperty(JcrConstants.JCR_DATA, cacheNode.getSession().getValueFactory().createBinary(tempIn));
 
             final String formatName = generator.getOutputFormat(parameterProvider).getFormatName();
             final String mimeType = MIMEMapping.getMIMEType(formatName);
             resourceNode.setProperty(JcrConstants.JCR_MIMETYPE, mimeType);
             resourceNode.setProperty(JcrConstants.JCR_MIMETYPE, contentType.toString());
             resourceNode.setProperty(JcrConstants.JCR_LASTMODIFIED, Calendar.getInstance());
 
             // Update metadata of the cache *after* a succesfull image generation (creationDate has been set when creating
             // Since this might be called from a different thread than the actual request, we can't call cacheNode.updateMetaData(), which by default tries to set the authorId by using the current context
             NodeTypes.LastModified.update(cacheNode);
             // We need to explicitly update lastModified property of resourceNode
             // when update is done to JcrConstants.JCR_DATA property, updating of lastMofified by MgnlPropertySettingContentDecorator is not invoked, because all JCR properties are ignored by info.magnolia.jcr.wrapper.MgnlPropertySettingContentDecorator#shouldIgnoreUpdate(final String propertyName)
             NodeTypes.LastModified.update(resourceNode);
 
             // finally save it all
             try {
                 systemSession.save();
             } catch (InvalidItemStateException e){
                 log.warn("Item found in invalid state. Attempting to refresh the session.");
                 systemSession.refresh(false);
                 return systemSession.getNode(cachePath + "/" + GENERATED_IMAGE_NODE_NAME).getProperty(JcrConstants.JCR_DATA);
             }
 
             return imageData;
         } catch (RepositoryException e) {
             throw new ImagingException("Can't store rendered image: " + e.getMessage(), e);
         } finally {
             lock.unlock();
         }
     }
 
     /**
      * Unwrap ExecutionExceptions wrapping a RuntimeException wrapping an ImagingException or IOException,
      * as thrown by the Function of the computing map.
      *
      * @see #currentJobs
      */
     private void unwrapRuntimeException(Exception e) throws ImagingException, IOException {
         final Throwable cause = e.getCause();
         if (cause instanceof ImagingException) {
             throw (ImagingException) cause;
         } else if (cause instanceof IOException) {
             throw (IOException) cause;
         } else if (cause instanceof RuntimeException) {
             unwrapRuntimeException((RuntimeException) cause);
         } else if (cause == null) {
             // This really, really, should not happen... but we'll let this exception bubble up
             throw new IllegalStateException("Unexpected and unhandled exception: " + (e.getMessage() != null ? e.getMessage() : ""), e);
         } else {
             // this shouldn't happen either, actually.
             throw new ImagingException(e.getMessage(), cause);
         }
     }
 
     private static class TemporaryImageResponse implements ImageResponse {
         private final OutputStream tempOut;
 
         public TemporaryImageResponse(OutputStream tempOut) {
             this.tempOut = tempOut;
         }
 
         @Override
         public void setMediaType(MediaType mediaType) throws IOException {
             // Do nothing - in the case of CachingImageStreamer, we rely on the "real" ImageResponse to set the mime-type on the response
         }
 
         @Override
         public OutputStream getOutputStream() throws IOException {
             return tempOut;
         }
     }
 }