/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.commons.vfs2.impl;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.ThreadFactory;
import java.util.stream.Stream;

import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.vfs2.FileListener;
import org.apache.commons.vfs2.FileMonitor;
import org.apache.commons.vfs2.FileName;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSystemException;
import org.apache.commons.vfs2.provider.AbstractFileSystem;

/**
 * A polling {@link FileMonitor} implementation.
 * <p>
 * The DefaultFileMonitor is a Thread based polling file system monitor with a 1 second delay.
 * </p>
 *
 * <h2>Design:</h2>
 * <p>
 * There is a Map of monitors known as FileMonitorAgents. With the thread running, each FileMonitorAgent object is asked
 * to "check" on the file it is responsible for. To do this check, the cache is cleared.
 * </p>
 * <ul>
 * <li>If the file existed before the refresh and it no longer exists, a delete event is fired.</li>
 * <li>If the file existed before the refresh and it still exists, check the last modified timestamp to see if that has
 * changed.</li>
 * <li>If it has, fire a change event.</li>
 * </ul>
 * <p>
 * With each file delete, the FileMonitorAgent of the parent is asked to re-build its list of children, so that they can
 * be accurately checked when there are new children.
 * </p>
 * <p>
 * New files are detected during each "check" as each file does a check for new children. If new children are found,
 * create events are fired recursively if recursive descent is enabled.
 * </p>
 * <p>
 * For performance reasons, added a delay that increases as the number of files monitored increases. The default is a
 * delay of 1 second for every 1000 files processed.
 * </p>
 * <h2>Example usage:</h2>
 *
 * <pre>
 * FileSystemManager fsManager = VFS.getManager();
 * FileObject listenDir = fsManager.resolveFile("/home/username/monitored/");
 *
 * DefaultFileMonitor fm = new DefaultFileMonitor(new CustomFileListener());
 * fm.setRecursive(true);
 * fm.addFile(listenDir);
 * fm.start();
 * </pre>
 *
 * <em>(where CustomFileListener is a class that implements the FileListener interface.)</em>
 */
// TODO Add a Builder so we can construct and start.
public class DefaultFileMonitor implements Runnable, FileMonitor, AutoCloseable {

    /**
     * File monitor agent.
     */
    private static final class FileMonitorAgent {

        private final FileObject fileObject;
        private final DefaultFileMonitor defaultFileMonitor;
        private boolean exists;
        private long timestamp;
        private Map<FileName, Object> children;

        private FileMonitorAgent(final DefaultFileMonitor defaultFileMonitor, final FileObject fileObject) {
            this.defaultFileMonitor = defaultFileMonitor;
            this.fileObject = fileObject;

            refresh();
            resetChildrenList();

            try {
                exists = fileObject.exists();
            } catch (final FileSystemException fse) {
                exists = false;
                timestamp = -1;
            }

            if (exists) {
                try {
                    timestamp = fileObject.getContent().getLastModifiedTime();
                } catch (final FileSystemException fse) {
                    timestamp = -1;
                }
            }
        }

        private void check() {
            refresh();

            try {
                // If the file existed and now doesn't
                if (exists && !fileObject.exists()) {
                    exists = fileObject.exists();
                    timestamp = -1;

                    // Fire delete event

                    ((AbstractFileSystem) fileObject.getFileSystem()).fireFileDeleted(fileObject);

                    // Remove listener in case file is re-created. Don't want to fire twice.
                    if (defaultFileMonitor.getFileListener() != null) {
                        fileObject.getFileSystem().removeListener(fileObject, defaultFileMonitor.getFileListener());
                    }

                    // Remove from map
                    defaultFileMonitor.queueRemoveFile(fileObject);
                } else if (exists && fileObject.exists()) {

                    // Check the timestamp to see if it has been modified
                    if (timestamp != fileObject.getContent().getLastModifiedTime()) {
                        timestamp = fileObject.getContent().getLastModifiedTime();
                        // Fire change event

                        // Don't fire if it's a folder because new file children
                        // and deleted files in a folder have their own event triggered.
                        if (!fileObject.getType().hasChildren()) {
                            ((AbstractFileSystem) fileObject.getFileSystem()).fireFileChanged(fileObject);
                        }
                    }

                } else if (!exists && fileObject.exists()) {
                    exists = fileObject.exists();
                    timestamp = fileObject.getContent().getLastModifiedTime();
                    // Don't fire if it's a folder because new file children
                    // and deleted files in a folder have their own event triggered.
                    if (!fileObject.getType().hasChildren()) {
                        ((AbstractFileSystem) fileObject.getFileSystem()).fireFileCreated(fileObject);
                    }
                }

                checkForNewChildren();

            } catch (final FileSystemException fse) {
                LOG.error(fse.getLocalizedMessage(), fse);
            }
        }

