/*
 *  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.Graphics;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.imageio.ImageIO;

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.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 ImageHelper()
    {
        // empty constructor
    }
    
    /**
     * 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.
     * @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
    {
        BufferedImage src = read(is);
        BufferedImage dest = _resizeImage(src, height, width, maxHeight, maxWidth);
        
        OutputStreamImageSink imageSink = new OutputStreamImageSink(os);
        imageSink.setOutputFormatName(format);
        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);
    }

    /**
     * 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
    {
        byte[] fileContent = IOUtils.toByteArray(is); // keep a copy of the initial stream in case no thumbnail is necessary
        
        BufferedImage src = read(new ByteArrayInputStream(fileContent));
        BufferedImage dest = _cropImage(src, x, y, height, width);
        
        if (src == dest)
        {
            // Thumbnail is equals to src image, means that the image is the same
            // We'd rather like return the initial stream
            IOUtils.write(fileContent, os);
        }
        else
        {
            ImageIO.write(dest, format, os);
        }
    }
    
    /**
     * 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 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
    {
        BufferedImage dest = new BufferedImage(Integer.valueOf(width), Integer.valueOf(height), src.getColorModel().hasAlpha() ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB);
        Graphics g = dest.getGraphics();
        int offsetX = x < 0 ? x * -1 : 0;
        int offsetY = y < 0 ? y * -1 : 0;
        g.drawImage(src, offsetX, offsetY, width, height, x + offsetX, y + offsetY, x + offsetX + width, y + offsetY + height, null);
        g.dispose();
        return dest;
    }
    
    /**
     * 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 thumbnail.scale(1);
                    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();
    }
}