/*
 *  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.util.Arrays;
import java.util.Collection;
import java.util.Map;

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;

/**
 * Abstract reader for Ametys resources.
 * If the resource is an image, this reader handles resizing and cropping.
 */
public abstract class AbstractResourceReader extends AbstractReader
{
    private static final String __DEFAULT_FORMAT = "png";
    private static final Collection<String> __ALLOWED_FORMATS = Arrays.asList("png", "gif", "jpg", "jpeg");

    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 resolver, Map objectModel, String src, Parameters par) throws ProcessingException, SAXException, IOException
    {
        super.setup(resolver, objectModel, src, par);
        
        doSetup(resolver, objectModel, src, par);
        
        _readForDownload = par.getParameterAsBoolean("download", false);
        Response response = ObjectModelHelper.getResponse(objectModel);

        if (_readForDownload)
        {
            String name = getFilename();
            String encodedName = getEncodedFilename();
            
            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;
    
    @SuppressWarnings("deprecation")
    public void generate() throws IOException, SAXException, ProcessingException
    {
        Response response = ObjectModelHelper.getResponse(objectModel);
        
        try (InputStream is = getInputStream())
        {
            if (processImage())
            {
                String fileName = getFilename();
                int i = fileName.lastIndexOf('.');
                String format = i != -1 ? fileName.substring(i + 1).toLowerCase() : __DEFAULT_FORMAT;
                format = __ALLOWED_FORMATS.contains(format) ? format : __DEFAULT_FORMAT;
                
                ImageHelper.generateThumbnail(is, out, format, _height, _width, _maxHeight, _maxWidth, _cropHeight, _cropWidth);  
            }
            else
            {
                // Copy data in response
                response.setHeader("Content-Length", Long.toString(getLength()));
                IOUtils.copy(is, out);
            }
        }
        finally
        {
            IOUtils.closeQuietly(out);
        }
    }
    
    /**
     * 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.
     * @return <code>true</code> if file is a image
     */
    protected boolean processImage()
    {
        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/");
        }
        
        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;
    }
}