        /**
         * Only checks for new children. If children are removed, they'll eventually be checked.
         */
        private void checkForNewChildren() {
            try {
                if (fileObject.getType().hasChildren()) {
                    final FileObject[] newChildren = fileObject.getChildren();
                    if (children != null) {
                        // See which new children are not listed in the current children map.
                        final Map<FileName, Object> newChildrenMap = new HashMap<>();
                        final Stack<FileObject> missingChildren = new Stack<>();

                        for (final FileObject element : newChildren) {
                            newChildrenMap.put(element.getName(), new Object()); // null ?
                            // If the child's not there
                            if (!children.containsKey(element.getName())) {
                                missingChildren.push(element);
                            }
                        }

                        children = newChildrenMap;

                        // If there were missing children
                        if (!missingChildren.empty()) {

                            while (!missingChildren.empty()) {
                                fireAllCreate(missingChildren.pop());
                            }
                        }

                    } else if (newChildren.length > 0) {
                        // First set of children - Break out the cigars
                        children = new HashMap<>();
                        for (final FileObject element : newChildren) {
                            children.put(element.getName(), new Object()); // null?
                            fireAllCreate(element);
                        }
                    }
                }
            } catch (final FileSystemException fse) {
                LOG.error(fse.getLocalizedMessage(), fse);
            }
        }

        /**
         * Recursively fires create events for all children if recursive descent is enabled. Otherwise the create event is only
         * fired for the initial FileObject.
         *
         * @param child The child to add.
         */
        private void fireAllCreate(final FileObject child) {
            // Add listener so that it can be triggered
            if (defaultFileMonitor.getFileListener() != null) {
                child.getFileSystem().addListener(child, defaultFileMonitor.getFileListener());
            }

            ((AbstractFileSystem) child.getFileSystem()).fireFileCreated(child);

            // Remove it because a listener is added in the queueAddFile
            if (defaultFileMonitor.getFileListener() != null) {
                child.getFileSystem().removeListener(child, defaultFileMonitor.getFileListener());
            }

            defaultFileMonitor.queueAddFile(child); // Add

            try {
                if (defaultFileMonitor.isRecursive() && child.getType().hasChildren()) {
                    Stream.of(child.getChildren()).forEach(this::fireAllCreate);
                }
            } catch (final FileSystemException fse) {
                LOG.error(fse.getLocalizedMessage(), fse);
            }
        }

        /**
         * Clear the cache and re-request the file object.
         */
        private void refresh() {
            try {
                fileObject.refresh();
            } catch (final FileSystemException fse) {
                LOG.error(fse.getLocalizedMessage(), fse);
            }
        }

        private void resetChildrenList() {
            try {
                if (fileObject.getType().hasChildren()) {
                    children = new HashMap<>();
                    for (final FileObject element : fileObject.getChildren()) {
                        children.put(element.getName(), new Object()); // null?
                    }
                }
            } catch (final FileSystemException fse) {
                children = null;
            }
        }

    }

    private static final ThreadFactory THREAD_FACTORY = new BasicThreadFactory.Builder().daemon(true).priority(Thread.MIN_PRIORITY).build();

    private static final Log LOG = LogFactory.getLog(DefaultFileMonitor.class);

    private static final Duration DEFAULT_DELAY = Duration.ofSeconds(1);

    private static final int DEFAULT_MAX_FILES = 1000;

    /**
     * Map from FileName to FileObject being monitored.
     */
    private final Map<FileName, FileMonitorAgent> monitorMap = new HashMap<>();

    /**
     * The low priority thread used for checking the files being monitored.
     */
    private Thread monitorThread;

    /**
     * File objects to be removed from the monitor map.
     */
    private final Stack<FileObject> deleteStack = new Stack<>();

    /**
     * File objects to be added to the monitor map.
     */
    private final Stack<FileObject> addStack = new Stack<>();

    /**
     * A flag used to determine if the monitor thread should be running.
     */
    private volatile boolean runFlag = true; // used for inter-thread communication

    /**
     * A flag used to determine if adding files to be monitored should be recursive.
     */
    private boolean recursive;

    /**
     * Sets the delay between checks
     */
    private Duration delay = DEFAULT_DELAY;

    /**
     * Sets the number of files to check until a delay will be inserted
     */
    private int checksPerRun = DEFAULT_MAX_FILES;

    /**
     * A listener object that if set, is notified on file creation and deletion.
     */
    private final FileListener listener;

    /**
     * Constructs a new instance with the given listener.
     *
     * @param listener the listener.
     */
    public DefaultFileMonitor(final FileListener listener) {
        this.listener = listener;
    }

    /**
     * Adds a file to be monitored.
     *
     * @param file The FileObject to monitor.
     */
    @Override
    public void addFile(final FileObject file) {
        synchronized (monitorMap) {
            if (monitorMap.get(file.getName()) == null) {
                monitorMap.put(file.getName(), new FileMonitorAgent(this, file));

                try {
                    if (listener != null) {
                        file.getFileSystem().addListener(file, listener);
                    }

                    if (file.getType().hasChildren() && recursive) {
                        // Traverse the children
                        // Add depth first
                        Stream.of(file.getChildren()).forEach(this::addFile);
                    }

                } catch (final FileSystemException fse) {
                    LOG.error(fse.getLocalizedMessage(), fse);
                }

            }
        }
    }

