/*
 *  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.core.util.path;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.io.FileExistsException;

/**
 * General path manipulation utilities.
 */
public final class PathUtils
{
    private PathUtils()
    {
        // utility class
    }
    
    /**
      * Copies a whole directory to a new location preserving the file dates.
      * <p>
      * This method copies the specified directory and all its child
      * directories and files to the specified destination.
      * The destination is the new location and name of the directory.
      * <p>
      * The destination directory is created if it does not exist.
      * If the destination directory did exist, then this method merges
      * the source with the destination, with the source taking precedence.
      * <p>
      * <strong>Note:</strong> This method tries to preserve the files' last
      * modified date/times using {@link File#setLastModified(long)}, however
      * it is not guaranteed that those operations will succeed.
      * If the modification operation fails, no indication is provided.
      *
      * @param srcDir  an existing directory to copy, must not be {@code null}
      * @param destDir the new directory, must not be {@code null}
      *
      * @throws NullPointerException if source or destination is {@code null}
      * @throws IOException          if source or destination is invalid
      * @throws IOException          if an IO error occurs during copying
      */
    public static void copyDirectory(final Path srcDir, final Path destDir) throws IOException
    {
        copyDirectory(srcDir, destDir, true);
    }

    /**
     * Copies a whole directory to a new location.
     * <p>
     * This method copies the contents of the specified source directory
     * to within the specified destination directory.
     * <p>
     * The destination directory is created if it does not exist.
     * If the destination directory did exist, then this method merges
     * the source with the destination, with the source taking precedence.
     * <p>
     * <strong>Note:</strong> Setting <code>preserveFileDate</code> to
     * {@code true} tries to preserve the files' last modified
     * date/times using {@link File#setLastModified(long)}, however it is
     * not guaranteed that those operations will succeed.
     * If the modification operation fails, no indication is provided.
     *
     * @param srcDir           an existing directory to copy, must not be {@code null}
     * @param destDir          the new directory, must not be {@code null}
     * @param preserveFileDate true if the file date of the copy
     *                         should be the same as the original
     *
     * @throws NullPointerException if source or destination is {@code null}
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs during copying
     */
    public static void copyDirectory(final Path srcDir, final Path destDir, final boolean preserveFileDate) throws IOException 
    {
        copyDirectory(srcDir, destDir, null, preserveFileDate);
    }

    /**
     * Copies a filtered directory to a new location preserving the file dates.
     * <p>
     * This method copies the contents of the specified source directory
     * to within the specified destination directory.
     * <p>
     * The destination directory is created if it does not exist.
     * If the destination directory did exist, then this method merges
     * the source with the destination, with the source taking precedence.
     * <p>
     * <strong>Note:</strong> This method tries to preserve the files' last
     * modified date/times using {@link File#setLastModified(long)}, however
     * it is not guaranteed that those operations will succeed.
     * If the modification operation fails, no indication is provided.
     * </p>
     * <h3>Example: Copy directories only</h3>
     * <pre>
     *  // only copy the directory structure
     *  FileUtils.copyDirectory(srcDir, destDir, Files::isDirectory);
     *  </pre>
     *
     * @param srcDir  an existing directory to copy, must not be {@code null}
     * @param destDir the new directory, must not be {@code null}
     * @param filter  the filter to apply, null means copy all directories and files
     *                should be the same as the original
     *
     * @throws NullPointerException if source or destination is {@code null}
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs during copying
     */
    public static void copyDirectory(final Path srcDir, final Path destDir, final Predicate<Path> filter) throws IOException 
    {
        copyDirectory(srcDir, destDir, filter, true);
    }
    
