package fr.ifremer.quadrige3.core.dao.technical;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Core Shared
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import com.google.common.collect.ImmutableList;
  import fr.ifremer.quadrige3.core.ProgressionCoreModel;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.lang3.mutable.MutableLong;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.net.io.CopyStreamListener;
  import org.apache.commons.net.io.Util;
  import org.apache.commons.vfs2.FileObject;
  import org.nuiton.jaxx.application.ApplicationIOUtil;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.math.RoundingMode;
  import java.nio.ByteBuffer;
  import java.nio.channels.FileChannel;
  import java.nio.channels.SeekableByteChannel;
  import java.nio.file.*;
  import java.nio.file.attribute.BasicFileAttributes;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  
  import static java.nio.file.FileVisitResult.CONTINUE;
  import static java.nio.file.FileVisitResult.SKIP_SUBTREE;
  import static java.nio.file.StandardOpenOption.*;
  
  /**
   * @author peck7 on 30/06/2017.
   */
  public class Files {
  
      private static final Log LOG = LogFactory.getLog(Files.class);
      private static final int DEFAULT_IO_BUFFER_SIZE = 131072; // 128kb
      private static final RoundingMode ROUNDING_MODE = RoundingMode.HALF_UP;
  
      private Files() {
          // no instance
      }
  
      enum FileSize {
          EXABYTE("EB", FileUtils.ONE_EB_BI),
          PETABYTE("PB", FileUtils.ONE_PB_BI),
          TERABYTE("TB", FileUtils.ONE_TB_BI),
          GIGABYTE("GB", FileUtils.ONE_GB_BI),
          MEGABYTE("MB", FileUtils.ONE_MB_BI),
          KILOBYTE("KB", FileUtils.ONE_KB_BI),
          BYTE("bytes", BigInteger.ONE);
  
          private final String unit;
          private final BigInteger byteCount;
  
          FileSize(String unit, BigInteger byteCount) {
              this.unit = unit;
              this.byteCount = byteCount;
          }
  
          private String unit() {
              return unit;
          }
  
          private BigInteger byteCount() {
              return byteCount;
          }
  
      }
  
      /**
       * Formats a file's size into a human readable format
      *
      * @param fileSize the file's size as BigInteger
      * @return the size as human readable string
      */
     public static String byteCountToDisplaySize(final BigInteger fileSize) {
 
         String unit = FileSize.BYTE.unit;
         BigDecimal fileSizeInUnit = BigDecimal.ZERO;
         String val;
 
         for (FileSize fs : FileSize.values()) {
             BigDecimal size_bd = new BigDecimal(fileSize);
             fileSizeInUnit = size_bd.divide(new BigDecimal(fs.byteCount), 5, ROUNDING_MODE);
             if (fileSizeInUnit.compareTo(BigDecimal.ONE) >= 0) {
                 unit = fs.unit;
                 break;
             }
         }
 
         // always round so that at least 3 numerics are displayed (###, ##.#, #.##)
         if (fileSizeInUnit.divide(BigDecimal.valueOf(100.0), BigDecimal.ROUND_DOWN).compareTo(BigDecimal.ONE) >= 0) {
             val = fileSizeInUnit.setScale(0, ROUNDING_MODE).toString();
         } else if (fileSizeInUnit.divide(BigDecimal.valueOf(10.0), BigDecimal.ROUND_DOWN).compareTo(BigDecimal.ONE) >= 0) {
             val = fileSizeInUnit.setScale(1, ROUNDING_MODE).toString();
         } else {
             val = fileSizeInUnit.setScale(2, ROUNDING_MODE).toString();
         }
 
         // trim zeros at the end
         if (val.endsWith(".00")) {
             val = val.substring(0, val.length() - 3);
         } else if (val.endsWith(".0")) {
             val = val.substring(0, val.length() - 2);
         }
 
         return String.format("%s %s", val, unit);
     }
 
     /**
      * Formats a file's size into a human readable format
      *
      * @param fileSize the file's size as long
      * @return the size as human readable string
      */
     public static String byteCountToDisplaySize(final long fileSize) {
         return byteCountToDisplaySize(BigInteger.valueOf(fileSize));
     }
 
     /**
      * Copy a file with progression monitor. Use VFS2 file resolver and streams
      *
      * @param sourceFileName      a {@link java.lang.String} object.
      * @param destinationFileName a {@link java.lang.String} object.
      * @param progressMonitor     a {@link org.apache.commons.net.io.CopyStreamListener} object.
      * @throws java.io.IOException if any.
      */
     @Deprecated
     public static void copy(String sourceFileName, String destinationFileName, CopyStreamListener progressMonitor) throws IOException {
 
         FileObject sourceFile = ApplicationIOUtil.resolveFile(sourceFileName, "Can't resolve " + sourceFileName);
         FileObject destinationFile = ApplicationIOUtil.resolveFile(destinationFileName, "Can't resolve " + destinationFileName);
 
         try (InputStream sourceFileIn = sourceFile.getContent().getInputStream();
              OutputStream destinationFileOut = destinationFile.getContent().getOutputStream()) {
             Util.copyStream(sourceFileIn, destinationFileOut, DEFAULT_IO_BUFFER_SIZE, sourceFile.getContent().getSize(), progressMonitor);
         }
     }
 
     public static void copyFile(final Path source, final Path target) throws IOException {
         copyFile(source, target, null);
     }
 
     public static void copyFile(final Path source, final Path target, final ProgressionCoreModel progressionModel) throws IOException {
         Assert.notNull(source);
         Assert.notNull(target);
         Assert.isTrue(java.nio.file.Files.exists(source), "the source to copy must exists");
         Assert.isTrue(java.nio.file.Files.isRegularFile(source), "the source to copy must be a regular file");
         if (java.nio.file.Files.exists(target))
             Assert.isTrue(!java.nio.file.Files.isSameFile(source, target), "the source and target can't be the same");
         java.nio.file.Files.createDirectories(target.getParent());
 
         if (progressionModel != null) {
             progressionModel.adaptTotal(getSize(source));
         }
 
         try (SeekableByteChannel inputChannel = java.nio.file.Files.newByteChannel(source, READ);
              SeekableByteChannel outputChannel = java.nio.file.Files.newByteChannel(target, CREATE, WRITE, TRUNCATE_EXISTING)) {
             ByteBuffer buffer = ByteBuffer.allocateDirect(DEFAULT_IO_BUFFER_SIZE);
             while (inputChannel.read(buffer) != -1) {
                 buffer.flip();
                 while (buffer.hasRemaining()) {
                     if (progressionModel != null) {
                         progressionModel.increments(buffer.remaining());
                     }
                     outputChannel.write(buffer);
                 }
                 buffer.clear();
             }
         }
     }
 
     public static void copyDirectory(final Path source, final Path target) throws IOException {
         copyDirectory(source, target, null);
     }
 
     public static void copyDirectory(final Path source, final Path target, ProgressionCoreModel progressionModel) throws IOException {
         Assert.notNull(source, "source is null");
         Assert.notNull(target, "target is null");
         Assert.isTrue(java.nio.file.Files.exists(source), "source must exists");
         Assert.isTrue(java.nio.file.Files.isDirectory(source), "source must be a directory");
         if (progressionModel != null) {
             progressionModel.adaptTotal(getSize(source));
         }
         java.nio.file.Files.walkFileTree(source, new TreeCopier(source, target, progressionModel));
     }
 
     public static void moveDirectory(final Path source, final Path target, final ProgressionCoreModel progressionModel) throws IOException {
         copyDirectory(source, target, progressionModel);
         cleanDirectory(source, "Fail to clean directory " + source);
     }
 
     static class TreeCopier implements FileVisitor<Path> {
         private final Path source;
         private final Path target;
         private final ProgressionCoreModel progressionModel;
 
         TreeCopier(Path source, Path target, ProgressionCoreModel progressionModel) {
             this.source = source;
             this.target = target;
             this.progressionModel = progressionModel;
         }
 
         @Override
         public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
             // before visiting entries in a directory we create the target directory
             Path newDir = target.resolve(source.relativize(dir));
             try {
                 java.nio.file.Files.createDirectories(newDir);
             } catch (IOException x) {
                 System.err.format("Unable to create: %s: %s%n", newDir, x);
                 return SKIP_SUBTREE;
             }
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
 
             try {
                 copyFile(file, target.resolve(source.relativize(file)), progressionModel);
             } catch (IOException e) {
                 System.err.format("Unable to copy: %s: %s%n", file, e);
             }
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult visitFileFailed(Path file, IOException exc) {
             if (exc instanceof FileSystemLoopException) {
                 System.err.println("cycle detected: " + file);
             } else {
                 System.err.format("Unable to copy: %s: %s%n", file, exc);
             }
             return CONTINUE;
         }
     }
 
     public static void copyStream(final InputStream inputStream, final OutputStream outputStream) throws IOException {
         copyStream(inputStream, outputStream, null);
     }
 
     public static void copyStream(final InputStream inputStream, final OutputStream outputStream, ProgressionCoreModel progressionModel) throws IOException {
         byte[] buffer = new byte[DEFAULT_IO_BUFFER_SIZE];
         int n;
         while (-1 != (n = inputStream.read(buffer))) {
             outputStream.write(buffer, 0, n);
             if (progressionModel != null) {
                 progressionModel.increments(n);
             }
         }
     }
 
     public static void deleteQuietly(final List<Path> paths) {
         if (paths == null) return;
         paths.forEach(Files::deleteQuietly);
     }
 
     public static void deleteQuietly(final Path path) {
         if (path == null) return;
         try {
             if (java.nio.file.Files.isDirectory(path)) {
                 cleanDirectory(path, "unable to clean " + path);
             }
             java.nio.file.Files.deleteIfExists(path);
         } catch (IOException ignored) {
         }
     }
 
     /**
      * <p>cleanDirectory.</p>
      *
      * @param directory   a {@link java.io.File} object.
      * @param failMessage a {@link java.lang.String} object.
      */
     public static void cleanDirectory(final File directory, final String failMessage) {
         cleanDirectory(directory.toPath(), failMessage);
     }
 
     public static void cleanDirectory(final Path directory, final String failMessage) {
         cleanDirectory(directory, failMessage, null);
     }
 
     public static void cleanDirectory(final Path directory, final String failMessage, ProgressionCoreModel progressionModel) {
 
         if (progressionModel != null) {
             progressionModel.setTotal(getDirectoryFileCount(directory));
         }
 
         int nbAttempt = 0;
         IOException lastException = null;
         while (isDirectoryNotEmpty(directory) && nbAttempt < 10) {
             nbAttempt++;
             try {
                 java.nio.file.Files.walkFileTree(directory, new RecursiveDeleteFileVisitor(directory, progressionModel));
                 lastException = null;
             } catch (NoSuchFileException ignored) {
             } catch (AccessDeniedException ade) {
                 if (java.nio.file.Files.exists(Paths.get(ade.getFile()))) {
                     lastException = ade;
                     break;
                 }
             } catch (IOException e) {
                 lastException = e;
                 // wait a while
                 try {
                     Thread.sleep(500);
                 } catch (InterruptedException ignored) {
                 }
             }
         }
         if (lastException != null) {
             throw new QuadrigeTechnicalException(failMessage, lastException);
         }
         if (LOG.isWarnEnabled() && nbAttempt > 1) {
             LOG.warn(String.format("cleaning the directory '%s' successful after %d attempts", directory, nbAttempt));
         }
     }
 
     private static boolean isDirectoryNotEmpty(final Path path) {
         if (!java.nio.file.Files.isDirectory(path)) {
             return false;
         }
         try {
             try (DirectoryStream<Path> dirStream = java.nio.file.Files.newDirectoryStream(path)) {
                 return dirStream.iterator().hasNext();
             }
         } catch (IOException e) {
             return false;
         }
     }
 
     private static class RecursiveDeleteFileVisitor extends SimpleFileVisitor<Path> {
 
         private final Path root;
         private final ProgressionCoreModel progressionModel;
 
         private RecursiveDeleteFileVisitor(Path root, ProgressionCoreModel progressionModel) {
             this.root = root;
             this.progressionModel = progressionModel;
         }
 
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
 
             // delete the file
             java.nio.file.Files.deleteIfExists(file);
             if (progressionModel != null)
                 progressionModel.increments(1);
             return FileVisitResult.CONTINUE;
         }
 
         @Override
         public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
 
             // don't delete the root
             if (dir == root) {
                 return FileVisitResult.TERMINATE;
             }
 
             // delete the directory
             java.nio.file.Files.deleteIfExists(dir);
             return FileVisitResult.CONTINUE;
         }
 
     }
 
     /**
      * Split a file into pieces of chunkSize bytes
      *
      * @param file      the file to split
      * @param chunkSize the chunk size in bytes
      * @return the list of created splitted up files
      * @throws IOException if any
      */
     public static List<Path> splitFile(final Path file, final long chunkSize) throws IOException {
         long fileSize = java.nio.file.Files.size(file);
         if (fileSize <= chunkSize) return ImmutableList.of(file);
 
         int partCounter = 0;
         long readPosition = 0;
         long remainingSize = fileSize;
         List<Path> files = new ArrayList<>();
 
         try (FileChannel in = FileChannel.open(file, READ)) {
             while (remainingSize > 0) {
                 // write each chunk of data into separate file with different number in name
                 String filePartName = String.format("%s.%03d", file.getFileName(), ++partCounter);
                 Path newFile = file.resolveSibling(filePartName);
                 try (FileChannel out = FileChannel.open(newFile, CREATE_NEW, WRITE)) {
                     for (long position = 0; position < (remainingSize < chunkSize ? remainingSize : chunkSize); ) {
                         position += in.transferTo(readPosition + position, chunkSize - position, out);
                         readPosition += position;
                         remainingSize -= position;
                     }
                 }
                 files.add(newFile);
             }
         }
         return files;
     }
 
     /**
      * Merge a list of files into 1 file
      * the target file must not exists
      *
      * @param files the list of files to merge
      * @param into  the target file
      * @throws IOException if any
      */
     public static void mergeFiles(final List<Path> files, final Path into) throws IOException {
         try (FileChannel out = FileChannel.open(into, CREATE_NEW, WRITE)) {
             for (Path file : files) {
                 try (FileChannel in = FileChannel.open(file, READ)) {
                     for (long position = 0, length = in.size(); position < length; ) {
                         position += in.transferTo(position, length - position, out);
                     }
                 }
             }
         }
     }
 
     /**
      * Get existing splitted up files names of current file
      * The input file can not exists, but it scans the file parent directory for files with similar name ending with a numeric
      *
      * @param file the base file
      * @return the list of splitted up files
      */
     public static List<Path> listOfFilesToMerge(final Path file) throws IOException {
 
         List<Path> files = getDirectoryContent(file.getParent(), entry -> entry.getFileName().toString().matches(file.getFileName().toString() + "[.]\\d+"));
         if (files == null) return null;
         files.sort(Path::compareTo); // ensuring order 001, 002, ..., 010, ...
         return files;
     }
 
     public static long getSize(final Path source) throws IOException {
         if (source == null || !java.nio.file.Files.exists(source)) return 0;
         if (java.nio.file.Files.isRegularFile(source)) return java.nio.file.Files.size(source);
         MutableLong size = new MutableLong(0);
         java.nio.file.Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
             @Override
             public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                 Objects.requireNonNull(file);
                 Objects.requireNonNull(attrs);
                 size.add(attrs.size());
                 return FileVisitResult.CONTINUE;
             }
         });
         return size.getValue();
     }
 
     public static List<Path> getDirectoryContent(final Path directory) throws IOException {
         if (directory == null || !java.nio.file.Files.isDirectory(directory)) return null;
         List<Path> content = new ArrayList<>();
         try (DirectoryStream<Path> directoryStream = java.nio.file.Files.newDirectoryStream(directory)) {
             directoryStream.forEach(content::add);
         }
         return content;
     }
 
     public static List<Path> getDirectoryContent(final Path directory, final DirectoryStream.Filter<Path> filter) throws IOException {
         if (directory == null || !java.nio.file.Files.isDirectory(directory)) return null;
         List<Path> content = new ArrayList<>();
         try (DirectoryStream<Path> directoryStream = java.nio.file.Files.newDirectoryStream(directory, filter)) {
             directoryStream.forEach(content::add);
         }
         return content;
     }
 
     public static long getDirectoryFileCount(Path directory) {
         if (directory == null || !java.nio.file.Files.exists(directory) || !java.nio.file.Files.isDirectory(directory))
             return 0;
         try {
             return java.nio.file.Files.walk(directory).parallel().filter(path -> !java.nio.file.Files.isDirectory(path)).count();
         } catch (IOException e) {
             // simply ignore it
             return 0;
         }
     }
 
 }