package com.atlassian.core.util.thumbnail;
   
   import com.google.common.base.Optional;
   import org.apache.commons.io.IOUtils;
   
   import javax.imageio.ImageIO;
   import javax.imageio.ImageReader;
   import javax.imageio.stream.ImageInputStream;
   import java.awt.Image;
  import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Iterator;
  
  public class DimensionsHelper {
  
      public Dimensions dimensionsForImage(final InputStream inputStream) throws IOException {
          final BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
  
          try
          {
              final ImageInputStream imageInputStream = getImageInputStream(inputStream);
              final Optional<ImageReader> imageReader = getImageReader(imageInputStream);
              if (!imageReader.isPresent())
              {
                  throw new IOException("There is no ImageReader available for the given ImageInputStream");
              }
              // Use the first one available
              final ImageReader reader = imageReader.get();
              try
              {
                  reader.setInput(imageInputStream);
                  return new Dimensions(reader.getWidth(0), reader.getHeight(0));
              }
              finally
              {
                  reader.dispose();
              }
          }
          finally
          {
              IOUtils.closeQuietly(bufferedInputStream);
          }
      }
  
      public Dimensions determineScaledDimensions(int maxWidth, int maxHeight, Image image)
      {
          return determineScaledDimensions(maxWidth, maxHeight, image.getWidth(null), image.getHeight(null));
      }
  
      public Dimensions determineScaledDimensions(int maxWidth, int maxHeight, int imageWidth, int imageHeight)
      {
          if (maxHeight > imageHeight && maxWidth > imageWidth)
          {
              return new Dimensions(imageWidth, imageHeight);
          }
          // Determine scale size.
          // Retain original image proportions with scaled image.
          double thumbRatio = (double) maxWidth / (double) maxHeight;
  
          double imageRatio = (double) imageWidth / (double) imageHeight;
  
          if (thumbRatio < imageRatio)
          {
              return new Dimensions(maxWidth, (int) Math.max(1, maxWidth / imageRatio));
          }
          else
          {
              return new Dimensions((int) Math.max(1, maxHeight * imageRatio), maxHeight);
          }
      }
  
      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();
      }
  }