/*
 *  Copyright 2012 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.core.util;

import java.awt.image.BufferedImage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.commons.io.IOUtils;

import net.coobird.thumbnailator.ThumbnailParameter;
import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.filters.ImageFilter;
import net.coobird.thumbnailator.geometry.Positions;
import net.coobird.thumbnailator.resizers.DefaultResizerFactory;
import net.coobird.thumbnailator.tasks.io.InputStreamImageSource;
import net.coobird.thumbnailator.tasks.io.OutputStreamImageSink;

/**
 * Helper for manipulating images.
 */
public final class ImageHelper
{
    private static final float IMAGE_QUALITY = 0.9f;
    
    private ImageHelper()
    {
        // empty constructor
    }
    
    private static boolean _needsChanges(int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth)
    {
        return height > 0 || width > 0 || maxHeight > 0 || maxWidth > 0 || cropHeight > 0 || cropWidth > 0;
    }
    
    private static boolean _isJpeg(String format)
    {
        return format.equalsIgnoreCase("jpg") || format.equalsIgnoreCase("jpeg");
    }
    
    /**
     * Returns a BufferedImage as from the supplied input stream
     * @param is The input stream
     * @return The buffered image
     * @throws IOException if an error occurs during reading.
     */
    public static BufferedImage read(InputStream is) throws IOException
    {
        InputStreamImageSource imageSource = new InputStreamImageSource(is);
        ThumbnailParameter param = new ThumbnailParameter(1.0f, 1.0f, null, true, null, null, 1.0f, 0, null, DefaultResizerFactory.getInstance(), true, true);
        imageSource.setThumbnailParameter(param);
        
        BufferedImage src = imageSource.read();
        
        // Perform the image filters
        for (ImageFilter filter : param.getImageFilters())
        {
            src = filter.apply(src);
        }
        
        return src;
    }
    
    /**
     * Generates a thumbnail from a source InputStream. Note that if final width and height are equals to source width and height, the stream is just copied.
     * If the image should be both cropped and resized, the resizing will be done after the cropping.
     * @param is the source.
     * @param os the destination.
     * @param format the image format. Must be one of "gif", "png" or "jpg".
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @param cropHeight the height of the cropped image. Ignore if negative.
     * @param cropWidth the width of the cropped image. Ignore if negative.
     * @throws IOException if an error occurs when manipulating streams.
     */
    public static void generateThumbnail(InputStream is, OutputStream os, String format, int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth) throws IOException
    {
        if (!_isJpeg(format) && !_needsChanges(height, width, maxHeight, maxWidth, cropHeight, cropWidth))
        {
            // no resizing nor cropping needed
            // only do it for non JPEG, as JPEG may have some Exif orientation that we need to handle anyway
            IOUtils.copy(is, os);
            return;
        }
        
        BufferedImage dest = read(is);
        
        if (cropHeight > 0 || cropWidth > 0)
        {
            dest = _cropImage(dest, cropHeight, cropWidth);
        }
        
        if (height > 0 || width > 0 || maxHeight > 0 || maxWidth > 0)
        {
            dest = _resizeImage(dest, height, width, maxHeight, maxWidth);
        }
        
        OutputStreamImageSink imageSink = new OutputStreamImageSink(os);
        imageSink.setOutputFormatName(format);
        ThumbnailParameter param = new ThumbnailParameter(1.0f, 1.0f, null, true, null, null, IMAGE_QUALITY, 0, null, DefaultResizerFactory.getInstance(), true, true);
        imageSink.setThumbnailParameter(param);
        imageSink.write(dest);
    }   
    
