/*
 *  Copyright 2020 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.schedule;

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.quartz.JobExecutionContext;

import org.ametys.core.file.FileHelper;
import org.ametys.core.schedule.progression.ContainerProgressionTracker;
import org.ametys.plugins.core.impl.schedule.AbstractStaticSchedulable;

/**
 * Abstract schedulable to delete files or folders.
 */
public abstract class AbstractDeleteFilesSchedulable extends AbstractStaticSchedulable
{
    /** File Helper */
    protected FileHelper _fileHelper;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _fileHelper = (FileHelper) manager.lookup(FileHelper.ROLE);
    }
    
    /**
     * Get the needed values so the script can run
     * @param context the context
     * @return the configuration with needed values for deletion
     */
    protected abstract DeleteFilesConfiguration _getConfiguration(JobExecutionContext context);
    
    @Override
    public void execute(JobExecutionContext context, ContainerProgressionTracker progressionTracker) throws Exception
    {
        DeleteFilesConfiguration configuration = _getConfiguration(context);
        
        Path root = configuration.getRootPath();
        if (root == null)
        {
            throw new IOException("The path is empty.");
        }
        
        if (Files.exists(root))
        {
            DirectoryStream.Filter<Path> fileFilter = _createFileFilter(configuration);
            
            if (configuration.deleteRoot() || Files.isRegularFile(root))
            {
                _delete(root, configuration, fileFilter);
            }
            else
            {
                try (DirectoryStream<Path> entries = Files.newDirectoryStream(root))
                {
                    for (Path entry : entries)
                    {
                        _delete(entry, configuration, fileFilter);
                    }
                }
            }
        }
    }
    
    /**
     * 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 configuration the configuration for deletion
     * @param fileFilter the file filter to apply
     * @throws IOException if an error occured while exploring or deleting files
     */
    protected void _delete(Path path, DeleteFilesConfiguration configuration, DirectoryStream.Filter<Path> fileFilter) throws IOException
    {
        _fileHelper.delete(path, fileFilter, configuration.deleteRecursively(), configuration.deleteEmptyFolders());
    }
    
    /**
     * Create the file filter to delete files.
     * @param configuration The delete files configuration
     * @return a file filter
     */
    protected DirectoryStream.Filter<Path> _createFileFilter(DeleteFilesConfiguration configuration)
    {
        return new DirectoryStream.Filter<>()
        {
            @Override
            public boolean accept(Path entry) throws IOException
            {
                return Files.getLastModifiedTime(entry)
                    .toInstant()
                    .isBefore(configuration.getAgeLimit());
            }
        };
    }
    
    /**
     * Inner class to store configuration for deletion.
     */
    protected static class DeleteFilesConfiguration
    {
        private Path _rootPath;
        private boolean _deleteRoot;
        private boolean _deleteRecursively;
        private boolean _deleteEmptyFolders;
        private Instant _ageLimit;
        
        /**
         * Constructor.
         * Default values:
         *  - ageLimit = now
         *  - deleteRoot = false
         *  - deleteRecursively = true
         *  - deleteEmptyFolders = true
         * @param rootPath The root path for deletion
         */
        public DeleteFilesConfiguration(Path rootPath)
        {
            _rootPath = rootPath;
            _ageLimit = Instant.now();
            _deleteRoot = false;
            _deleteRecursively = true;
            _deleteEmptyFolders = true;
        }
        
        /**
         * Get the root folder or file to delete
         * @return a Directory or a file, that will be deleted/emptied
         */
        public Path getRootPath()
        {
            return _rootPath;
        }
        
        /**
         * Set to <code>true</code> to delete the root folder.
         * @param deleteRoot <code>true</code> to delete the root folde
         */
        public void setDeleteRoot(boolean deleteRoot)
        {
            _deleteRoot = deleteRoot;
        }
        
        /**
         * Do the root needs to be deleted or emptied ?
         * @return <code>true</code> to delete the root folder
         */
        public boolean deleteRoot()
        {
            return _deleteRoot;
        }
        
        /**
         * Set to <code>true</code> to delete files recursively.
         * @param deleteRecursively <code>true</code> to delete files recursively
         */
        public void setDeleteRecursively(boolean deleteRecursively)
        {
            _deleteRecursively = deleteRecursively;
        }
        
        /**
         * Do the folders needs to be deleted recursively ?
         * @return <code>true</code> to delete files recursively
         */
        public boolean deleteRecursively()
        {
            return _deleteRecursively;
        }
        
        /**
         * Set to <code>true</code> to delete empty folders.
         * @param deleteEmptyFolders <code>true</code> to delete empty folders
         */
        public void setDeleteEmptyFolders(boolean deleteEmptyFolders)
        {
            _deleteEmptyFolders = deleteEmptyFolders;
        }
        
        /**
         * When a folder is empty, do it needs to be deleted ?
         * @return <code>true</code> to delete empty folders
         */
        public boolean deleteEmptyFolders()
        {
            return _deleteEmptyFolders;
        }
        
        /**
         * Set the age limit of files to delete.
         * @param ageLimit The age limit
         */
        public void setAgeLimit(Instant ageLimit)
        {
            _ageLimit = ageLimit;
        }
        
        /**
         * Only delete files older than this instant.
         * @return instant, only older files will be deleted
         */
        public Instant getAgeLimit()
        {
            return _ageLimit;
        }
    }
}