package fr.ifremer.quadrige2.core.dao.technical;
   
   /*-
    * #%L
    * Quadrige2 Core :: Quadrige2 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 fr.ifremer.quadrige2.core.exception.Quadrige2TechnicalException;
  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.nio.file.*;
  import java.nio.file.attribute.BasicFileAttributes;
  
  /**
   * @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 = 1048576;
  
      private Files() {
          // no instance
      }
  
      /**
       * 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.
       */
      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);
          }
      }
  
      /**
       * <p>cleanDirectory.</p>
       *
       * @param directory a {@link java.io.File} object.
       * @param failMessage a {@link java.lang.String} object.
       */
      public static void cleanDirectory(File directory, String failMessage) {
  
          Path path = directory.toPath();
          int nbAttempt = 0;
          IOException lastException = null;
          while (isDirectoryNotEmpty(path) && nbAttempt < 10) {
              nbAttempt++;
              try {
                  java.nio.file.Files.walkFileTree(path, new RecursiveDeleteFileVisitor(path));
                  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 Quadrige2TechnicalException(failMessage, lastException);
         }
         if (log.isWarnEnabled() && nbAttempt > 1) {
             log.warn(String.format("cleaning the directory '%s' successful after %d attempts", directory.getAbsolutePath(), 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 RecursiveDeleteFileVisitor(Path root) {
             this.root = root;
         }
 
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
 
             // delete the file
             java.nio.file.Files.deleteIfExists(file);
             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;
         }
 
     }
 }