/*
 *  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.cms.data;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.ZonedDateTime;
import java.util.Optional;

import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;

/**
 * Class representing a resource
 */
public class Resource
{
    /** Empty array */
    private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    /** Max size for keeping temporary data in memory */
    private static final int MAX_BUFFER_SIZE = 0x10000;
    
    /** The resource's mime type */
    protected String _mimeType;
    
    /** The resource's encoding */
    protected String _encoding;
    
    /** The resource's last modification date */
    protected ZonedDateTime _lastModificationDate;
    
    /** Underlying tmp file */
    protected File _tmpFile;

    /** Buffer for small-sized data */
    protected byte[] _buffer = EMPTY_BYTE_ARRAY;
    
    /** The resource's repository data */
    protected RepositoryData _repositoryData;
    
    /**
     * Default constructor
     */
    public Resource()
    {
        // Empty constructor
    }
    
    /**
     * Constructor to use when reading the resource from the repository
     * @param repositoryData the repository data containing the resource's data
     */
    public Resource(RepositoryData repositoryData)
    {
        _repositoryData = repositoryData;
    }

    /**
     * Retrieve the resource's data
     * If the data has already been read, the stream is reseted so it can be read again from the start
     * @return the resource's data, or <code>null</code> if there is no data
     */
    public InputStream getInputStream()
    {
        if (_repositoryData != null)
        {
            if (_repositoryData.hasValue("data", "jcr"))
            {
                return _repositoryData.getStream("data", "jcr");
            }
            else
            {
                return null;
            }
        }
        else if (_tmpFile != null)
        {
            try 
            {
                // this instance is backed by a temp file
                return new FileInputStream(_tmpFile);
            }
            catch (FileNotFoundException e)
            {
                return null;
            }
        }
        else if (_buffer.length > 0)
        {
            // this instance is backed by an in-memory buffer
            return new ByteArrayInputStream(_buffer);
        }
        else
        {
            return null;
        }
    }

    /**
     * Retrieves the length of the resource's data
     * @return the length of the resource's data
     * @throws AmetysRepositoryException if an error occurs while reading the data in the repository
     */
    public long getLength() throws AmetysRepositoryException
    {
        if (_repositoryData != null)
        {
            return _repositoryData.getStreamLength("data", "jcr");
        }
        else if (_tmpFile != null)
        {
            return _tmpFile.length();
        }
        else
        {
            return _buffer.length;
        }
    }
    
    /**
     * Sets the resource's data
     * @param in the data to set
     * @throws IOException if an error occurs while reading the input stream
     */
    public void setInputStream(InputStream in) throws IOException
    {
        byte[] spoolBuffer = new byte[0x2000];
        int read;
        int len = 0;
        @SuppressWarnings("resource")
        OutputStream out = null;
        File spoolFile = null;
        try 
        {
            while ((read = in.read(spoolBuffer)) > 0)
            {
                if (out != null)
                {
                    // spool to temporary file
                    out.write(spoolBuffer, 0, read);
                    len += read;
                }
                else if (len + read > MAX_BUFFER_SIZE)
                {
                    // threshold for keeping data in memory exceeded;
                    // create temporary file and spool buffer contents
                    spoolFile = File.createTempFile("bin", null, null);
                    spoolFile.deleteOnExit();
                    out = new FileOutputStream(spoolFile);
                    out.write(_buffer, 0, len);
                    out.write(spoolBuffer, 0, read);
                    _buffer = null;
                    len += read;
                }
                else
                {
                    // reallocate new buffer and spool old buffer contents
                    byte[] newBuffer = new byte[len + read];
                    System.arraycopy(_buffer, 0, newBuffer, 0, len);
                    System.arraycopy(spoolBuffer, 0, newBuffer, len, read);
                    _buffer = newBuffer;
                    len += read;
                }
            }
        }
        finally
        {
            if (out != null)
            {
                out.close();
            }
        }

        // init fields
        if (_tmpFile != null)
        {
            _tmpFile.delete();
        }
        _tmpFile = spoolFile;
        _repositoryData = null;
    }

    /**
     * Retrieves an output stream that allows to modify the resource's data
     * @return the output stream
     */
    public OutputStream getOutputStream()
    {
        return new ByteArrayOutputStream()
        {
            @Override
            public void close() throws IOException
            {
                super.close();
                closeOutputStream(this);
            }
        };
    }
    
    /**
     * Closes the given {@link OutputStream}
     * @param outputStream the {@link OutputStream} to close
     * @throws IOException if an error occurs while registering the stream
     */
    protected void closeOutputStream(ByteArrayOutputStream outputStream) throws IOException
    {
        _buffer = outputStream.toByteArray();
        if (_tmpFile != null)
        {
            _tmpFile.delete();
        }
        _repositoryData = null;
    }
    
    /**
     * Retrieves the mime type of the resource's data
     * @return the mime type of the resource's data
     */
    public String getMimeType()
    {
        return _mimeType;
    }

    /**
     * Sets the mime type of the resource's data
     * @param mimeType the mime type to set
     */
    public void setMimeType(String mimeType)
    {
        _mimeType = mimeType;
    }

    /**
     * Retrieves the encoding of the resource's data
     * @return the encoding of the resource's data
     */
    public String getEncoding()
    {
        return _encoding;
    }

    /**
     * Sets the encoding of the resource's data
     * @param encoding the encoding to set
     */
    public void setEncoding(String encoding)
    {
        _encoding = encoding;
    }

    /**
     * Retrieves the last modification date of the resource's data
     * @return the last modification date of the resource's data
     */
    public ZonedDateTime getLastModificationDate()
    {
        return _lastModificationDate;
    }

    /**
     * Sets the last modification date of the resource's data
     * @param lastModificationDate the last modification date to set
     */
    public void setLastModificationDate(ZonedDateTime lastModificationDate)
    {
        _lastModificationDate = lastModificationDate;
    }
    
    /**
     * Retrieves the resource's repository data
     * @return the resource's repository data
     */
    public Optional<RepositoryData> getRepositoryData()
    {
        return Optional.ofNullable(_repositoryData);
    }
}