    /**
     * Copies a filtered directory to a new location.
     * <p>
     * This method copies the contents of the specified source directory
     * to within the specified destination directory.
     * <p>
     * The destination directory is created if it does not exist.
     * If the destination directory did exist, then this method merges
     * the source with the destination, with the source taking precedence.
     * <p>
     * <strong>Note:</strong> Setting <code>preserveFileDate</code> to
     * {@code true} tries to preserve the files' last modified
     * date/times using {@link File#setLastModified(long)}, however it is
     * not guaranteed that those operations will succeed.
     * If the modification operation fails, no indication is provided.
     * </p>
     * <h3>Example: Copy directories only</h3>
     * <pre>
     *  // only copy the directory structure
     *  FileUtils.copyDirectory(srcDir, destDir, DirectoryFileFilter.DIRECTORY, false);
     *  </pre>
     *
     * <h3>Example: Copy directories and txt files</h3>
     * <pre>
     *  // Create a filter for ".txt" files
     *  IOFileFilter txtSuffixFilter = FileFilterUtils.suffixFileFilter(".txt");
     *  IOFileFilter txtFiles = FileFilterUtils.andFileFilter(FileFileFilter.FILE, txtSuffixFilter);
     *
     *  // Create a filter for either directories or ".txt" files
     *  FileFilter filter = FileFilterUtils.orFileFilter(DirectoryFileFilter.DIRECTORY, txtFiles);
     *
     *  // Copy using the filter
     *  FileUtils.copyDirectory(srcDir, destDir, filter, false);
     *  </pre>
     *
     * @param srcDir           an existing directory to copy, must not be {@code null}
     * @param destDir          the new directory, must not be {@code null}
     * @param filter           the filter to apply, null means copy all directories and files
     * @param preserveFileDate true if the file date of the copy
     *                         should be the same as the original
     *
     * @throws NullPointerException if source or destination is {@code null}
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs during copying
     */
    public static void copyDirectory(final Path srcDir, final Path destDir, final Predicate<Path> filter, final boolean preserveFileDate) throws IOException 
    {
        checkFileRequirements(srcDir, destDir);
        if (!Files.isDirectory(srcDir)) 
        {
            throw new IOException("Source '" + srcDir + "' exists but is not a directory");
        }
        if (srcDir.toAbsolutePath().equals(destDir.toAbsolutePath())) 
        {
            throw new IOException("Source '" + srcDir + "' and destination '" + destDir + "' are the same");
        }

        // Cater for destination being directory within the source directory (see IO-141)
        List<Path> exclusionList = null;
        if (destDir.getFileSystem() == srcDir.getFileSystem() 
                && destDir.toAbsolutePath().startsWith(srcDir.toAbsolutePath())) 
        {
            List<Path> srcFiles;
            try (Stream<Path> walk = Files.list(srcDir))
            {
                if (filter != null)
                {
                    srcFiles = walk.filter(filter).collect(Collectors.toList());
                }
                else
                {
                    srcFiles = walk.collect(Collectors.toList());
                }
            }

            if (!srcFiles.isEmpty()) 
            {
                exclusionList = new ArrayList<>(srcFiles.size());
                for (final Path srcFile : srcFiles) 
                {
                    final Path copiedFile = destDir.resolve(srcFile.getFileName());
                    exclusionList.add(copiedFile.toAbsolutePath());
                }
            }
        }
        doCopyDirectory(srcDir, destDir, filter, preserveFileDate, exclusionList);
    }

