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

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.servlet.multipart.Part;
import org.apache.cocoon.servlet.multipart.PartOnDisk;
import org.apache.cocoon.servlet.multipart.RejectedPart;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipFile;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.file.PathUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.excalibur.source.ModifiableTraversableSource;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.SourceUtil;
import org.apache.excalibur.source.TraversableSource;
import org.apache.excalibur.source.impl.FileSource;
import org.apache.tika.mime.MediaType;

import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.DateUtils;


/**
 * Helper for managing files and folders of a application directory such as
 * WEB-INF/params
 */
public final class FileHelper extends AbstractLogEnabled implements Component, Serviceable, Contextualizable
{
    /** The Avalon role name */
    public static final String ROLE = FileHelper.class.getName();

    /** The current user provider. */
    protected CurrentUserProvider _currentUserProvider;
    
    /** The tika provider */
    protected TikaProvider _tikaProvider;
    /** The source resolver */
    protected SourceResolver _srcResolver;

    private org.apache.cocoon.environment.Context _cocoonContext;

    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        _currentUserProvider = (CurrentUserProvider) serviceManager.lookup(CurrentUserProvider.ROLE);
        _srcResolver = (org.apache.excalibur.source.SourceResolver) serviceManager.lookup(org.apache.excalibur.source.SourceResolver.ROLE);
        _tikaProvider = (TikaProvider) serviceManager.lookup(TikaProvider.ROLE); 
    }

    public void contextualize(Context context) throws ContextException
    {
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(org.apache.cocoon.Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    /**
     * Get the files/folders of a given source 
     * @param rootURI The uri of root folder
     * @param path The path of folder in root folder
     * @return the child files and folders as JSON representation
     * @throws IOException if an error occurred
     */
    public List<Map<String, Object>> getFiles(String rootURI, String path) throws IOException
    {
        return getFiles(rootURI, path, List.of());
    }
    
    /**
     * Get files and folders contained in the given path.
     * @param rootURI The uri of root folder
     * @param path the relative file's path from files root directory
     * @param ignoredSources The names of source to ignore
     * @return the list of parameters files and folders as JSON representation
     * @throws IOException If an error occurred while listing files
     */
    public List<Map<String, Object>> getFiles(String rootURI, String path, List<String> ignoredSources) throws IOException
    {
        TraversableSource rootDir = (TraversableSource) _srcResolver.resolveURI(rootURI);
        TraversableSource currentDir = (TraversableSource) _srcResolver.resolveURI(rootURI + (path.length() > 0 ? "/" + path : ""));

        if (!currentDir.exists() || !currentDir.isCollection())
        {
            throw new IOException("The source folder '" + currentDir.getURI() + "' does not exist or is not a folder.");
        }
        
        List<Map<String, Object>> nodes = new ArrayList<>();
        
        for (TraversableSource child : (Collection<TraversableSource>) currentDir.getChildren())
        {
            if (!ignoredSources.contains(child.getName()))
            {
                if (child.isCollection())
                {
                    nodes.add(getFolderProperties(child, rootDir));
                }
                else
                {
                    nodes.add(getFileProperties(child, rootDir));
                }
            }
        }
        return nodes;
    }
    
    /**
     * Convert collection to JSON object
     * @param folder the folder
     * @param root the root directory
     * @return JSON object
     */
    public Map<String, Object> getFolderProperties (TraversableSource folder, TraversableSource root)
    {
        Map<String, Object> jsonObject = new HashMap<>();
        jsonObject.put("type", "collection");
        jsonObject.put("name", folder.getName());
        jsonObject.put("path", _getRelativePath(root, folder));
        return jsonObject;
    }
    
    /**
     * Convert file to JSON object
     * @param file the file
     * @param root the root directory
     * @return JSON object
     */
    public Map<String, Object> getFileProperties (TraversableSource file, TraversableSource root)
    {
        Map<String, Object> jsonObject = new HashMap<>();
        
        jsonObject.put("type", "resource");
        jsonObject.put("name", file.getName());
        jsonObject.put("path", _getRelativePath(root, file));
        
        jsonObject.put("size", file.getContentLength());
        jsonObject.put("lastModified", DateUtils.dateToString(new Date(file.getLastModified())));
        
        String mimeType = _cocoonContext.getMimeType(file.getName().toLowerCase());
        jsonObject.put("mimetype", mimeType != null ? mimeType : "application/unknown");
        
        return jsonObject;
    }
    
    /**
     * Get the relative path from root directory
     * @param root The root directory
     * @param file The file
     * @return The relative path
     */
    protected String _getRelativePath (TraversableSource root, TraversableSource file)
    {
        String relPath = file.getURI().substring(root.getURI().length());
        
        if (relPath.endsWith("/"))
        {
            relPath = relPath.substring(0, relPath.length() - 1);
        }
        
        return relPath;
    }
    
    /**
     * Saves text to given file in UTF-8 format
     * 
     * @param fileURI the file URI. Must point to an existing file.
     * @param text the UTF-8 file content
     * @return A result map.
     * @throws IOException If an error occurred while saving
     */
    public Map<String, Object> saveFile(String fileURI, String text) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        ModifiableTraversableSource src = null;
        try
        {
            src = (ModifiableTraversableSource) _srcResolver.resolveURI(fileURI);
                
            if (!src.exists())
            {
                result.put("success", false);
                result.put("error", "unknown-file");
                return result;
            }
    
            if (src.isCollection())
            {
                result.put("success", false);
                result.put("error", "is-not-file");
                return result;
            }
    
            try (OutputStream os = src.getOutputStream())
            {
                IOUtils.write(text, os, StandardCharsets.UTF_8);
            }
    
            if (src.getName().startsWith("messages") && src.getName().endsWith(".xml"))
            {
                result.put("isI18n", true);
            }
        }
        finally 
        {
            _srcResolver.release(src);
        }

        result.put("success", true);
        return result;
    }

    /**
     * Create a folder
     * 
     * @param parentURI the parent URI, relative to the root
     * @param name the name of the new folder to create
     * @param renameIfExists true if the folder have to be renamed if the folder
     *            with same name already exits.
     * @return The result Map with the name and uri of created folder, or a
     *         boolean "success" to false if an error occurs.
     * @throws IOException If an error occurred adding the folder
     */
    public Map<String, Object> addFolder(String parentURI, String name, boolean renameIfExists) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        FileSource parentDir = (FileSource) _srcResolver.resolveURI(parentURI);

        if (!parentDir.isCollection())
        {
            result.put("success", false);
            result.put("error", "is-not-folder");
            return result;
        }

        int index = 2;
        String folderName = name;

        if (!renameIfExists && parentDir.getChild(folderName).exists())
        {
            result.put("success", false);
            result.put("error", "already-exist");
            return result;
        }

        while (parentDir.getChild(folderName).exists())
        {
            folderName = name + " (" + index + ")";
            index++;
        }

        FileSource folder = (FileSource) parentDir.getChild(folderName);
        folder.makeCollection();

        result.put("success", true);
        result.put("name", folder.getName());
        result.put("uri", folder.getURI());

        return result;
    }

    /**
     * Add or update a file
     * 
     * @param part The file multipart to upload
     * @param parentDir The parent directory
     * @param mode The insertion mode: 'add-rename' or 'update' or null.
     * @param unzip true to unzip .zip file
     * @return the result map
     * @throws IOException If an error occurred manipulating the file
     */
    public Map<String, Object> addOrUpdateFile(Part part, FileSource parentDir, String mode, boolean unzip) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        if (!(part instanceof PartOnDisk))
        {
            result.put("success", false);
            if (part instanceof RejectedPart rejectedPart && rejectedPart.getMaxContentLength() == 0)
            {
                result.put("error", "infected");
            }
            else // if (part == null || partUploaded instanceof RejectedPart)
            {
                result.put("error", "rejected");
            }
            return result;
        }

        PartOnDisk uploadedFilePart = (PartOnDisk) part;
        File uploadedFile = uploadedFilePart.getFile();

        String fileName = uploadedFile.getName();
        FileSource file = (FileSource) parentDir.getChild(fileName);
        if (fileName.toLowerCase().endsWith(".zip") && unzip)
        {
            try
            {
                // Unzip the uploaded file
                _unzip(parentDir, new ZipFile(uploadedFile, "cp437"));

                result.put("unzip", true);
                result.put("success", true);
                return result;
            }
            catch (IOException e)
            {
                getLogger().error("Failed to unzip file " + uploadedFile.getPath(), e);
                result.put("success", false);
                result.put("error", "unzip-error");
                return result;
            }
        }
        else if (file.exists())
        {
            if ("add-rename".equals(mode))
            {
                // Find a new name
                String[] f = fileName.split("\\.");
                int index = 1;
                while (parentDir.getChild(fileName).exists())
                {
                    fileName = f[0] + "-" + (index++) + '.' + f[1];
                }

                file = (FileSource) parentDir.getChild(fileName);
            }
            else if (!"update".equals(mode))
            {
                result.put("success", false);
                result.put("error", "already-exist");
                return result;
            }
        }
        else
        {
            file.getFile().createNewFile();
        }

        InputStream is = new FileInputStream(uploadedFile);

        SourceUtil.copy(is, file.getOutputStream());

        result.put("name", file.getName());
        result.put("uri", file.getURI());
        result.put("success", true);

        return result;
    }
    
    private void _unzip(FileSource destSrc, ZipFile zipFile) throws IOException
    {
        Enumeration<ZipArchiveEntry> entries = zipFile.getEntries();
        while (entries.hasMoreElements())
        {
            FileSource parentCollection = destSrc;

            ZipArchiveEntry zipEntry = entries.nextElement();

            String zipName = zipEntry.getName();
            String[] path = zipName.split("/");

            for (int i = 0; i < path.length - 1; i++)
            {
                String name = path[i];
                parentCollection = _addCollection(parentCollection, name);
            }

            String name = path[path.length - 1];
            if (zipEntry.isDirectory())
            {
                parentCollection = _addCollection(parentCollection, name);
            }
            else
            {
                _addZipEntry(parentCollection, zipFile, zipEntry, name);
            }
        }
    }

    private FileSource _addCollection(FileSource collection, String name) throws IOException
    {
        FileSource src = (FileSource) collection.getChild(name);
        if (!src.exists())
        {
            src.makeCollection();
        }

        return src;
    }

    private void _addZipEntry(FileSource collection, ZipFile zipFile, ZipArchiveEntry zipEntry, String fileName) throws IOException
    {
        FileSource fileSrc = (FileSource) collection.getChild(fileName);

        try (InputStream is = zipFile.getInputStream(zipEntry))
        {
            SourceUtil.copy(is, fileSrc.getOutputStream());
        }
        catch (IOException e)
        {
            // Do nothing
        }
    }

    /**
     * Remove a folder or a file
     * 
     * @param fileUri the file/folder URI
     * @return the result map.
     * @throws IOException If an error occurs while removing the folder/file
     */
    public Map<String, Object> deleteFile(String fileUri) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        FileSource file = (FileSource) _srcResolver.resolveURI(fileUri);

        if (file.exists())
        {
            FileUtils.deleteQuietly(file.getFile());
            result.put("success", true);
        }
        else
        {
            result.put("success", false);
            result.put("error", "no-exists");
        }

        return result;
    }
    
    /**
     * Delete all files corresponding to the file filter into the file tree.
     * @param path the path to delete (can be a file or a directory)
     * @param fileFilter the file filter to apply
     * @param recursiveDelete if <code>true</code>, the file tree will be explored to delete files
     * @param deleteEmptyDirs if <code>true</code>, empty dirs will be deleted
     * @throws IOException if an error occured while exploring or deleting files
     */
    public void delete(Path path, DirectoryStream.Filter<Path> fileFilter, boolean recursiveDelete, boolean deleteEmptyDirs) throws IOException
    {
        if (Files.isDirectory(path))
        {
            if (recursiveDelete)
            {
                try (DirectoryStream<Path> entries = Files.newDirectoryStream(path))
                {
                    for (Path entry : entries)
                    {
                        delete(entry, fileFilter, recursiveDelete, deleteEmptyDirs);
                    }
                }
            }
            
            if (deleteEmptyDirs && PathUtils.isEmptyDirectory(path))
            {
                Files.delete(path);
            }
        }
        else if (fileFilter.accept(path))
        {
            Files.delete(path);
        }
    }

    /**
     * Rename a file or a folder
     * 
     * @param fileUri the relative URI of the file or folder to rename
     * @param name the new name of the file/folder
     * @return The result Map with the name, path of the renamed file/folder, or
     *         a boolean "already-exist" is a file/folder already exists with
     *         this name.
     * @throws IOException if an error occurs while renaming the file/folder
     */
    public Map<String, Object> renameFile(String fileUri, String name) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        FileSource file = (FileSource) _srcResolver.resolveURI(fileUri);
        FileSource parentDir = (FileSource) file.getParent();

        // Case sensitive exists
        if (file.getFile().getName().equals(name) && parentDir.getChild(name).exists())
        {
            result.put("success", false);
            result.put("error", "already-exist");
        }
        else
        {
            Source dest = _srcResolver.resolveURI(parentDir.getURI() + name);
            file.moveTo(dest);

            result.put("success", true);
            result.put("uri", parentDir.getURI() + name);
            result.put("name", name);
        }

        return result;
    }

    /**
     * Tests if a file/folder with given name exists
     * 
     * @param parentUri the parent folder URI
     * @param name the name of the child
     * @return true if the file exists
     * @throws IOException if an error occurred
     */
    public boolean hasChild(String parentUri, String name) throws IOException
    {
        FileSource currentDir = (FileSource) _srcResolver.resolveURI(parentUri);
        return currentDir.getChild(name).exists();
    }

    /**
     * Copy a file or folder
     * 
     * @param srcUri The URI of file/folder to copy
     * @param parentTargetUri The URI of parent target file
     * @return a result map with the name and uri of copied file in case of
     *         success.
     * @throws IOException If an error occured manipulating the source
     */
    public Map<String, Object> copySource(String srcUri, String parentTargetUri) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        FileSource srcFile = (FileSource) _srcResolver.resolveURI(srcUri);

        if (!srcFile.exists())
        {
            result.put("success", false);
            result.put("error", "no-exists");
            return result;
        }

        String srcFileName = srcFile.getName();
        FileSource targetFile = (FileSource) _srcResolver.resolveURI(parentTargetUri + (srcFileName.length() > 0 ? "/" + srcFileName : ""));

        // Find unique file name
        int index = 2;
        String fileName = srcFileName;
        while (targetFile.exists())
        {
            fileName = srcFileName + " (" + index + ")";
            targetFile = (FileSource) _srcResolver.resolveURI(parentTargetUri + (fileName.length() > 0 ? "/" + fileName : ""));
            index++;
        }

        if (srcFile.getFile().isDirectory())
        {
            FileUtils.copyDirectory(srcFile.getFile(), targetFile.getFile());
        }
        else
        {
            FileUtils.copyFile(srcFile.getFile(), targetFile.getFile());
        }

        result.put("success", true);
        result.put("name", targetFile.getName());
        result.put("uri", targetFile.getURI());

        return result;
    }

    /**
     * Move a file or folder
     * 
     * @param srcUri The URI of file/folder to move
     * @param parentTargetUri The URI of parent target file
     * @return a result map with the name and uri of moved file in case of
     *         success.
     * @throws IOException If an error occurred manipulating the source
     */
    public Map<String, Object> moveSource(String srcUri, String parentTargetUri) throws IOException
    {
        Map<String, Object> result = new HashMap<>();

        FileSource srcFile = (FileSource) _srcResolver.resolveURI(srcUri);

        if (!srcFile.exists())
        {
            result.put("success", false);
            result.put("error", "no-exists");
            return result;
        }

        FileSource parentDargetDir = (FileSource) _srcResolver.resolveURI(parentTargetUri);
        String fileName = srcFile.getName();
        FileSource targetFile = (FileSource) _srcResolver.resolveURI(parentTargetUri + (fileName.length() > 0 ? "/" + fileName : ""));

        if (targetFile.exists())
        {
            result.put("msg", "already-exists");
            return result;
        }

        FileUtils.moveToDirectory(srcFile.getFile(), parentDargetDir.getFile(), false);

        result.put("success", true);
        result.put("name", targetFile.getName());
        result.put("uri", targetFile.getURI());

        return result;
    }
    
    /**
     * Get the URIs of sources which match filter value. Source are filtered both on their filename and in their content for text file.
     * The search will be performed on the current source and all its descendants
     * @param source The source to start search
     * @param value the value to match
     * @return the URIs of matching source
     */
    public List<String> filterSources(TraversableSource source, String value)
    {
        return _filterSources(source, _standardizeValue(value));
    }
        
    private List<String> _filterSources(TraversableSource source, String value)
    {
        List<String> matches = new ArrayList<>();
        if (source.isCollection())
        {
            // Check if the collection match
            if (_sourceNameMatch(source, value))
            {
                matches.add(source.getURI());
            }
            
            // Check if any children match
            try
            {
                Collection<TraversableSource> children = source.getChildren();
                for (TraversableSource child : children)
                {
                    matches.addAll(_filterSources(child, value));
                }
            }
            catch (IOException e)
            {
                getLogger().error("Failed to retrieve children for source '" + source.getURI() + "'. Potential children will be ignored.");
            }
        }
        else if (_resourceMatch(source, value))
        {
            matches.add(source.getURI());
        }
        
        return matches;
        
    }
    // pre-process string before comparison
    private String _standardizeValue(String value)
    {
        return value.toLowerCase();
    }

    private boolean _resourceMatch(TraversableSource currentSrc, String value)
    {
        if (_sourceNameMatch(currentSrc, value))
        {
            return true;
        }
        else
        {
            // detect always return something as "application/octet-stream" if nothing else
            MediaType mediaType = MediaType.parse(_tikaProvider.getTika().detect(currentSrc.getName()));
            // Only read the file if its a text file.
            // We will be able to read line by line that way
            // without loading all the file at once
            if (_isSupportedType(mediaType))
            {
                try (InputStream is = currentSrc.getInputStream())
                {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8)); // We just hope its actually UTF-8
                    String line;
                    while ((line = reader.readLine()) != null)
                    {
                        if (_standardizeValue(line).contains(value))
                        {
                            return true;
                        }
                    }
                }
                catch (IOException e)
                {
                    getLogger().error("An error occurred while trying to read the definition file at '" + currentSrc.getURI() + "'", e);
                }
            }
        }
        return false;
    }

    private boolean _isSupportedType(MediaType mediaType)
    {
        String type = mediaType.getType();
        if (StringUtils.equals(type, "text"))
        {
            return true;
        }
        else if (StringUtils.equals(type, "application"))
        {
            String subtype = mediaType.getSubtype();
            return StringUtils.equals(subtype, "xml")
                || StringUtils.contains(subtype, "+xml")    // + to avoid matching mybinaryxmltype
                || StringUtils.equals(subtype, "json")
                || StringUtils.contains(subtype, "+json");  // + to avoid matching mybinaryjsontype
        }
        return false;
    }

    private boolean _sourceNameMatch(TraversableSource currentSrc, String value)
    {
        return _standardizeValue(currentSrc.getName()).contains(value);
    }
}