package org.apache.maven.plugins.scmpublish;
   
   /*
    * 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 org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.io.filefilter.NameFileFilter;
  import org.apache.commons.io.filefilter.NotFileFilter;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.Component;
  import org.apache.maven.plugins.annotations.Mojo;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.MatchPatterns;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  /**
   * Publish a content to scm. By default, content is taken from default site staging directory
   * <code>${project.build.directory}/staging</code>.
   * Can be used without project, so usable to update any SCM with any content.
   */
  @Mojo ( name = "publish-scm", aggregator = true, requiresProject = false )
  public class ScmPublishPublishScmMojo
      extends AbstractScmPublishMojo
  {
      /**
       * The content to be published.
       */
      @Parameter ( property = "scmpublish.content", defaultValue = "${project.build.directory}/staging" )
      private File content;
  
      /**
       */
      @Component
      protected MavenProject project;
  
      private List<File> deleted = new ArrayList<File>();
  
      private List<File> added = new ArrayList<File>();
  
      private List<File> updated = new ArrayList<File>();
  
      /**
       * Update scm checkout directory with content.
       *
       * @param checkout        the scm checkout directory
       * @param dir             the content to put in scm (can be <code>null</code>)
       * @param doNotDeleteDirs directory names that should not be deleted from scm even if not in new content:
       *                        used for modules, which content is available only when staging
       * @throws IOException
       */
      private void update( File checkout, File dir, List<String> doNotDeleteDirs )
          throws IOException
      {
          String[] files =
              checkout.list( new NotFileFilter( new NameFileFilter( scmProvider.getScmSpecificFilename() ) ) );
  
          Set<String> checkoutContent = new HashSet<String>( Arrays.asList( files ) );
          List<String> dirContent = ( dir != null ) ? Arrays.asList( dir.list() ) : Collections.<String>emptyList();
  
          Set<String> deleted = new HashSet<String>( checkoutContent );
          deleted.removeAll( dirContent );
  
          MatchPatterns ignoreDeleteMatchPatterns = null;
          List<String> pathsAsList = new ArrayList<String>( 0 );
          if ( ignorePathsToDelete != null && ignorePathsToDelete.length > 0 )
          {
             ignoreDeleteMatchPatterns = MatchPatterns.from( ignorePathsToDelete );
             pathsAsList = Arrays.asList( ignorePathsToDelete );
         }
 
         for ( String name : deleted )
         {
             if ( ignoreDeleteMatchPatterns != null && ignoreDeleteMatchPatterns.matches( name, true ) )
             {
                 getLog().debug(
                     name + " match one of the patterns '" + pathsAsList + "': do not add to deleted files" );
                 continue;
             }
             getLog().debug( "file marked for deletion:" + name );
             File file = new File( checkout, name );
 
             if ( ( doNotDeleteDirs != null ) && file.isDirectory() && ( doNotDeleteDirs.contains( name ) ) )
             {
                 // ignore directory not available
                 continue;
             }
 
             if ( file.isDirectory() )
             {
                 update( file, null, null );
             }
             this.deleted.add( file );
         }
 
         for ( String name : dirContent )
         {
             File file = new File( checkout, name );
             File source = new File( dir, name );
 
             if ( source.isDirectory() )
             {
                 if ( !checkoutContent.contains( name ) )
                 {
                     this.added.add( file );
                     file.mkdir();
                 }
 
                 update( file, source, null );
             }
             else
             {
                 if ( checkoutContent.contains( name ) )
                 {
                     this.updated.add( file );
                 }
                 else
                 {
                     this.added.add( file );
                 }
 
                 copyFile( source, file );
             }
         }
     }
 
     /**
      * Copy a file content, normalizing newlines when necessary.
      *
      * @param srcFile  the source file
      * @param destFile the destination file
      * @throws IOException
      * @see #requireNormalizeNewlines(File)
      */
     private void copyFile( File srcFile, File destFile )
         throws IOException
     {
         if ( requireNormalizeNewlines( srcFile ) )
         {
             copyAndNormalizeNewlines( srcFile, destFile );
         }
         else
         {
             FileUtils.copyFile( srcFile, destFile );
         }
     }
 
     /**
      * Copy and normalize newlines.
      *
      * @param srcFile  the source file
      * @param destFile the destination file
      * @throws IOException
      */
     private void copyAndNormalizeNewlines( File srcFile, File destFile )
         throws IOException
     {
         BufferedReader in = null;
         PrintWriter out = null;
         try
         {
             in = new BufferedReader( new InputStreamReader( new FileInputStream( srcFile ), siteOutputEncoding ) );
             out = new PrintWriter( new OutputStreamWriter( new FileOutputStream( destFile ), siteOutputEncoding ) );
             String line;
             while ( ( line = in.readLine() ) != null )
             {
                 if ( in.ready() )
                 {
                     out.println( line );
                 }
                 else
                 {
                     out.print( line );
                 }
             }
         }
         finally
         {
             IOUtils.closeQuietly( out );
             IOUtils.closeQuietly( in );
         }
     }
 
     public void scmPublishExecute()
         throws MojoExecutionException, MojoFailureException
     {
         if ( siteOutputEncoding == null )
         {
             getLog().warn( "No output encoding, defaulting to UTF-8." );
             siteOutputEncoding = "utf-8";
         }
 
         if ( !content.exists() )
         {
             throw new MojoExecutionException( "Configured content directory does not exist: " + content );
         }
 
         if ( !content.canRead() )
         {
             throw new MojoExecutionException( "Can't read content directory: " + content );
         }
 
         checkoutExisting();
 
         try
         {
             logInfo( "Updating content..." );
             update( checkoutDirectory, content, ( project == null ) ? null : project.getModel().getModules() );
         }
         catch ( IOException ioe )
         {
             throw new MojoExecutionException( "Could not copy content to scm checkout", ioe );
         }
 
         logInfo( "Publish files: %d addition(s), %d update(s), %d delete(s)", added.size(), updated.size(),
                  deleted.size() );
 
         if ( isDryRun() )
         {
             for ( File addedFile : added )
             {
                 logInfo( "Added %s", addedFile.getAbsolutePath() );
             }
             for ( File deletedFile : deleted )
             {
                 logInfo( "Deleted %s", deletedFile.getAbsolutePath() );
             }
             for ( File updatedFile : updated )
             {
                 logInfo( "Updated %s", updatedFile.getAbsolutePath() );
             }
             return;
         }
 
         if ( !added.isEmpty() )
         {
             addFiles( added );
         }
 
         if ( !deleted.isEmpty() )
         {
             deleteFiles( deleted );
         }
 
         logInfo( "Checking in SCM..." );
         checkinFiles();
     }
 }