/*
 *  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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Set;

import org.apache.commons.io.IOUtils;

import org.ametys.core.util.POIHolder.Point;

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
{
    /** The unresizable images formats */
    public static final Collection<String> UNRESIZABLE_FORMATS = Set.of("svg", "svg+xml");
    private static final float IMAGE_QUALITY = 0.9f;
    
    private ImageHelper()
    {
        // empty constructor
    }
    
    private static boolean _isUnresizableFormat(String format)
    {
        return UNRESIZABLE_FORMATS.contains(format);
    }
    
    private static boolean _needsChanges(String format, int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth)
    {
        return !_isUnresizableFormat(format) && (height > 0 || width > 0 || maxHeight > 0 || maxWidth > 0 || cropHeight > 0 || cropWidth > 0);
    }
    
    /**
     * 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", "svg" or "jpg". "svg" will not be resized.
     * @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
    {
        generateThumbnail(is, os, format, height, width, maxHeight, maxWidth, cropHeight, cropWidth, null);
    }
    
    /**
     * 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", "svg" or "jpg". "svg" will not be resized.
     * @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.
     * @param poi the Point of Interest to center the crop around. Ignore if crop sizes are negative. Can be null to use the center as POI.
     * @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, Point poi) throws IOException
    {
        if (!_needsChanges(format, height, width, maxHeight, maxWidth, cropHeight, cropWidth))
        {
            // no resizing nor cropping needed
            IOUtils.copy(is, os);
            return;
        }
        
        byte[] data = IOUtils.toByteArray(is);
        BufferedImage src = read(new ByteArrayInputStream(data));
        BufferedImage dest = src;
        
        if (cropHeight > 0 || cropWidth > 0)
        {
            dest = _cropImage(dest, cropHeight, cropWidth, poi);
        }
        
        if (height > 0 || width > 0 || maxHeight > 0 || maxWidth > 0)
        {
            dest = _resizeImage(dest, height, width, maxHeight, maxWidth);
        }
        
        if (src == dest)
        {
            // source and destination have same dimensions, so preserve the initial image
            IOUtils.copy(new ByteArrayInputStream(data), os);
            return;
        }
        
        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
    {
        return generateThumbnail(src, height, width, maxHeight, maxWidth, cropHeight, cropWidth, null);
    }
    /**
     * 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.
     * @param poi the Point of Interest to center the crop around. Ignore if crop sizes are negative. Can be null to use the center as POI.
     * @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, Point poi) throws IOException
    {
        BufferedImage dest = src;
        
        if (cropHeight > 0 || cropWidth > 0)
        {
            dest = _cropImage(src, cropHeight, cropWidth, poi);
        }
        
        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", "svg" or "jpg". "svg" will not be resized.
     * @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
    {
        generateThumbnail(is, os, format, height, width, maxHeight, maxWidth, 0, 0);
    }
    
    /**
     * 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", "svg" or "jpg". "svg" will not be resized.
     * @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 (_isUnresizableFormat(format) || ratio == 1)
        {
            // no resizing needed
            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", "svg" or "jpg". "svg" will not be resized.
     * @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
    {
        if (_isUnresizableFormat(format))
        {
            // no resizing needed
            IOUtils.copy(is, os);
            return;
        }
        
        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 to the size specified, centered around the given Point of Interest.
     * If POI is null, the center of the image is used
     * @param src the source image.
     * @param height the width of the specified rectangular region
     * @param width the height of the specified rectangular region
     * @param poi the Point of Interest to center the crop around, or {@code null} to use the center
     * @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, Point poi) throws IOException
    {
        if (poi == null)
        {
            return Thumbnails.of(src).size(width, height).crop(Positions.CENTER).asBufferedImage();
        }

        // Scale src to COVER target dimensions (maintain aspect ratio)
        double scaleX = (double) width / src.getWidth();
        double scaleY = (double) height / src.getHeight();
        double scale = Math.max(scaleX, scaleY);

        int scaledWidth = (int) Math.round(src.getWidth() * scale);
        int scaledHeight = (int) Math.round(src.getHeight() * scale);

        BufferedImage scaled = Thumbnails.of(src)
                .size(scaledWidth, scaledHeight)
                .keepAspectRatio(false)
                .asBufferedImage();

        // Project POI into the scaled image
        int scaledPoiX = (int) Math.round((double) poi.x() / src.getWidth() * scaledWidth);
        int scaledPoiY = (int) Math.round((double) poi.y() / src.getHeight() * scaledHeight);

        // Top-left corner centered on POI, clamped to bounds
        int x = Math.max(0, Math.min(scaledPoiX - width / 2, scaledWidth - width));
        int y = Math.max(0, Math.min(scaledPoiY - height / 2, scaledHeight - height));

        return scaled.getSubimage(x, y, width, height);
    }
    
    /**
     * 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();
    }
}