/*
 *  Copyright 2019 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.cocoon;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Response;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.reading.AbstractReader;
import org.apache.commons.io.IOUtils;
import org.xml.sax.SAXException;

import org.ametys.core.util.ImageHelper;
import org.ametys.core.util.URIUtils;

/**
 * Abstract reader for Ametys resources.
 * If the resource is an image, this reader handles resizing and cropping.
 */
public abstract class AbstractResourceReader extends AbstractReader
{
    /** Default returned format */
    protected static final String __DEFAULT_FORMAT = "png";
    
    /** List of allowed output formats */
    protected static final Collection<String> __ALLOWED_OUTPUT_FORMATS = Arrays.asList("png", "gif", "jpg", "jpeg");
    /** List of format that cannot be resized */
    protected static final Collection<String> __UNRESIZABLE_FORMATS = Set.of("svg");

    private int _width;
    private int _height;
    private int _maxWidth;
    private int _maxHeight;
    private int _cropWidth;
    private int _cropHeight;
    
    private boolean _readForDownload;
    
    @Override
    public void setup(SourceResolver sresolver, Map sObjectModel, String src, Parameters par) throws ProcessingException, SAXException, IOException
    {
        super.setup(sresolver, sObjectModel, src, par);
        
        doSetup(sresolver, sObjectModel, src, par);
        
        _readForDownload = par.getParameterAsBoolean("download", false);
        Response response = ObjectModelHelper.getResponse(sObjectModel);

        if (_readForDownload)
        {
            String name = getFilename();
            String encodedName = getEncodedFilename();
            encodedName = encodedName != null ? URIUtils.encodeHeader(encodedName) : null;
            
            response.setHeader("Content-Disposition", "attachment; filename=\"" + (encodedName != null ? encodedName : name) + "\"" + (encodedName != null ? ";filename*=UTF-8''" + encodedName : ""));
        }
        
        // parameters for image resizing
        _width = par.getParameterAsInteger("width", 0);
        _height = par.getParameterAsInteger("height", 0);
        _maxWidth = par.getParameterAsInteger("maxWidth", 0);
        _maxHeight = par.getParameterAsInteger("maxHeight", 0);
        _cropWidth = par.getParameterAsInteger("cropWidth", 0);
        _cropHeight = par.getParameterAsInteger("cropHeight", 0);
    }

    /**
     * Called by {@link #setup(SourceResolver, Map, String, Parameters)}. This method should be implemented by subclasses to retrieve the actual resource.
     * @param res the {@link SourceResolver}.
     * @param objModel the Cocoon's object model.
     * @param src the source, as given by the sitemap.
     * @param par the parameters, as given by the sitemap.
     * @throws ProcessingException if an error occurs while processing the resource.
     * @throws IOException if an error occurs while accessing the resource.
     */
    protected abstract void doSetup(SourceResolver res, Map objModel, String src, Parameters par) throws ProcessingException, IOException;
    
    public void generate() throws IOException, SAXException, ProcessingException
    {
        Response response = ObjectModelHelper.getResponse(objectModel);
        
        try (InputStream is = getInputStream())
        {
            String fileName = getFilename();
            int i = fileName.lastIndexOf('.');
            String fileExtension = i != -1 ? fileName.substring(i + 1).toLowerCase() : __DEFAULT_FORMAT;
            
            if (processImage(fileExtension))
            {
                String outputFormat = __ALLOWED_OUTPUT_FORMATS.contains(fileExtension) ? fileExtension : __DEFAULT_FORMAT;
                
                generateThumbnail(is, outputFormat);
                
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("Image generated: " + ObjectModelHelper.getRequest(objectModel).getRequestURI());
                }
            }
            else
            {
                // Copy data in response
                response.setHeader("Content-Length", Long.toString(getLength()));
                IOUtils.copy(is, out);

                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("Resource generated: " + ObjectModelHelper.getRequest(objectModel).getRequestURI());
                }
            }
        }
        finally
        {
            IOUtils.closeQuietly(out);
        }
    }
    
    /**
     * Generate the thumbnail in {@link OutputStream} out
     * @param is original image
     * @param format format of the file
     * @throws IOException if an error occurs when manipulating streams.
     */
    protected void generateThumbnail(InputStream is, String format) throws IOException
    {
        ImageHelper.generateThumbnail(is, out, format, _height, _width, _maxHeight, _maxWidth, _cropHeight, _cropWidth);
    }
    
    /**
     * Returns the resource's {@link InputStream}.
     * @return the resource's {@link InputStream}.
     */
    protected abstract InputStream getInputStream();
    
    /**
     * Returns the resource's name.
     * @return the resource's name.
     */
    protected abstract String getFilename();
    
    /**
     * If needed, returns the resource's name, properly encoded for using in a "Content-Disposition" HTTP header.<br>
     * May be null, in which case the result of {@link #getFilename()} is used instead.
     * @return the encoded resource's name, if any.
     */
    protected abstract String getEncodedFilename();
    
    /**
     * Returns the resource's length.
     * @return the resource's length.
     */
    protected abstract long getLength();
    
    
    /**
     * Determines if the file is an image and should be processed.
     * @param fileExtension The file extension to process
     * @return <code>true</code> if file is a image
     */
    protected 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 (!_readForDownload)
        {
            // only process image if it is for rendering purposes
            return getMimeType() != null && getMimeType().startsWith("image/");
        }
        else
        {
            return false;
        }
    }
    
    /**
     * Helper method to compute a suffix based on resizing and cropping properties.
     * @return a String to be used in cache keys.
     */
    protected String getKeySuffix()
    {
        return "#" + _height + "#" + _width + "#" + _maxHeight + "#" + _maxWidth + "#" + _cropHeight + "#" + _cropWidth;
    }
}