/*
 *  Copyright 2010 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.cms.content;

import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.parameters.ParameterException;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.caching.CacheableProcessingComponent;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
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.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.source.impl.validity.TimeStampValidity;
import org.xml.sax.SAXException;

import org.ametys.cms.repository.Content;
import org.ametys.core.util.ImageHelper;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.File;
import org.ametys.plugins.repository.metadata.Folder;
import org.ametys.plugins.repository.metadata.RichText;

/**
 * Reader for binary or file metadata.
 */
public class ContentFileReader extends AbstractReader implements CacheableProcessingComponent
{
    private Content _content;
    private File _file;
    
    private String _path;
    
    private int _width;
    private int _height;
    private int _maxWidth;
    private int _maxHeight;
    private int _cropWidth;
    private int _cropHeight;
    
    private boolean _readForDownload;
    private Collection<String> _allowedFormats = Arrays.asList(new String[]{"png", "gif", "jpg", "jpeg"});
    
    @Override
    public void setup(SourceResolver res, Map objModel, String src, Parameters par) throws ProcessingException, SAXException, IOException
    {
        super.setup(res, objModel, src, par);
        
        Request request = ObjectModelHelper.getRequest(objectModel);
        _content = (Content) request.getAttribute(Content.class.getName());
        
        String metadataName = parameters.getParameter("metadata", null);
        RichText richText = _getMeta(_content.getMetadataHolder(), metadataName);
        
        Folder folder = richText.getAdditionalDataFolder();
        
        try
        {
            _path = parameters.getParameter("path");
        }
        catch (ParameterException e)
        {
            throw new ProcessingException("The path parameter is mandatory for reading binary metadata.", e);
        }
        
        List<String> pathElements = Arrays.asList(_path.split("/"));
        
        Iterator<String> it = pathElements.iterator();
        
        while (it.hasNext())
        {
            String pathElement = it.next();
            pathElement = URLDecoder.decode(pathElement, "utf-8");
            
            if (it.hasNext())
            {
                // not the last segment : it is a composite
                folder = folder.getFolder(pathElement);
            }
            else
            {
                File file = folder.getFile(pathElement);
                _file = file;
            }
        }
        
        _readForDownload = par.getParameterAsBoolean("download", false);
        Response response = ObjectModelHelper.getResponse(objectModel);

        if (_readForDownload)
        {
            response.setHeader("Content-Disposition", "attachment; filename=\"" + _file.getName() + "\"");
        }

        // 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);
    }
    
    @Override
    public Serializable getKey()
    {
        return _path + "#" + _height + "#" + _width + "#" + _maxHeight + "#" + _maxWidth + "#" + _cropHeight + "#" + _cropWidth;
    }

    @Override
    public SourceValidity getValidity()
    {
        return new TimeStampValidity(getLastModified());
    }
    
    @Override
    public long getLastModified()
    {
        if (_content != null)
        {
            return _content.getLastModified().getTime();
        }
        
        return super.getLastModified();
    }
    
    @Override
    public String getMimeType()
    {
        if (_file != null)
        {
            return _file.getResource().getMimeType();
        }

        return super.getMimeType();
    }

    @Override
    public void generate() throws IOException, SAXException, ProcessingException
    {
        try (InputStream is = _file.getResource().getInputStream())
        {
            if (_isImage())
            {
                // it's an image (which must be resized or not)
                int i = _file.getName().lastIndexOf('.');
                String format = i != -1 ? _file.getName().substring(i + 1) : "png";
                format = _allowedFormats.contains(format) ? format : "png";
                ImageHelper.generateThumbnail(is, out, format, _height, _width, _maxHeight, _maxWidth, _cropHeight, _cropWidth);
            }
            else
            {
                Response response = ObjectModelHelper.getResponse(objectModel);
                response.setHeader("Content-Length", Long.toString(_file.getResource().getLength()));
                
                // Copy data in response
                IOUtils.copy(is, out);
            }
        }
        finally
        {
            IOUtils.closeQuietly(out);
        }
    }
    
    @Override
    public void recycle()
    {
        super.recycle();
        
        _file = null;
        _content = null;
    }
    
    /**
     * Determines if the file is an image
     * @return <code>true</code> if file is a image
     */
    protected boolean _isImage()
    {
        if (_width > 0 || _height > 0 || _maxHeight > 0 || _maxWidth > 0 || _cropHeight > 0 || _cropWidth > 0)
        {
            // resize is required, assume this is a image
            return true;
        }
        else
        {
            return getMimeType() != null && getMimeType().startsWith("image/");
        }
    }
    
    /** 
     * Get the rich text meta
     * @param meta The composite meta
     * @param metadataName The metadata name (with /)
     * @return The rich text meta
     */
    protected RichText _getMeta(CompositeMetadata meta, String metadataName)
    {
        int pos = metadataName.indexOf("/");
        if (pos == -1)
        {
            return meta.getRichText(metadataName);
        }
        return _getMeta(meta.getCompositeMetadata(metadataName.substring(0, pos)), metadataName.substring(pos + 1));
    }

}