package com.atlassian.core.util.thumbnail;
   
   import com.atlassian.core.util.ReusableBufferedInputStream;
   import com.google.common.base.Optional;
   
   import javax.imageio.ImageIO;
   import javax.imageio.ImageReadParam;
   import javax.imageio.ImageReader;
   import javax.imageio.stream.ImageInputStream;
  import java.awt.image.BufferedImage;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Iterator;
  
  public class StreamImageScale implements ImageScaler
  {
      private final DimensionsHelper dimensionsHelper;
  
      public StreamImageScale(DimensionsHelper dimensionsHelper)
      {
          this.dimensionsHelper = dimensionsHelper;
      }
  
      @Override
      public BufferedImage scaleImage(int maxWidth, int maxHeight, ReusableBufferedInputStream imageStream) throws IOException
      {
          final ImageInputStream imageInputStream = getImageInputStream(imageStream);
          final Optional<ImageReader> imageReader = getImageReader(imageInputStream);
  
          if (!imageReader.isPresent())
          {
              throw new IOException("Cannot read the image");
          }
  
          final ImageReader reader = imageReader.get();
          try
          {
              reader.setInput(imageInputStream);
  
              final Dimensions scaledDimensions = dimensionsHelper.determineScaledDimensions(maxWidth, maxHeight, reader.getWidth(0), reader.getHeight(0));
              int ratio = (int) Math.floor(((double) reader.getWidth(0) / (double) scaledDimensions.getWidth()));
  
              final ImageReadParam param = reader.getDefaultReadParam();
              param.setSourceSubsampling(ratio, ratio, 0, 0);
  
              final BufferedImage scaledImage = reader.read(0, param);
              //Subsampling does not return an exact size of an image - we can force it by cropping an image
              return scaledImage.getSubimage(0, 0,
                      Math.min(scaledDimensions.getWidth(), scaledImage.getWidth()),
                      Math.min(scaledDimensions.getHeight(), scaledImage.getHeight()));
          }
          finally
          {
              reader.dispose();
          }
      }
  
      ImageInputStream getImageInputStream(InputStream inputStream) throws IOException
      {
          return ImageIO.createImageInputStream(inputStream);
      }
  
      Optional<ImageReader> getImageReader(ImageInputStream imageInputStream) throws IOException
      {
          final Iterator<ImageReader> readers = ImageIO.getImageReaders(imageInputStream);
          return readers.hasNext() ? Optional.of(readers.next()) : Optional.<ImageReader>absent();
      }
  
  }