/*
 *  Copyright 2021 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.path;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.Base64;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.ModifiableSource;
import org.apache.excalibur.source.ModifiableTraversableSource;
import org.apache.excalibur.source.MoveableSource;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.SourceNotFoundException;
import org.apache.excalibur.source.SourceUtil;
import org.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.source.impl.FileSource;

import org.ametys.core.util.LambdaUtils;
import org.ametys.core.util.LambdaUtils.LambdaException;

/**
 * A {@link ModifiableTraversableSource} for path objects.
 */
public class PathSource implements ModifiableTraversableSource, MoveableSource
{
    /** The file */
    protected Path _path;

    /** The scheme */
    protected String _scheme;

    /** The URI of this source */
    protected String _uri;
    
    /** The uri taking in account the final file */
    protected String _externalUri;

    /**
     * Empty constructor
     */
    protected PathSource()
    {
        // Nothing
    }
    
    /**
     * Builds a PathSource given an URI, which doesn't necessarily have to start with "file:"
     * @param uri The filURI
     * @throws SourceException If URL cannot be created
     * @throws MalformedURLException If URL is malformed
     */
    public PathSource(String uri) throws SourceException, MalformedURLException
    {
        int pos = SourceUtil.indexOfSchemeColon(uri);
        if (pos == -1)
        {
            throw new MalformedURLException("Invalid URI : " + uri);
        }

        String scheme = uri.substring(0, pos);
        String fileName = uri.substring(pos + 1);
        fileName = SourceUtil.decodePath(fileName);
        init(scheme, Path.of(fileName));
    }

    /**
     * Builds a PathSource, given an URI scheme and a Path.
     * @param scheme The scheme
     * @param path The file
     * @throws SourceException If url cannot be created
     */
    public PathSource(String scheme, Path path) throws SourceException
    {
        init(scheme, path);
    }
    
    /**
     * Builds a PathSource, given an URI scheme, URI and a Path.
     * @param scheme The scheme
     * @param uri the URI
     * @param path The file
     */
    public PathSource(String scheme, String uri, Path path)
    {
        _scheme = scheme;
        _uri = uri.replace('\\', '/');
        _path = path;
    }

    private void init(String scheme, Path path) throws SourceException
    {
        _scheme = scheme;

        String uri;
        try
        {
            uri = path.toUri().toURL().toExternalForm();
        }
        catch (MalformedURLException mue)
        {
            // Can this really happen ?
            throw new SourceException("Failed to get URL for file " + path, mue);
        }

        if (!uri.startsWith(scheme))
        {
            // Scheme is not "file:"
            uri = scheme + ':' + uri.substring(uri.indexOf(':') + 1);
        }

        _uri = uri;

        _path = path;
    }

    /**
     * Get the associated file
     * @return The underlying path
     */
    public Path getFile()
    {
        return _path;
    }

    //----------------------------------------------------------------------------------
    //  Source interface methods
    //----------------------------------------------------------------------------------

    public long getContentLength()
    {
        try
        {
            return Files.size(_path);
        }
        catch (IOException e)
        {
            return -1;
        }
    }

    public InputStream getInputStream() throws IOException, SourceNotFoundException
    {
        try
        {
            return Files.newInputStream(_path);
        }
        catch (NoSuchFileException e)
        {
            throw new SourceNotFoundException(_uri + " doesn't exist.", e);
        }
        catch (IOException e)
        {
            throw new SourceException("An error occurred while opening " + _uri + ".", e);
        }
    }

    public long getLastModified()
    {
        try
        {
            return Files.getLastModifiedTime(_path).toMillis();
        }
        catch (IOException e)
        {
            return 0;
        }
    }

    public String getMimeType()
    {
        return URLConnection.getFileNameMap().getContentTypeFor(_path.getFileName().toString());
    }

    public String getScheme()
    {
        return _scheme;

    }