    @Override
    public void close() {
        runFlag = false;
        if (monitorThread != null) {
            monitorThread.interrupt();
            try {
                monitorThread.join();
            } catch (final InterruptedException e) {
                // ignore
            }
            monitorThread = null;
        }
    }

    /**
     * Gets the number of files to check per run.
     *
     * @return The number of files to check per iteration.
     */
    public int getChecksPerRun() {
        return checksPerRun;
    }

    /**
     * Gets the delay between runs.
     *
     * @return The delay period in milliseconds.
     * @deprecated Use {@link #getDelayDuration()}.
     */
    @Deprecated
    public long getDelay() {
        return delay.toMillis();
    }

    /**
     * Gets the delay between runs.
     *
     * @return The delay period.
     */
    public Duration getDelayDuration() {
        return delay;
    }

    /**
     * Gets the current FileListener object notified when there are changes with the files added.
     *
     * @return The FileListener.
     */
    FileListener getFileListener() {
        return listener;
    }

    /**
     * Tests the recursive setting when adding files for monitoring.
     *
     * @return true if monitoring is enabled for children.
     */
    public boolean isRecursive() {
        return recursive;
    }

    /**
     * Queues a file for addition to be monitored.
     *
     * @param file The FileObject to add.
     */
    protected void queueAddFile(final FileObject file) {
        addStack.push(file);
    }

    /**
     * Queues a file for removal from being monitored.
     *
     * @param file The FileObject to be removed from being monitored.
     */
    protected void queueRemoveFile(final FileObject file) {
        deleteStack.push(file);
    }

    /**
     * Removes a file from being monitored.
     *
     * @param file The FileObject to remove from monitoring.
     */
    @Override
    public void removeFile(final FileObject file) {
        synchronized (monitorMap) {
            final FileName fn = file.getName();
            if (monitorMap.get(fn) != null) {
                FileObject parent;
                try {
                    parent = file.getParent();
                } catch (final FileSystemException fse) {
                    parent = null;
                }

                monitorMap.remove(fn);

                if (parent != null) { // Not the root
                    final FileMonitorAgent parentAgent = monitorMap.get(parent.getName());
                    if (parentAgent != null) {
                        parentAgent.resetChildrenList();
                    }
                }
            }
        }
    }

    /**
     * Asks the agent for each file being monitored to check its file for changes.
     */
    @Override
    public void run() {
        mainloop: while (!monitorThread.isInterrupted() && runFlag) {
            // For each entry in the map
            final Object[] fileNames;
            synchronized (monitorMap) {
                fileNames = monitorMap.keySet().toArray();
            }
            for (int iterFileNames = 0; iterFileNames < fileNames.length; iterFileNames++) {
                final FileName fileName = (FileName) fileNames[iterFileNames];
                final FileMonitorAgent agent;
                synchronized (monitorMap) {
                    agent = monitorMap.get(fileName);
                }
                if (agent != null) {
                    agent.check();
                }

                if (getChecksPerRun() > 0 && (iterFileNames + 1) % getChecksPerRun() == 0) {
                    try {
                        Thread.sleep(getDelayDuration().toMillis());
                    } catch (final InterruptedException e) {
                        // Woke up.
                    }
                }

                if (monitorThread.isInterrupted() || !runFlag) {
                    continue mainloop;
                }
            }

            while (!addStack.empty()) {
                addFile(addStack.pop());
            }

            while (!deleteStack.empty()) {
                removeFile(deleteStack.pop());
            }

            try {
                Thread.sleep(getDelayDuration().toMillis());
            } catch (final InterruptedException e) {
                continue;
            }
        }

        runFlag = true;
    }

    /**
     * Sets the number of files to check per run. An additional delay will be added if there are more files to check.
     *
     * @param checksPerRun a value less than 1 will disable this feature
     */
    public void setChecksPerRun(final int checksPerRun) {
        this.checksPerRun = checksPerRun;
    }

    /**
     * Sets the delay between runs.
     *
     * @param delay The delay period.
     * @since 2.10.0
     */
    public void setDelay(final Duration delay) {
        this.delay = delay == null || delay.isNegative() ? DEFAULT_DELAY : delay;
    }

    /**
     * Sets the delay between runs.
     *
     * @param delay The delay period in milliseconds.
     * @deprecated Use {@link #setDelay(Duration)}.
     */
    @Deprecated
    public void setDelay(final long delay) {
        setDelay(delay > 0 ? Duration.ofMillis(delay) : DEFAULT_DELAY);
    }

    /**
     * Sets the recursive setting when adding files for monitoring.
     *
     * @param newRecursive true if monitoring should be enabled for children.
     */
    public void setRecursive(final boolean newRecursive) {
        recursive = newRecursive;
    }

    /**
     * Starts monitoring the files that have been added.
     */
    public synchronized void start() {
        if (monitorThread == null) {
            monitorThread = THREAD_FACTORY.newThread(this);
        }
        monitorThread.start();
    }

    /**
     * Stops monitoring the files that have been added.
     */
    public synchronized void stop() {
        close();
    }
}