package org.apache.maven.plugins.clean;
   
   /*
    * 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.
   */
  
  import java.io.File;
  import java.io.IOException;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.StandardCopyOption;
  import java.util.ArrayDeque;
  import java.util.Deque;
  
  import org.apache.maven.execution.ExecutionListener;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.shared.utils.Os;
  import org.eclipse.aether.SessionData;
  
  import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_BACKGROUND;
  import static org.apache.maven.plugins.clean.CleanMojo.FAST_MODE_DEFER;
  
  /**
   * Cleans directories.
   * 
   * @author Benjamin Bentmann
   */
  class Cleaner
  {
  
      private static final boolean ON_WINDOWS = Os.isFamily( Os.FAMILY_WINDOWS );
  
      private static final String LAST_DIRECTORY_TO_DELETE = Cleaner.class.getName() + ".lastDirectoryToDelete";
  
      /**
       * The maven session.  This is typically non-null in a real run, but it can be during unit tests.
       */
      private final MavenSession session;
  
      private final Logger logDebug;
  
      private final Logger logInfo;
  
      private final Logger logVerbose;
  
      private final Logger logWarn;
  
      private final File fastDir;
  
      private final String fastMode;
  
      /**
       * Creates a new cleaner.
       * @param log The logger to use, may be <code>null</code> to disable logging.
       * @param verbose Whether to perform verbose logging.
       * @param fastMode The fast deletion mode
       */
      Cleaner( MavenSession session, final Log log, boolean verbose, File fastDir, String fastMode )
      {
          logDebug = ( log == null || !log.isDebugEnabled() ) ? null : log::debug;
  
          logInfo = ( log == null || !log.isInfoEnabled() ) ? null : log::info;
  
          logWarn = ( log == null || !log.isWarnEnabled() ) ? null : log::warn;
  
          logVerbose = verbose ? logInfo : logDebug;
  
          this.session = session;
          this.fastDir = fastDir;
          this.fastMode = fastMode;
      }
  
      /**
       * Deletes the specified directories and its contents.
       * 
       * @param basedir The directory to delete, must not be <code>null</code>. Non-existing directories will be silently
       *            ignored.
       * @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
       *            everything.
       * @param followSymlinks Whether to follow symlinks.
      * @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     public void delete( File basedir, Selector selector, boolean followSymlinks, boolean failOnError,
                         boolean retryOnError )
         throws IOException
     {
         if ( !basedir.isDirectory() )
         {
             if ( !basedir.exists() )
             {
                 if ( logDebug != null )
                 {
                     logDebug.log( "Skipping non-existing directory " + basedir );
                 }
                 return;
             }
             throw new IOException( "Invalid base directory " + basedir );
         }
 
         if ( logInfo != null )
         {
             logInfo.log( "Deleting " + basedir + ( selector != null ? " (" + selector + ")" : "" ) );
         }
 
         File file = followSymlinks ? basedir : basedir.getCanonicalFile();
 
         if ( selector == null && !followSymlinks && fastDir != null && session != null )
         {
             // If anything wrong happens, we'll just use the usual deletion mechanism
             if ( fastDelete( file ) )
             {
                 return;
             }
         }
 
         delete( file, "", selector, followSymlinks, failOnError, retryOnError );
     }
 
     private boolean fastDelete( File baseDirFile )
     {
         Path baseDir = baseDirFile.toPath();
         Path fastDir = this.fastDir.toPath();
         // Handle the case where we use ${maven.multiModuleProjectDirectory}/target/.clean for example
         if ( fastDir.toAbsolutePath().startsWith( baseDir.toAbsolutePath() ) )
         {
             try
             {
                 String prefix = baseDir.getFileName().toString() + ".";
                 Path tmpDir = Files.createTempDirectory( baseDir.getParent(), prefix );
                 try
                 {
                     Files.move( baseDir, tmpDir, StandardCopyOption.REPLACE_EXISTING );
                     if ( session != null )
                     {
                         session.getRepositorySession().getData().set( LAST_DIRECTORY_TO_DELETE, baseDir.toFile() );
                     }
                     baseDir = tmpDir;
                 }
                 catch ( IOException e )
                 {
                     Files.delete( tmpDir );
                     throw e;
                 }
             }
             catch ( IOException e )
             {
                 if ( logDebug != null )
                 {
                     // TODO: this Logger interface cannot log exceptions and needs refactoring
                     logDebug.log( "Unable to fast delete directory: " + e );
                 }
                 return false;
             }
         }
         // Create fastDir and the needed parents if needed
         try
         {
             if ( !Files.isDirectory( fastDir ) )
             {
                 Files.createDirectories( fastDir );
             }
         }
         catch ( IOException e )
         {
             if ( logDebug != null )
             {
                 // TODO: this Logger interface cannot log exceptions and needs refactoring
                 logDebug.log( "Unable to fast delete directory as the path "
                         + fastDir + " does not point to a directory or cannot be created: " + e );
             }
             return false;
         }
 
         try
         {
             Path tmpDir = Files.createTempDirectory( fastDir, "" );
             Path dstDir = tmpDir.resolve( baseDir.getFileName() );
             // Note that by specifying the ATOMIC_MOVE, we expect an exception to be thrown
             // if the path leads to a directory on another mountpoint.  If this is the case
             // or any other exception occurs, an exception will be thrown in which case
             // the method will return false and the usual deletion will be performed.
             Files.move( baseDir, dstDir, StandardCopyOption.ATOMIC_MOVE );
             BackgroundCleaner.delete( this, tmpDir.toFile(), fastMode );
             return true;
         }
         catch ( IOException e )
         {
             if ( logDebug != null )
             {
                 // TODO: this Logger interface cannot log exceptions and needs refactoring
                 logDebug.log( "Unable to fast delete directory: " + e );
             }
             return false;
         }
     }
 
     /**
      * Deletes the specified file or directory.
      * 
      * @param file The file/directory to delete, must not be <code>null</code>. If <code>followSymlinks</code> is
      *            <code>false</code>, it is assumed that the parent file is canonical.
      * @param pathname The relative pathname of the file, using {@link File#separatorChar}, must not be
      *            <code>null</code>.
      * @param selector The selector used to determine what contents to delete, may be <code>null</code> to delete
      *            everything.
      * @param followSymlinks Whether to follow symlinks.
      * @param failOnError Whether to abort with an exception in case a selected file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @return The result of the cleaning, never <code>null</code>.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     private Result delete( File file, String pathname, Selector selector, boolean followSymlinks, boolean failOnError,
                            boolean retryOnError )
         throws IOException
     {
         Result result = new Result();
 
         boolean isDirectory = file.isDirectory();
 
         if ( isDirectory )
         {
             if ( selector == null || selector.couldHoldSelected( pathname ) )
             {
                 final boolean isSymlink = Files.isSymbolicLink( file.toPath() );
                 File canonical = followSymlinks ? file : file.getCanonicalFile();
                 if ( followSymlinks || !isSymlink )
                 {
                     String[] filenames = canonical.list();
                     if ( filenames != null )
                     {
                         String prefix = pathname.length() > 0 ? pathname + File.separatorChar : "";
                         for ( int i = filenames.length - 1; i >= 0; i-- )
                         {
                             String filename = filenames[i];
                             File child = new File( canonical, filename );
                             result.update( delete( child, prefix + filename, selector, followSymlinks, failOnError,
                                                    retryOnError ) );
                         }
                     }
                 }
                 else if ( logDebug != null )
                 {
                     logDebug.log( "Not recursing into symlink " + file );
                 }
             }
             else if ( logDebug != null )
             {
                 logDebug.log( "Not recursing into directory without included files " + file );
             }
         }
 
         if ( !result.excluded && ( selector == null || selector.isSelected( pathname ) ) )
         {
             if ( logVerbose != null )
             {
                 if ( isDirectory )
                 {
                     logVerbose.log( "Deleting directory " + file );
                 }
                 else if ( file.exists() )
                 {
                     logVerbose.log( "Deleting file " + file );
                 }
                 else
                 {
                     logVerbose.log( "Deleting dangling symlink " + file );
                 }
             }
             result.failures += delete( file, failOnError, retryOnError );
         }
         else
         {
             result.excluded = true;
         }
 
         return result;
     }
 
     /**
      * Deletes the specified file, directory. If the path denotes a symlink, only the link is removed, its target is
      * left untouched.
      * 
      * @param file The file/directory to delete, must not be <code>null</code>.
      * @param failOnError Whether to abort with an exception in case the file/directory could not be deleted.
      * @param retryOnError Whether to undertake additional delete attempts in case the first attempt failed.
      * @return <code>0</code> if the file was deleted, <code>1</code> otherwise.
      * @throws IOException If a file/directory could not be deleted and <code>failOnError</code> is <code>true</code>.
      */
     private int delete( File file, boolean failOnError, boolean retryOnError )
         throws IOException
     {
         if ( !file.delete() )
         {
             boolean deleted = false;
 
             if ( retryOnError )
             {
                 if ( ON_WINDOWS )
                 {
                     // try to release any locks held by non-closed files
                     System.gc();
                 }
 
                 final int[] delays = { 50, 250, 750 };
                 for ( int i = 0; !deleted && i < delays.length; i++ )
                 {
                     try
                     {
                         Thread.sleep( delays[i] );
                     }
                     catch ( InterruptedException e )
                     {
                         // ignore
                     }
                     deleted = file.delete() || !file.exists();
                 }
             }
             else
             {
                 deleted = !file.exists();
             }
 
             if ( !deleted )
             {
                 if ( failOnError )
                 {
                     throw new IOException( "Failed to delete " + file );
                 }
                 else
                 {
                     if ( logWarn != null )
                     {
                         logWarn.log( "Failed to delete " + file );
                     }
                     return 1;
                 }
             }
         }
 
         return 0;
     }
 
     private static class Result
     {
 
         private int failures;
 
         private boolean excluded;
 
         public void update( Result result )
         {
             failures += result.failures;
             excluded |= result.excluded;
         }
 
     }
 
     private interface Logger
     {
 
         void log( CharSequence message );
 
     }
 
     private static class BackgroundCleaner extends Thread
     {
 
         private static BackgroundCleaner instance;
 
         private final Deque<File> filesToDelete = new ArrayDeque<>();
 
         private final Cleaner cleaner;
 
         private final String fastMode;
 
         private static final int NEW = 0;
         private static final int RUNNING = 1;
         private static final int STOPPED = 2;
 
         private int status = NEW;
 
         public static void delete( Cleaner cleaner, File dir, String fastMode )
         {
             synchronized ( BackgroundCleaner.class )
             {
                 if ( instance == null || !instance.doDelete( dir ) )
                 {
                     instance = new BackgroundCleaner( cleaner, dir, fastMode );
                 }
             }
         }
 
         static void sessionEnd()
         {
             synchronized ( BackgroundCleaner.class )
             {
                 if ( instance != null )
                 {
                     instance.doSessionEnd();
                 }
             }
         }
 
         private BackgroundCleaner( Cleaner cleaner, File dir, String fastMode )
         {
             super( "mvn-background-cleaner" );
             this.cleaner = cleaner;
             this.fastMode = fastMode;
             init( cleaner.fastDir, dir );
         }
 
         public void run()
         {
             while ( true )
             {
                 File basedir = pollNext();
                 if ( basedir == null )
                 {
                     break;
                 }
                 try
                 {
                     cleaner.delete( basedir, "", null, false, false, true );
                 }
                 catch ( IOException e )
                 {
                     // do not display errors
                 }
             }
         }
 
         synchronized void init( File fastDir, File dir )
         {
             if ( fastDir.isDirectory() )
             {
                 File[] children = fastDir.listFiles();
                 if ( children != null && children.length > 0 )
                 {
                     for ( File child : children )
                     {
                         doDelete( child );
                     }
                 }
             }
             doDelete( dir );
         }
 
         synchronized File pollNext()
         {
             File basedir = filesToDelete.poll();
             if ( basedir == null )
             {
                 if ( cleaner.session != null )
                 {
                     SessionData data = cleaner.session.getRepositorySession().getData();
                     File lastDir = ( File ) data.get( LAST_DIRECTORY_TO_DELETE );
                     if ( lastDir != null )
                     {
                         data.set( LAST_DIRECTORY_TO_DELETE, null );
                         return lastDir;
                     }
                 }
                 status = STOPPED;
                 notifyAll();
             }
             return basedir;
         }
 
         synchronized boolean doDelete( File dir )
         {
             if ( status == STOPPED )
             {
                 return false;
             }
             filesToDelete.add( dir );
             if ( status == NEW && FAST_MODE_BACKGROUND.equals( fastMode ) )
             {
                 status = RUNNING;
                 notifyAll();
                 start();
             }
             wrapExecutionListener();
             return true;
         }
 
         /**
          * If this has not been done already, we wrap the ExecutionListener inside a proxy
          * which simply delegates call to the previous listener.  When the session ends, it will
          * also call {@link BackgroundCleaner#sessionEnd()}.
          * There's no clean API to do that properly as this is a very unusual use case for a plugin
          * to outlive its main execution.
          */
         private void wrapExecutionListener()
         {
             ExecutionListener executionListener = cleaner.session.getRequest().getExecutionListener();
             if ( executionListener == null
                     || !Proxy.isProxyClass( executionListener.getClass() )
                     || !( Proxy.getInvocationHandler( executionListener ) instanceof SpyInvocationHandler ) )
             {
                 ExecutionListener listener = ( ExecutionListener ) Proxy.newProxyInstance(
                         ExecutionListener.class.getClassLoader(),
                         new Class[] { ExecutionListener.class },
                         new SpyInvocationHandler( executionListener ) );
                 cleaner.session.getRequest().setExecutionListener( listener );
             }
         }
 
         synchronized void doSessionEnd()
         {
             if ( status != STOPPED )
             {
                 if ( status == NEW )
                 {
                     start();
                 }
                 if ( !FAST_MODE_DEFER.equals( fastMode ) )
                 {
                     try
                     {
                         cleaner.logInfo.log( "Waiting for background file deletion" );
                         while ( status != STOPPED )
                         {
                             wait();
                         }
                     }
                     catch ( InterruptedException e )
                     {
                         // ignore
                     }
                 }
             }
         }
 
     }
 
     static class SpyInvocationHandler implements InvocationHandler
     {
         private final ExecutionListener delegate;
 
         SpyInvocationHandler( ExecutionListener delegate )
         {
             this.delegate = delegate;
         }
 
         @Override
         public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
         {
             if ( "sessionEnded".equals( method.getName() ) )
             {
                 BackgroundCleaner.sessionEnd();
             }
             if ( delegate != null )
             {
                 return method.invoke( delegate, args );
             }
             return null;
         }
 
     }
 
 }