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

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.wicket.util.lang.Bytes;

/**
 * This folder subclass provides some type safety and extensibility for "files" that hold other
 * files.
 * 
 * @author Jonathan Locke
 */
public class Folder extends File
{
        /**
         * Filter for files
         * 
         * @author Jonathan Locke
         */
        public static interface FileFilter
        {
                /**
                 * File filter that matches all files
                 */
                public static FileFilter ALL_FILES = new FileFilter()
                {
                        @Override
                        public boolean accept(final File file)
                        {
                                return true;
                        }
                };

                /**
                 * @param file
                 *            The file to test
                 * @return True if the file should be accepted
                 */
                public boolean accept(File file);
        }

        /**
         * Filter for folders
         * 
         * @author Jonathan Locke
         */
        public static interface FolderFilter
        {
                /**
                 * @param folder
                 *            The folder to test
                 * @return True if the file should be accepted
                 */
                public boolean accept(Folder folder);
        }

        private static final long serialVersionUID = 1L;

        /**
         * Constructor.
         * 
         * @param parent
         *            parent
         * @param child
         *            child
         */
        public Folder(final Folder parent, final String child)
        {
                super(parent, child);
        }

        /**
         * Construct.
         * 
         * @param file
         *            File
         */
        public Folder(final java.io.File file)
        {
                this(file.getPath());
        }

        /**
         * Constructor.
         * 
         * @param pathname
         *            path name
         */
        public Folder(final String pathname)
        {
                super(pathname);
        }

        /**
         * Constructor.
         * 
         * @param parent
         *            parent
         * @param child
         *            child
         */
        public Folder(final String parent, final String child)
        {
                super(parent, child);
        }

        /**
         * Constructor.
         * 
         * @param uri
         *            folder uri
         */
        public Folder(final URI uri)
        {
                super(uri);
        }

        /**
         * Does a mkdirs() on this folder if it does not exist. If the folder cannot be created, an
         * IOException is thrown.
         * 
         * @throws IOException
         *             Thrown if folder cannot be created
         */
        public void ensureExists() throws IOException
        {
                if (!exists() && !mkdirs())
                {
                        throw new IOException("Unable to create folder " + this);
                }
        }

        /**
         * @param name
         *            Name of child folder
         * @return Child file object
         */
        public Folder folder(final String name)
        {
                return new Folder(this, name);
        }

        /**
         * @return Disk space free on the partition where this folder lives
         */
        public Bytes freeDiskSpace()
        {
                return Bytes.bytes(super.getFreeSpace());
        }

        /**
         * @return Files in this folder
         */
        public File[] getFiles()
        {
                return getFiles(FileFilter.ALL_FILES);
        }

        /**
         * @return All files nested within this folder
         */
        public File[] getNestedFiles()
        {
                return getNestedFiles(FileFilter.ALL_FILES);
        }

        /**
         * Gets files in this folder matching a given filter recursively.
         * 
         * @param filter
         *            The filter
         * @return The list of files
         */
        public File[] getNestedFiles(final FileFilter filter)
        {
                final List<File> files = new ArrayList<>();
                files.addAll(Arrays.asList(getFiles(filter)));
                final Folder[] folders = getFolders();
                for (Folder folder : folders)
                {
                        files.addAll(Arrays.asList(folder.getNestedFiles(filter)));
                }
                return files.toArray(new File[files.size()]);
        }

        /**
         * @param filter
         *            File filter
         * @return Files
         */
        public File[] getFiles(final FileFilter filter)
        {
                // Get list of java.io files
                final java.io.File[] files = listFiles(new java.io.FileFilter()
                {
                        /**
                         * @see java.io.FileFilter#accept(java.io.File)
                         */
                        @Override
                        public boolean accept(final java.io.File file)
                        {
                                return file.isFile() && filter.accept(new File(file));
                        }
                });

                // Convert java.io files to org.apache.wicket files
                if (files != null)
                {
                        final File[] wicketFiles = new File[files.length];
                        for (int i = 0; i < files.length; i++)
                        {
                                wicketFiles[i] = new File(files[i]);
                        }
                        return wicketFiles;
                }
                return new File[0];
        }

        /**
         * Gets all folders in this folder, except "." and ".."
         * 
         * @return Folders
         */
        public Folder[] getFolders()
        {
                return getFolders(new FolderFilter()
                {
                        @Override
                        public boolean accept(final Folder folder)
                        {
                                final String name = folder.getName();
                                return !name.equals(".") && !name.equals("..");
                        }
                });
        }

        /**
         * @param filter
         *            Folder filter
         * @return Folders
         */
        public Folder[] getFolders(final FolderFilter filter)
        {
                // Get java io files that are directories matching the filter
                final java.io.File[] files = listFiles(new java.io.FileFilter()
                {
                        /**
                         * @see java.io.FileFilter#accept(java.io.File)
                         */
                        @Override
                        public boolean accept(final java.io.File file)
                        {
                                return file.isDirectory() && filter.accept(new Folder(file.getPath()));
                        }
                });

                // Convert
                if (files != null)
                {
                        final Folder[] wicketFolders = new Folder[files.length];
                        for (int i = 0; i < files.length; i++)
                        {
                                wicketFolders[i] = new Folder(files[i]);
                        }
                        return wicketFolders;
                }
                return new Folder[0];
        }

        /**
         * Removes this folder and everything in it, recursively. A best effort is made to remove nested
         * folders and files in depth-first order.
         * 
         * @return True if the folder was successfully removed
         */
        @Override
        public boolean remove()
        {
                return remove(this);
        }

        /**
         * Removes all the files in this folder.
         * 
         * @return True if any files were successfully removed
         */
        public boolean removeFiles()
        {
                final File[] files = getFiles();
                boolean success = true;
                for (File file : files)
                {
                        success = file.remove() && success;
                }
                return success;
        }

        /**
         * Removes everything in the given folder and then the folder itself.
         * 
         * @param folder
         *            The folder
         * @return True if the folder was successfully removed
         */
        private boolean remove(final Folder folder)
        {
                final Folder[] folders = getFolders();
                boolean success = true;
                for (Folder subfolder : folders)
                {
                        success = subfolder.remove() && success;
                }
                success = removeFiles() && success;
                return folder.delete() && success;
        }
}