    public String getURI()
    {
        try
        {
            if (_externalUri == null)
            {
                _externalUri = _uri + "?path=" + new String(Base64.getEncoder().withoutPadding().encode(_path.toUri().toURL().toExternalForm().getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); 
            }
            return _externalUri;
        }
        catch (MalformedURLException e)
        {
            throw new RuntimeException(e);
        }
    }

    public SourceValidity getValidity()
    {
        if (Files.exists(_path))
        {
            return new PathTimeStampValidity(_path);
        }
        else
        {
            return null;
        }
    }

    public void refresh()
    {
        // Nothing to do...
    }

    public boolean exists()
    {
        return Files.exists(getFile());
    }

    //----------------------------------------------------------------------------------
    //  TraversableSource interface methods
    //----------------------------------------------------------------------------------

    public Source getChild(String name) throws SourceException
    {
        if (!Files.isDirectory(_path))
        {
            throw new SourceException(getURI() + " is not a directory");
        }

        Path subPath = _path.resolve(name);
        return new PathSource(this.getScheme(), _uri + "/" + subPath.getFileName().toString(), subPath);

    }

    public Collection getChildren() throws SourceException
    {
        if (!Files.isDirectory(_path))
        {
            throw new SourceException(getURI() + " is not a directory");
        }

        // Build a PathSource object for each of the children
        try (Stream<Path> files = Files.list(_path))
        {
            return files
                    .map(LambdaUtils.wrap(path -> new PathSource(this.getScheme(), _uri + "/" + path.getFileName().toString(), path)))
                    .collect(Collectors.toList());
        }
        catch (LambdaException e)
        {
            throw (SourceException) e.getCause();
        }
        catch (IOException e)
        {
            throw new SourceException("Cannot list files under " + _path, e);
        }
    }

    public String getName()
    {
        return _path.getFileName().toString();
    }

    public Source getParent() throws SourceException
    {
        String specificPath = StringUtils.substringAfter(_uri, "://");
        int lastIndexOf = specificPath.lastIndexOf('/');
        if (lastIndexOf == -1)
        {
            return null;
        }
               
        String parentPath = specificPath.substring(0, lastIndexOf);
        if (parentPath.matches("^/*$"))
        {
            return null;
        }
        
        return new PathSource(getScheme(), parentPath, _path.getParent());
    }

    public boolean isCollection()
    {
        return Files.isDirectory(_path);
    }

    //----------------------------------------------------------------------------------
    //  ModifiableSource interface methods
    //----------------------------------------------------------------------------------

    /**
     * Get an <code>InputStream</code> where raw bytes can be written to.
     * The signification of these bytes is implementation-dependent and
     * is not restricted to a serialized XML document.
     *
     * The output stream returned actually writes to a temp file that replaces
     * the real one on close. This temp file is used as lock to forbid multiple
     * simultaneous writes. The real file is updated atomically when the output
     * stream is closed.
     *
     * The returned stream must be closed or cancelled by the calling code.
     *
     * @return a stream to write to
     * @throws ConcurrentModificationException if another thread is currently
     *         writing to this file.
     */
    public OutputStream getOutputStream() throws IOException
    {
        // Create a temp file. It will replace the right one when writing terminates,
        // and serve as a lock to prevent concurrent writes.
        Path tmpFile = getFile().getParent().resolve(getFile().getFileName() + ".tmp");

        // Can we write the file ?
        if (Files.exists(getFile()) && !Files.isWritable(getFile()))
        {
            throw new IOException("Cannot write to file " + getFile().toString());
        }

        // Check if it temp file already exists, meaning someone else currently writing
        try 
        {
            Files.createFile(tmpFile);
        }
        catch (IOException e)
        {
            throw new ConcurrentModificationException("File " + getFile().toString() + " is already being written by another thread", e);
        }

        // Return a stream that will rename the temp file on close.
        return new PathSourceOutputStream(tmpFile, this);
    }

    /**
     * Can the data sent to an <code>OutputStream</code> returned by
     * {@link #getOutputStream()} be cancelled ?
     *
     * @return true if the stream can be cancelled
     */
    public boolean canCancel(OutputStream stream)
    {
        if (stream instanceof PathSourceOutputStream)
        {
            PathSourceOutputStream fsos = (PathSourceOutputStream) stream;
            if (fsos.getSource() == this)
            {
                return fsos.canCancel();
            }
        }

        // Not a valid stream for this source
        throw new IllegalArgumentException("The stream is not associated to this source");
    }

    /**
     * Cancel the data sent to an <code>OutputStream</code> returned by
     * {@link #getOutputStream()}.
     * <p>
     * After cancel, the stream should no more be used.
     */
    public void cancel(OutputStream stream) throws SourceException
    {
        if (stream instanceof PathSourceOutputStream)
        {
            PathSourceOutputStream fsos = (PathSourceOutputStream) stream;
            if (fsos.getSource() == this)
            {
                try
                {
                    fsos.cancel();
                }
                catch (Exception e)
                {
                    throw new SourceException("Exception during cancel.", e);
                }
                return;
            }
        }

        // Not a valid stream for this source
        throw new IllegalArgumentException("The stream is not associated to this source");
    }

    /**
     * Delete the source.
     */
    public void delete() throws SourceException
    {
        if (!Files.exists(_path))
        {
            throw new SourceNotFoundException("Cannot delete non-existing file " + _path.toString());
        }
        
        try
        {
            Files.deleteIfExists(_path);
        }
        catch (IOException e)
        {
            throw new SourceException("Could not delete " + _path.toString() + " (unknown reason)", e);
        } 
    }

    //----------------------------------------------------------------------------------
    //  ModifiableTraversableSource interface methods
    //----------------------------------------------------------------------------------

    public void makeCollection() throws SourceException
    {
        try
        {
            Files.createDirectories(_path);
        }
        catch (IOException e)
        {
            throw new SourceException("Could not create collection " + this.getFile().toString(), e); 
        }
    }

    //----------------------------------------------------------------------------------
    //  MoveableSource interface methods
    //----------------------------------------------------------------------------------

    public void copyTo(Source destination) throws SourceException
    {
        try (InputStream is = this.getInputStream(); 
             OutputStream os = ((ModifiableSource) destination).getOutputStream())
        {
            SourceUtil.copy(is, os);
        }
        catch (IOException ioe)
        {
            throw new SourceException("Couldn't copy " + getURI() + " to " + destination.getURI(), ioe);
        }
    }

    public void moveTo(Source destination) throws SourceException
    {
        if (destination instanceof FileSource)
        {
            final Path dest = ((PathSource) destination).getFile();
            final Path parent = dest.getParent();

            if (parent != null)
            {
                try
                {
                 // ensure parent directories exist
                    Files.createDirectories(parent);
                }
                catch (IOException e)
                {
                    throw new SourceException("Couldn't move " + getURI() + " to " + destination.getURI(), e);
                } 
            }

            try
            {
                Files.move(_path, dest);
            }
            catch (IOException e)
            {
                throw new SourceException("Couldn't move " + getURI() + " to " + destination.getURI(), e);
            }
        }
        else
        {
            SourceUtil.move(this, destination);
        }

    }

    //----------------------------------------------------------------------------------
    //  Private helper class for ModifiableSource implementation
    //----------------------------------------------------------------------------------

    /**
     * A file outputStream that will rename the temp file to the destination file upon close()
     * and discard the temp file upon cancel().
     */
    private static class PathSourceOutputStream extends OutputStream
    {

        private OutputStream _os;
        private boolean _isClosed;
        private PathSource _source;
        private Path _tmpFile;

        public PathSourceOutputStream(Path tmpFile, PathSource source) throws IOException
        {
            _tmpFile = tmpFile;
            _os = Files.newOutputStream(tmpFile);
            _source = source;
        }

        @Override
        public void write(int b) throws IOException
        {
            _os.write(b);
        }
        
        @Override
        public void flush() throws IOException
        {
            _os.flush();
        }
        
        @Override
        public void close() throws IOException
        {
            if (!_isClosed)
            {
                _os.close();
                try
                {
                    // Delete destination file
                    Files.deleteIfExists(_source.getFile());
                    
                    // Rename temp file to destination file
                    Files.move(_tmpFile, _source.getFile());
                }
                finally
                {
                    // Ensure temp file is deleted, ie lock is released.
                    // If there was a failure above, written data is lost.
                    Files.deleteIfExists(_tmpFile);
                    _isClosed = true;
                }
            }

        }

        public boolean canCancel()
        {
            return !_isClosed;
        }

        public void cancel() throws Exception
        {
            if (_isClosed)
            {
                throw new IllegalStateException("Cannot cancel : outputstrem is already closed");
            }

            _isClosed = true;
            _os.close();
            Files.deleteIfExists(_tmpFile);
        }

        @SuppressWarnings("deprecation")
        @Override
        public void finalize() throws Throwable
        {
            super.finalize();
            if (!_isClosed)
            {
                // Something wrong happened while writing : delete temp file
                PathUtils.deleteQuietly(_tmpFile);
            }
        }

        public PathSource getSource()
        {
            return _source;
        }
    }
}