    /**
     * Generates a BufferedImage with specified size instructions, scaling if necessary.<br>
     * If the image should be both cropped and resized, the resizing will be done after the cropping.
     * @param src the source image.
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @param cropHeight the height of the cropped image. Ignore if negative.
     * @param cropWidth the width of the cropped image. Ignore if negative.
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    public static BufferedImage generateThumbnail(BufferedImage src, int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth) throws IOException
    {
        BufferedImage dest = src;
        
        if (cropHeight > 0 || cropWidth > 0)
        {
            dest = _cropImage(src, cropHeight, cropWidth);
        }
        
        if (height > 0 || width > 0 || maxHeight > 0 || maxWidth > 0)
        {
            dest = _resizeImage(src, height, width, maxHeight, maxWidth);
        }
        
        return dest;
    }
    
    /**
     * Generates a thumbnail from a source InputStream. Note that if final width and height are equals to source width and height, the stream is just copied.
     * @param is the source.
     * @param os the destination.
     * @param format the image format. Must be one of "gif", "png" or "jpg".
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @throws IOException if an error occurs when manipulating streams.
     */
    public static void generateThumbnail(InputStream is, OutputStream os, String format, int height, int width, int maxHeight, int maxWidth) throws IOException
    {
        if (!_isJpeg(format) && !_needsChanges(height, width, maxHeight, maxWidth, 0, 0))
        {
            // no resizing needed
            // only do it for non JPEG, as JPEG may have some Exif orientation that we need to handle anyway
            IOUtils.copy(is, os);
            return;
        }
        
        BufferedImage src = read(is);
        BufferedImage dest = _resizeImage(src, height, width, maxHeight, maxWidth);
        
        OutputStreamImageSink imageSink = new OutputStreamImageSink(os);
        imageSink.setOutputFormatName(format);
        ThumbnailParameter param = new ThumbnailParameter(1.0f, 1.0f, null, true, null, null, IMAGE_QUALITY, 0, null, DefaultResizerFactory.getInstance(), true, true);
        imageSink.setThumbnailParameter(param);
        imageSink.write(dest);
    }
    
    /**
     * Generates a BufferedImage with specified size instructions, scaling if necessary.<br>
     * @param src the source image.
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    public static BufferedImage generateThumbnail(BufferedImage src, int height, int width, int maxHeight, int maxWidth) throws IOException
    {
        return _resizeImage(src, height, width, maxHeight, maxWidth);
    }
    
    /**
     * Generates a thumbnail from a source InputStream. Note that if final width and height are equals to source width and height, the stream is just copied.
     * @param is the source.
     * @param os the destination.
     * @param format the image format. Must be one of "gif", "png" or "jpg".
     * @param ratio ratio to resize the image (1 = same size)
     * @throws IOException if an error occurs when manipulating streams.
     */
    public static void generateThumbnail(InputStream is, OutputStream os, String format, double ratio) throws IOException
    {
        if (!_isJpeg(format) && ratio == 1)
        {
            // no resizing needed
            // only do it for non JPEG, as JPEG may have some Exif orientation that we need to handle anyway
            IOUtils.copy(is, os);
            return;
        }
        
        BufferedImage src = read(is);
        BufferedImage dest = _resizeImage(src, ratio);
        
        OutputStreamImageSink imageSink = new OutputStreamImageSink(os);
        imageSink.setOutputFormatName(format);
        ThumbnailParameter param = new ThumbnailParameter(1.0f, 1.0f, null, true, null, null, IMAGE_QUALITY, 0, null, DefaultResizerFactory.getInstance(), true, true);
        imageSink.setThumbnailParameter(param);
        imageSink.write(dest);
    }
    
    /**
     * Generates a BufferedImage with specified size instructions, scaling if necessary.<br>
     * @param src the source image.
     * @param ratio ratio to resize the image (1 = same size)
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    public static BufferedImage generateThumbnail(BufferedImage src, double ratio) throws IOException
    {
        return _resizeImage(src, ratio);
    }

    /**
     * Crop an image from a source InputStream. Note that if any of the coordinate and size are negatives, the image will just be copied.
     * @param is the source.
     * @param os the destination.
     * @param format the image format. Must be one of "gif", "png" or "jpg".
     * @param x The X coordinate of the upper-left corner of the specified rectangular region
     * @param y the Y coordinate of the upper-left corner of the specified rectangular region
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @throws IOException If an error occurs
     */
    public static void generateCroppedImage(InputStream is, OutputStream os, String format, int x, int y, int height, int width) throws IOException
    {
        BufferedImage src = read(is);
        BufferedImage dest = _cropImage(src, x, y, height, width);
        
        OutputStreamImageSink imageSink = new OutputStreamImageSink(os);
        imageSink.setOutputFormatName(format);
        ThumbnailParameter param = new ThumbnailParameter(1.0f, 1.0f, null, true, null, null, IMAGE_QUALITY, 0, null, DefaultResizerFactory.getInstance(), true, true);
        imageSink.setThumbnailParameter(param);
        imageSink.write(dest);
    }
    
