/*
 *  Copyright 2016 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.resources;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.ResourceNotFoundException;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.core.util.ImageHelper;

/**
 * Resource handler for images
 */
public class ImageResourceHandler extends SimpleResourceHandler
{
    private static final Pattern _SIZE_PATTERN = Pattern.compile("^(.+)_(max|crop|)(\\d+)x(\\d+)(\\.[^./]+)?$");

    private static final Collection<String> __ALLOWED_OUTPUT_FORMATS = Set.of("png", "gif", "jpg", "jpeg");
    private static final Collection<String> __UNRESIZABLE_FORMATS = Set.of("svg");
    
    private int _height;
    private int _width;
    private int _maxHeight;
    private int _maxWidth;
    private int _cropHeight;
    private int _cropWidth;
    
    private boolean _download;
    
    record SizedSource(Source source, int height, int width, int maxHeight, int maxWidth, int cropHeight, int cropWidth) { /* empty */ }
    
    /**
     * Default constructor
     */
    public ImageResourceHandler()
    {
        super();
    }
    
    /**
     * If the {@link Source} is already resolved by the {@link ResourceHandlerProvider},
     * it may provide it through the constructor to avoid resolving it again.
     * @param sizedSource the source.
     */
    public ImageResourceHandler(SizedSource sizedSource)
    {
        super(sizedSource.source);
        _toFields(sizedSource);
    }
    
    private void _toFields(SizedSource sizedSource)
    {
        _source = sizedSource.source;
        _height = sizedSource.height;
        _width = sizedSource.width;
        _maxHeight = sizedSource.maxHeight;
        _maxWidth = sizedSource.maxWidth;
        _cropHeight = sizedSource.cropHeight;
        _cropWidth = sizedSource.cropWidth;
    }

    @Override
    public Source setup(String location, Map objectModel, Parameters par, boolean readForDownload) throws IOException, ProcessingException
    {
        if (_source == null)
        {
            // If the source has not been resolved by the provider, do it now
            SizedSource sizedSource = _resolveSource(location, _resolver);
            if (sizedSource != null)
            {
                _toFields(sizedSource);
            }
        }
        
        if (_source != null)
        {
            _download = readForDownload;
            
            return _source;
        }
        else
        {
            throw new ResourceNotFoundException("Resource not found for URI : " + location);
        }
    }

    @Override
    public void generate(OutputStream out) throws IOException, ProcessingException
    {
        String fileExtension = StringUtils.substringAfterLast(_source.getURI(), ".").toLowerCase();
        
        try (InputStream is = _source.getInputStream())
        {
            if (_processImage(fileExtension))
            {
                String outputFormat = __ALLOWED_OUTPUT_FORMATS.contains(fileExtension) ? fileExtension : "png";
                ImageHelper.generateThumbnail(is, out, outputFormat, _height, _width, _maxHeight, _maxWidth, _cropHeight, _cropWidth);
            }
            else
            {
                // Copy data in response
                IOUtils.copy(is, out);
            }
        }
    }
    
    private boolean _processImage(String fileExtension)
    {
        if (__UNRESIZABLE_FORMATS.contains(fileExtension))
        {
            return false;
        }
        else if (_width > 0 || _height > 0 || _maxHeight > 0 || _maxWidth > 0 || _cropHeight > 0 || _cropWidth > 0)
        {
            // resize or crop is required, assume this is an image
            return true;
        }
        else if (!_download)
        {
            String mimeType = _source.getMimeType();
                    
            // only process image if it is for rendering purposes
            return mimeType != null && mimeType.startsWith("image/");
        }
        else
        {
            return false;
        }
    }

    @Override
    public Serializable getKey()
    {
        return _source.getURI() + "###" + _width + "x" + _height + "x" + _maxWidth + "x" + _maxHeight + "x" + _cropWidth + "x" + _cropHeight;
    }
    
    /**
     * Resolve the source at the given location
     * @param location the location of the source to resolve
     * @param resolver the source resolver
     * @return the resolved source or null
     */
    static SizedSource _resolveSource(String location, SourceResolver resolver)
    {
        try
        {
            Source source = null;
            try
            {
                source = resolver.resolveURI(location);
                if (source != null && source.exists())
                {
                    return new SizedSource(source, 0, 0, 0, 0, 0, 0);
                }
                else
                {
                    throw new SourceNotFoundException(location);
                }
            }
            catch (SourceNotFoundException e)
            {
                resolver.release(source);
            }
            
            
            Matcher sizeMatcher = _SIZE_PATTERN.matcher(location);
            if (sizeMatcher.matches())
            {
                String computedLocation = sizeMatcher.group(1);
                String suffix = sizeMatcher.group(5);
                if (suffix != null)
                {
                    computedLocation += suffix;
                }
                
                try
                {
                    source = resolver.resolveURI(computedLocation);
                    if (!source.exists())
                    {
                        throw new SourceNotFoundException(computedLocation);
                    }
                }
                catch (SourceNotFoundException e)
                {
                    resolver.release(source);
                    return null;
                }
                
                // type is either empty (resize), max or crop.
                String type = sizeMatcher.group(2);
                
                int pHeight = Integer.parseInt(sizeMatcher.group(3));
                int pWidth = Integer.parseInt(sizeMatcher.group(4));

                int height = "".equals(type) ? pHeight : 0;
                int width = "".equals(type) ? pWidth : 0;
                int maxHeight = "max".equals(type) ? pHeight : 0;
                int maxWidth = "max".equals(type) ? pWidth : 0;
                int cropHeight = "crop".equals(type) ? pHeight : 0;
                int cropWidth = "crop".equals(type) ? pWidth : 0;
                
                return new SizedSource(source, height, width, maxHeight, maxWidth, cropHeight, cropWidth);
            }
            else
            {
                return null;
            }
        }
        catch (IOException e)
        {
            return null;
        }
    }
}