    /**
     * checks requirements for file copy
     * @param src the source file
     * @param dest the destination
     * @throws FileNotFoundException if the destination does not exist
     */
    private static void checkFileRequirements(final Path src, final Path dest) throws FileNotFoundException 
    {
        if (src == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (dest == null) 
        {
            throw new NullPointerException("Destination must not be null");
        }
        if (!Files.exists(src)) 
        {
            throw new FileNotFoundException("Source '" + src + "' does not exist");
        }
    }

    /**
     * Internal copy directory method.
     *
     * @param srcDir           the validated source directory, must not be {@code null}
     * @param destDir          the validated destination directory, must not be {@code null}
     * @param filter           the filter to apply, null means copy all directories and files
     * @param preserveFileDate whether to preserve the file date
     * @param exclusionList    List of files and directories to exclude from the copy, may be null
     * @throws IOException if an error occurs
     */
    private static void doCopyDirectory(final Path srcDir, final Path destDir, final Predicate<Path> filter, final boolean preserveFileDate, final List<Path> exclusionList) throws IOException 
    {
        // recurse
        List<Path> srcFiles;
        try (Stream<Path> walk = Files.list(srcDir))
        {
            if (filter != null)
            {
                srcFiles = walk.filter(filter).collect(Collectors.toList());
            }
            else
            {
                srcFiles = walk.collect(Collectors.toList());
            }
        }

        if (Files.exists(destDir)) 
        {
            if (!Files.isDirectory(destDir)) 
            {
                throw new IOException("Destination '" + destDir + "' exists but is not a directory");
            }
        } 
        else 
        {
            Path createdDirectories = Files.createDirectories(destDir);
            if (!Files.isDirectory(createdDirectories)) 
            {
                throw new IOException("Destination '" + destDir + "' directory cannot be created");
            }
        }
        if (!Files.isWritable(destDir))
        {
            throw new IOException("Destination '" + destDir + "' cannot be written to");
        }
        for (final Path srcFile : srcFiles) 
        {
            final Path dstFile = destDir.resolve(srcFile.getFileName().toString());
            if (exclusionList == null || !exclusionList.contains(srcFile.toAbsolutePath())) 
            {
                if (Files.isDirectory(srcFile)) 
                {
                    doCopyDirectory(srcFile, dstFile, filter, preserveFileDate, exclusionList);
                } 
                else 
                {
                    doCopyFile(srcFile, dstFile, preserveFileDate);
                }
            }
        }

        // Do this last, as the above has probably affected directory metadata
        if (preserveFileDate) 
        {
            Files.setLastModifiedTime(destDir, Files.getLastModifiedTime(srcDir));
        }
    }
    
    /**
     * Internal copy file method.
     * This caches the original file length, and throws an IOException
     * if the output file length is different from the current input file length.
     * So it may fail if the file changes size.
     * It may also fail with "IllegalArgumentException: Negative size" if the input file is truncated part way
     * through copying the data and the new file size is less than the current position.
     *
     * @param srcFile          the validated source file, must not be {@code null}
     * @param destFile         the validated destination file, must not be {@code null}
     * @param preserveFileDate whether to preserve the file date
     * @throws IOException              if an error occurs
     * @throws IOException              if the output file length is not the same as the input file length after the
     * copy completes
     * @throws IllegalArgumentException "Negative size" if the file is truncated so that the size is less than the
     * position
     */
    private static void doCopyFile(final Path srcFile, final Path destFile, final boolean preserveFileDate) throws IOException 
    {
        if (Files.exists(destFile) && Files.isDirectory(destFile)) 
        {
            throw new IOException("Destination '" + destFile + "' exists but is a directory");
        }

        Files.copy(srcFile, destFile, StandardCopyOption.REPLACE_EXISTING);

        final long srcLen = Files.size(srcFile); // TODO See IO-386
        final long dstLen = Files.size(destFile); // TODO See IO-386
        if (srcLen != dstLen) 
        {
            throw new IOException("Failed to copy full contents from '" + srcFile + "' to '" + destFile + "' Expected length: " + srcLen + " Actual: " + dstLen);
        }
        if (preserveFileDate) 
        {
            Files.setLastModifiedTime(destFile, Files.getLastModifiedTime(srcFile));
        }
    }

    /**
     * Moves a file.
     * <p>
     * When the destination file is on another file system, do a "copy and delete".
     *
     * @param srcFile  the file to be moved
     * @param destFile the destination file
     * @throws NullPointerException if source or destination is {@code null}
     * @throws FileExistsException  if the destination file exists
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs moving the file
     * @since 1.4
     */
    public static void moveFile(final Path srcFile, final Path destFile) throws IOException 
    {
        if (srcFile == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (destFile == null) 
        {
            throw new NullPointerException("Destination must not be null");
        }
        if (!Files.exists(srcFile)) 
        {
            throw new FileNotFoundException("Source '" + srcFile + "' does not exist");
        }
        if (Files.isDirectory(srcFile)) 
        {
            throw new IOException("Source '" + srcFile + "' is a directory");
        }
        if (Files.exists(destFile)) 
        {
            throw new FileExistsException("Destination '" + destFile + "' already exists");
        }
        if (Files.isDirectory(destFile)) 
        {
            throw new IOException("Destination '" + destFile + "' is a directory");
        }
        
        try
        {
            Files.move(srcFile, destFile);
        }
        catch (IOException e)
        {
            copyFile(srcFile, destFile);
            if (!Files.deleteIfExists(srcFile)) 
            {
                deleteQuietly(destFile);
                throw new IOException("Failed to delete original file '" + srcFile + "' after copy to '" + destFile + "'");
            }
        }
    }
    
    /**
     * Moves a file or directory to the destination directory.
     * <p>
     * When the destination is on another file system, do a "copy and delete".
     *
     * @param src           the file or directory to be moved
     * @param destDir       the destination directory
     * @param createDestDir If {@code true} create the destination directory,
     *                      otherwise if {@code false} throw an IOException
     * @throws NullPointerException if source or destination is {@code null}
     * @throws FileExistsException  if the directory or file exists in the destination directory
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs moving the file
     */
    public static void moveToDirectory(final Path src, final Path destDir, final boolean createDestDir) throws IOException 
    {
        if (src == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (destDir == null) 
        {
            throw new NullPointerException("Destination must not be null");
        }
        if (!Files.exists(src)) 
        {
            throw new FileNotFoundException("Source '" + src + "' does not exist");
        }
        if (Files.isDirectory(src)) 
        {
            moveDirectoryToDirectory(src, destDir, createDestDir);
        } 
        else 
        {
            moveFileToDirectory(src, destDir, createDestDir);
        }
    }

    /**
     * Moves a file to a directory.
     *
     * @param srcFile       the file to be moved
     * @param destDir       the destination file
     * @param createDestDir If {@code true} create the destination directory,
     *                      otherwise if {@code false} throw an IOException
     * @throws NullPointerException if source or destination is {@code null}
     * @throws FileExistsException  if the destination file exists
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs moving the file
     * @since 1.4
     */
    public static void moveFileToDirectory(final Path srcFile, final Path destDir, final boolean createDestDir) throws IOException 
    {
        if (srcFile == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (destDir == null) 
        {
            throw new NullPointerException("Destination directory must not be null");
        }
        if (!Files.exists(destDir) && createDestDir) 
        {
            Files.createDirectories(destDir);
        }
        if (!Files.exists(destDir)) 
        {
            throw new FileNotFoundException("Destination directory '" + destDir + "' does not exist [createDestDir=" + createDestDir + "]");
        }
        if (!Files.isDirectory(destDir)) 
        {
            throw new IOException("Destination '" + destDir + "' is not a directory");
        }
        moveFile(srcFile, destDir.resolve(srcFile.getFileName().toString()));
    }

    
    /**
     * Moves a directory to another directory.
     *
     * @param src           the file to be moved
     * @param destDir       the destination file
     * @param createDestDir If {@code true} create the destination directory,
     *                      otherwise if {@code false} throw an IOException
     * @throws NullPointerException if source or destination is {@code null}
     * @throws FileExistsException  if the directory exists in the destination directory
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs moving the file
     */
    public static void moveDirectoryToDirectory(final Path src, final Path destDir, final boolean createDestDir) throws IOException 
    {
        if (src == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (destDir == null) 
        {
            throw new NullPointerException("Destination directory must not be null");
        }
        if (!Files.exists(destDir) && createDestDir) 
        {
            Files.createDirectories(destDir);
        }
        if (!Files.exists(destDir)) 
        {
            throw new FileNotFoundException("Destination directory '" + destDir + "' does not exist [createDestDir=" + createDestDir + "]");
        }
        if (!Files.isDirectory(destDir)) 
        {
            throw new IOException("Destination '" + destDir + "' is not a directory");
        }
        moveDirectory(src, destDir.resolve(src.getFileName().toString()));
    }
    
    /**
     * Moves a directory.
     * <p>
     * When the destination directory is on another file system, do a "copy and delete".
     *
     * @param srcDir  the directory to be moved
     * @param destDir the destination directory
     * @throws NullPointerException if source or destination is {@code null}
     * @throws FileExistsException  if the destination directory exists
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs moving the file
     */
    public static void moveDirectory(final Path srcDir, final Path destDir) throws IOException 
    {
        if (srcDir == null) 
        {
            throw new NullPointerException("Source must not be null");
        }
        if (destDir == null) 
        {
            throw new NullPointerException("Destination must not be null");
        }
        if (!Files.exists(srcDir)) 
        {
            throw new FileNotFoundException("Source '" + srcDir + "' does not exist");
        }
        if (!Files.isDirectory(srcDir)) 
        {
            throw new IOException("Source '" + srcDir + "' is not a directory");
        }
        if (Files.exists(destDir)) 
        {
            throw new FileExistsException("Destination '" + destDir + "' already exists");
        }
        
        try
        {
            Files.move(srcDir, destDir);
        }
        catch (IOException e)
        {
            if (destDir.toAbsolutePath().toString().startsWith(srcDir.toAbsolutePath().toString() + File.separator)) 
            {
                throw new IOException("Cannot move directory: " + srcDir + " to a subdirectory of itself: " + destDir);
            }
            copyDirectory(srcDir, destDir);
            deleteDirectory(srcDir);
            if (Files.exists(srcDir)) 
            {
                throw new IOException("Failed to delete original directory '" + srcDir + "' after copy to '" + destDir + "'");
            }
        }
    }

    
    /**
     * Deletes a file, never throwing an exception. If file is a directory, delete it and all sub-directories.
     * <p>
     * The difference between File.delete() and this method are:
     * <ul>
     * <li>A directory to be deleted does not have to be empty.</li>
     * <li>No exceptions are thrown when a file or directory cannot be deleted.</li>
     * </ul>
     *
     * @param file file or directory to delete, can be {@code null}
     * @return {@code true} if the file or directory was deleted, otherwise
     * {@code false}
     */
    public static boolean deleteQuietly(final Path file) 
    {
        if (file == null) 
        {
            return false;
        }
        try 
        {
            if (Files.isDirectory(file)) 
            {
                cleanDirectory(file);
            }
        } 
        catch (final Exception ignored) 
        {
            // ignored
        }

        try 
        {
            return Files.deleteIfExists(file);
        } 
        catch (final Exception ignored) 
        {
            return false;
        }
    }
    
    /**
     * Cleans a directory without deleting it.
     *
     * @param directory directory to clean
     * @throws IOException              in case cleaning is unsuccessful
     * @throws IllegalArgumentException if {@code directory} does not exist or is not a directory
     */
    public static void cleanDirectory(final Path directory) throws IOException 
    {
        final Path[] files = verifiedListFiles(directory);

        IOException exception = null;
        for (final Path file : files) 
        {
            try 
            {
                forceDelete(file);
            } 
            catch (final IOException ioe) 
            {
                exception = ioe;
            }
        }

        if (null != exception) 
        {
            throw exception;
        }
    }

    /**
     * Lists files in a directory, asserting that the supplied directory satisfies exists and is a directory
     * @param directory The directory to list
     * @return The files in the directory, never null.
     * @throws IOException if an I/O error occurs
     */
    private static Path[] verifiedListFiles(final Path directory) throws IOException 
    {
        if (!Files.exists(directory)) 
        {
            final String message = directory + " does not exist";
            throw new IllegalArgumentException(message);
        }

        if (!Files.isDirectory(directory)) 
        {
            final String message = directory + " is not a directory";
            throw new IllegalArgumentException(message);
        }
        
        try (Stream<Path> s = Files.list(directory))
        {
            List<Path> collect = s.collect(Collectors.toList());
            return collect.toArray(new Path[collect.size()]);
        }
    }

    /**
     * Deletes a file. If file is a directory, delete it and all sub-directories.
     * <p>
     * The difference between File.delete() and this method are:
     * <ul>
     * <li>A directory to be deleted does not have to be empty.</li>
     * <li>You get exceptions when a file or directory cannot be deleted.
     * (java.io.File methods returns a boolean)</li>
     * </ul>
     *
     * @param file file or directory to delete, must not be {@code null}
     * @throws NullPointerException  if the directory is {@code null}
     * @throws FileNotFoundException if the file was not found
     * @throws IOException           in case deletion is unsuccessful
     */
    public static void forceDelete(final Path file) throws IOException 
    {
        if (Files.isDirectory(file)) 
        {
            deleteDirectory(file);
        } 
        else 
        {
            final boolean filePresent = Files.exists(file);
            if (!Files.deleteIfExists(file)) 
            {
                if (!filePresent) 
                {
                    throw new FileNotFoundException("File does not exist: " + file);
                }
                final String message = "Unable to delete file: " + file;
                throw new IOException(message);
            }
        }
    }
    
    /**
     * Deletes a directory recursively.
     *
     * @param directory directory to delete
     * @throws IOException              in case deletion is unsuccessful
     * @throws IllegalArgumentException if {@code directory} does not exist or is not a directory
     */
    public static void deleteDirectory(final Path directory) throws IOException 
    {
        if (!Files.exists(directory)) 
        {
            return;
        }

        if (!isSymlink(directory)) 
        {
            cleanDirectory(directory);
        }

        if (!Files.deleteIfExists(directory)) 
        {
            final String message = "Unable to delete directory " + directory + ".";
            throw new IOException(message);
        }
    }
    
    /**
     * Determines whether the specified file is a Symbolic Link rather than an actual file.
     * <p>
     * Will not return true if there is a Symbolic Link anywhere in the path,
     * only if the specific file is.
     * <p>
     * When using jdk1.7, this method delegates to {@code boolean java.nio.file.Files.isSymbolicLink(Path path)}
     *
     * <p>
     * For code that runs on Java 1.7 or later, use the following method instead:
     * <br>
     * {@code boolean java.nio.file.Files.isSymbolicLink(Path path)}
     * @param file the file to check
     * @return true if the file is a Symbolic Link
     * @throws IOException if an IO error occurs while checking the file
     */
    public static boolean isSymlink(final Path file) throws IOException 
    {
        if (file == null) 
        {
            throw new NullPointerException("File must not be null");
        }
        return Files.isSymbolicLink(file);
    }
    
    /**
     * Copies a file to a new location preserving the file date.
     * <p>
     * This method copies the contents of the specified source file to the
     * specified destination file. The directory holding the destination file is
     * created if it does not exist. If the destination file exists, then this
     * method will overwrite it.
     * <p>
     * <strong>Note:</strong> This method tries to preserve the file's last
     * modified date/times using {@link File#setLastModified(long)}, however
     * it is not guaranteed that the operation will succeed.
     * If the modification operation fails, no indication is provided.
     *
     * @param srcFile  an existing file to copy, must not be {@code null}
     * @param destFile the new file, must not be {@code null}
     *
     * @throws NullPointerException if source or destination is {@code null}
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs during copying
     * @throws IOException          if the output file length is not the same as the input file length after the copy
     * completes
     * @see #copyFile(Path, Path, boolean)
     */
    public static void copyFile(final Path srcFile, final Path destFile) throws IOException 
    {
        copyFile(srcFile, destFile, true);
    }

    /**
     * Copies a file to a new location.
     * <p>
     * This method copies the contents of the specified source file
     * to the specified destination file.
     * The directory holding the destination file is created if it does not exist.
     * If the destination file exists, then this method will overwrite it.
     * <p>
     * <strong>Note:</strong> Setting <code>preserveFileDate</code> to
     * {@code true} tries to preserve the file's last modified
     * date/times using {@link File#setLastModified(long)}, however it is
     * not guaranteed that the operation will succeed.
     * If the modification operation fails, no indication is provided.
     *
     * @param srcFile          an existing file to copy, must not be {@code null}
     * @param destFile         the new file, must not be {@code null}
     * @param preserveFileDate true if the file date of the copy
     *                         should be the same as the original
     *
     * @throws NullPointerException if source or destination is {@code null}
     * @throws IOException          if source or destination is invalid
     * @throws IOException          if an IO error occurs during copying
     * @throws IOException          if the output file length is not the same as the input file length after the copy
     * completes
     * @see #doCopyFile(Path, Path, boolean)
     */
    public static void copyFile(final Path srcFile, final Path destFile, final boolean preserveFileDate) throws IOException 
    {
        checkFileRequirements(srcFile, destFile);
        if (Files.isDirectory(srcFile)) 
        {
            throw new IOException("Source '" + srcFile + "' exists but is a directory");
        }
        if (srcFile.toAbsolutePath().equals(destFile.toAbsolutePath())) 
        {
            throw new IOException("Source '" + srcFile + "' and destination '" + destFile + "' are the same");
        }
        
        final Path parentFile = destFile.getParent();
        if (parentFile != null) 
        {
            Files.createDirectories(parentFile);
            if (!Files.isDirectory(parentFile)) 
            {
                throw new IOException("Destination '" + parentFile + "' directory cannot be created");
            }
        }
        if (Files.exists(destFile) && !Files.isWritable(destFile)) 
        {
            throw new IOException("Destination '" + destFile + "' exists but is read-only");
        }
        doCopyFile(srcFile, destFile, preserveFileDate);
    }
}