    /**
     * Crop the image in the center, at the specified dimensions. The returned <code>BufferedImage</code> shares the same data array as the original image.
     * @param src the source image.
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    public static BufferedImage generateCroppedImage(BufferedImage src, int height, int width) throws IOException
    {
        return _cropImage(src, height, width);
    }    
    /**
     * Crop the image by a specified rectangular region. The returned <code>BufferedImage</code> shares the same data array as the original image.
     * @param src the source image.
     * @param x The X coordinate of the upper-left corner of the specified rectangular region
     * @param y the Y coordinate of the upper-left corner of the specified rectangular region
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    public static BufferedImage generateCroppedImage(BufferedImage src, int x, int y, int height, int width) throws IOException
    {
        return _cropImage(src, x, y, height, width);
    }
    
    /**
     * Crop the image to the size specified to the center of the image.
     * @param src the source image.
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @return The cropped image as a BufferedImage
     * @throws IOException If the source image is not readable
     */
    protected static BufferedImage _cropImage(BufferedImage src, int height, int width) throws IOException
    {
        return Thumbnails.of(src).size(width, height).crop(Positions.CENTER).asBufferedImage();
    }
    
    /**
     * Crop the image by a specified rectangular region. The returned <code>BufferedImage</code> shares the same data array as the original image.
     * @param src the source image.
     * @param x The X coordinate of the upper-left corner of the specified rectangular region.
     * @param y the Y coordinate of the upper-left corner of the specified rectangular region.
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    protected static BufferedImage _cropImage(BufferedImage src, int x, int y, int height, int width) throws IOException
    {
        return Thumbnails.of(src).scale(1).sourceRegion(x, y, width, height).asBufferedImage();
    }
    
    /**
     * Resize the buffered image
     * @param src the source image
     * @param height the specified height. Ignored if negative.
     * @param width the specified width. Ignored if negative.
     * @param maxHeight the maximum image height. Ignored if height or width is specified.
     * @param maxWidth the maximum image width. Ignored if height or width is specified.
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    protected static BufferedImage _resizeImage(BufferedImage src, int height, int width, int maxHeight, int maxWidth) throws IOException
    {
        int srcHeight = src.getHeight();
        int srcWidth = src.getWidth();
        
        int destHeight = 0;
        int destWidth = 0;
        
        boolean keepAspectRatio = true;
        
        if (height > 0)
        {
            // heigth is specified
            destHeight = height;
            
            if (width > 0)
            {
                // additionnally, width is also specified
                destWidth = width;
                keepAspectRatio = false;
            }
            else
            {
                // width is computed
                destWidth = srcWidth * destHeight / srcHeight;
            }
        }
        else if (width > 0)
        {
            // width is specified, height is computed
            destWidth = width;
            destHeight = srcHeight * destWidth / srcWidth;
        }
        else if (maxHeight > 0)
        {
            if (maxWidth > 0)
            {
                if (srcHeight <= maxHeight && srcWidth <= maxWidth)
                {
                    // the source image is already smaller than the destination box
                    return src;
                }
                
                destWidth = maxWidth;
                destHeight = maxHeight;
            }
            else
            {
                if (srcHeight <= maxHeight)
                {
                    // the source image is already smaller than the destination box
                    return src;
                }
                
                destHeight = maxHeight;
                destWidth = srcWidth * destHeight / srcHeight;
            }
        }
        else if (maxWidth > 0)
        {
            if (srcWidth <= maxWidth)
            {
                // the source image is already smaller than the destination box
                return src;
            }
            
            destWidth = maxWidth;
            destHeight = srcHeight * destWidth / srcWidth;
        }
        else
        {
            // No resize is required
            return src;
        }
        
        if (destHeight == srcHeight && destWidth == srcWidth)
        {
            // already the good format, don't change anything
            return src;
        }
        
        return Thumbnails.of(src).size(destWidth, destHeight).keepAspectRatio(keepAspectRatio).imageType(src.getColorModel().hasAlpha() ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB).asBufferedImage();
    }
    
    /**
     * Resize the buffered image
     * @param src the source image
     * @param ratio ratio to resize the image (1 = same size)
     * @return a scaled BufferedImage. If no size modification is required, this will return the src image.
     * @throws IOException If the source image is not readable
     */
    protected static BufferedImage _resizeImage(BufferedImage src, double ratio) throws IOException
    {
        if (ratio == 1)
        {
            return src;
        }
        return Thumbnails.of(src).scale(ratio).imageType(src.getColorModel().hasAlpha() ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB).asBufferedImage();
    }
}