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.FilenameUtils;
  import org.apache.maven.plugin.AbstractMojo;
  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.Parameter;
  import org.apache.maven.scm.CommandParameter;
  import org.apache.maven.scm.CommandParameters;
  import org.apache.maven.scm.ScmBranch;
  import org.apache.maven.scm.ScmException;
  import org.apache.maven.scm.ScmFileSet;
  import org.apache.maven.scm.ScmResult;
  import org.apache.maven.scm.command.add.AddScmResult;
  import org.apache.maven.scm.command.checkin.CheckInScmResult;
  import org.apache.maven.scm.manager.NoSuchScmProviderException;
  import org.apache.maven.scm.manager.ScmManager;
  import org.apache.maven.scm.provider.ScmProvider;
  import org.apache.maven.scm.provider.svn.AbstractSvnScmProvider;
  import org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository;
  import org.apache.maven.scm.repository.ScmRepository;
  import org.apache.maven.scm.repository.ScmRepositoryException;
  import org.apache.maven.settings.Settings;
  import org.apache.maven.shared.release.config.ReleaseDescriptor;
  import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
  import org.codehaus.plexus.util.Os;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeSet;
  
  /**
   * Base class for the scm-publish mojos.
   */
  public abstract class AbstractScmPublishMojo
      extends AbstractMojo
  {
      /**
       * Location of the scm publication tree.
       */
      @Parameter ( property = "scmpublish.pubScmUrl", defaultValue = "${project.distributionManagement.site.url}",
                   required = true )
      protected String pubScmUrl;
  
      /**
       * Location where the scm check-out is done.
       */
      @Parameter ( property = "scmpublish.checkoutDirectory",
                   defaultValue = "${project.build.directory}/scmpublish-checkout" )
      protected File checkoutDirectory;
  
      /**
       * Display list of added, deleted, and changed files, but do not do any actual SCM operations.
       */
      @Parameter ( property = "scmpublish.dryRun" )
      private boolean dryRun;
  
      /**
       * Run add and delete commands, but leave the actually checkin for the user to run manually.
       */
      @Parameter ( property = "scmpublish.skipCheckin" )
      private boolean skipCheckin;
  
      /**
       * SCM log/checkin comment for this publication.
       */
      @Parameter ( property = "scmpublish.checkinComment", defaultValue = "Site checkin for project ${project.name}" )
      private String checkinComment;
  
      /**
       * Patterns to exclude from the scm tree.
      */
     @Parameter
     protected String excludes;
 
     /**
      * Patterns to include in the scm tree.
      */
     @Parameter
     protected String includes;
 
     /**
      * List of SCM provider implementations.
      * Key is the provider type, eg. <code>cvs</code>.
      * Value is the provider implementation (the role-hint of the provider), eg. <code>cvs</code> or <code>cvs_native</code>.
      * @see ScmManager.setScmProviderImplementation
      */
     @Parameter
     private Map<String, String> providerImplementations;
 
     /**
      * The SCM manager.
      */
     @Component
     private ScmManager scmManager;
 
     /**
      * Tool that gets a configured SCM repository from release configuration.
      */
     @Component
     protected ScmRepositoryConfigurator scmRepositoryConfigurator;
 
     /**
      * The SCM username to use.
      */
     @Parameter ( property = "username" )
     protected String username;
 
     /**
      * The SCM password to use.
      */
     @Parameter ( property = "password" )
     protected String password;
 
     /**
      * Use a local checkout instead of doing a checkout from the upstream repository. <b>WARNING</b>: This will only work
      * with distributed SCMs which support the file:// protocol
      * TODO: we should think about having the defaults for the various SCM providers provided via Modello!
      */
     @Parameter ( property = "localCheckout", defaultValue = "false" )
     protected boolean localCheckout;
 
     /**
      * The outputEncoding parameter of the site plugin. This plugin will corrupt your site
      * if this does not match the value used by the site plugin.
      */
     @Parameter ( property = "outputEncoding", defaultValue = "${project.reporting.outputEncoding}" )
     protected String siteOutputEncoding;
 
     /**
      * If the checkout directory exists and this flag is activated, the plugin will try an SCM-update rather
      * than delete then checkout.
      */
     @Parameter ( property = "scmpublish.tryUpdate", defaultValue = "false" )
     protected boolean tryUpdate;
 
     /**
      * Do not delete files to the scm
      */
     @Parameter ( property = "scmpublish.skipDeletedFiles", defaultValue = "false" )
     protected boolean skipDeletedFiles;
 
     /**
      */
     @Parameter ( defaultValue = "${basedir}", readonly = true )
     protected File basedir;
 
     /**
      */
     @Component
     protected Settings settings;
 
     /**
      * Collections of paths not to delete when checking content to delete.
      * If your site has subdirectories published by an other mechanism/build
      */
     @Parameter
     protected String[] ignorePathsToDelete;
 
     /**
      * SCM branch to use. For github, you must configure with <code>gh-pages</code>.
      */
     @Parameter ( property = "scmpublish.scm.branch" )
     protected String scmBranch;
 
     /**
      * Configure svn automatic remote url creation.
      */
     @Parameter ( property = "scmpublish.automaticRemotePathCreation", defaultValue = "true" )
     protected boolean automaticRemotePathCreation;
 
     /**
      * Filename extensions of files which need new line normalization.
      */
     private final static String[] NORMALIZE_EXTENSIONS = { "html", "css", "js" };
 
     /**
      * Extra file extensions to normalize line ending (will be added to default
      * <code>html</code>,<code>css</code>,<code>js</code> list)
      */
     @Parameter
     protected String[] extraNormalizeExtensions;
 
     protected ScmProvider scmProvider;
 
     protected ScmRepository scmRepository;
 
     protected void logInfo( String format, Object... params )
     {
         getLog().info( String.format( format, params ) );
     }
 
     protected void logWarn( String format, Object... params )
     {
         getLog().warn( String.format( format, params ) );
     }
 
     protected void logError( String format, Object... params )
     {
         getLog().error( String.format( format, params ) );
     }
 
     private File relativize( File base, File file )
     {
         return new File( base.toURI().relativize( file.toURI() ).getPath() );
     }
 
     protected boolean requireNormalizeNewlines( File f )
         throws IOException
     {
         List<String> extensions = Arrays.asList( NORMALIZE_EXTENSIONS );
         if ( extraNormalizeExtensions != null )
         {
             extensions.addAll( Arrays.asList( extraNormalizeExtensions ) );
         }
 
         return FilenameUtils.isExtension( f.getName(), extensions );
     }
 
     private ReleaseDescriptor setupScm()
         throws ScmRepositoryException, NoSuchScmProviderException
     {
         String scmUrl;
         if ( localCheckout )
         {
             // in the release phase we have to change the checkout URL
             // to do a local checkout instead of going over the network.
 
             // the first step is a bit tricky, we need to know which provider! like e.g. "scm:jgit:http://"
             // the offset of 4 is because 'scm:' has 4 characters...
             String providerPart = pubScmUrl.substring( 0, pubScmUrl.indexOf( ':', 4 ) );
 
             // X TODO: also check the information from releaseDescriptor.getScmRelativePathProjectDirectory()
             // X TODO: in case our toplevel git directory has no pom.
             // X TODO: fix pathname once I understand this.
             scmUrl = providerPart + ":file://" + "target/localCheckout";
             logInfo( "Performing a LOCAL checkout from " + scmUrl );
         }
 
         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
         releaseDescriptor.setInteractive( settings.isInteractiveMode() );
 
         //TODO use from settings with decrypt stuff
 
         releaseDescriptor.setScmPassword( password );
         releaseDescriptor.setScmUsername( username );
 
         releaseDescriptor.setWorkingDirectory( basedir.getAbsolutePath() );
         releaseDescriptor.setLocalCheckout( localCheckout );
         releaseDescriptor.setScmSourceUrl( pubScmUrl );
 
         if ( providerImplementations != null )
         {
             for ( Map.Entry<String, String> providerEntry : providerImplementations.entrySet() )
             {
                 logInfo( "Changing the default '%s' provider implementation to '%s'.", providerEntry.getKey(),
                          providerEntry.getValue() );
                 scmManager.setScmProviderImplementation( providerEntry.getKey(), providerEntry.getValue() );
             }
         }
 
         scmRepository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );
 
         scmProvider = scmRepositoryConfigurator.getRepositoryProvider( scmRepository );
 
         return releaseDescriptor;
     }
 
     protected void checkoutExisting()
         throws MojoExecutionException
     {
 
         if ( scmProvider instanceof AbstractSvnScmProvider )
         {
             checkCreateRemoteSvnPath();
         }
 
         logInfo( "%s the pub tree from  %s ...", ( tryUpdate ? "Updating" : "Checking out" ), pubScmUrl );
 
         if ( checkoutDirectory.exists() && !tryUpdate )
 
         {
             try
             {
                 FileUtils.deleteDirectory( checkoutDirectory );
             }
             catch ( IOException e )
             {
                 logError( e.getMessage() );
 
                 throw new MojoExecutionException( "Unable to remove old checkout directory: " + e.getMessage(), e );
             }
         }
 
         boolean forceCheckout = false;
 
         if ( !checkoutDirectory.exists() )
 
         {
             if ( tryUpdate )
             {
                 logInfo( "TryUpdate is configured but no local copy currently available: forcing checkout." );
             }
             checkoutDirectory.mkdirs();
             forceCheckout = true;
         }
 
         try
         {
             ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, includes, excludes );
 
             ScmResult scmResult;
             if ( tryUpdate && !forceCheckout )
             {
                 scmResult = scmProvider.update( scmRepository, fileSet );
             }
             else if ( scmBranch == null )
             {
                 scmResult = scmProvider.checkOut( scmRepository, fileSet );
             }
             else
             {
                 ScmBranch scmBranch = new ScmBranch( this.scmBranch );
                 scmResult = scmProvider.checkOut( scmRepository, fileSet, scmBranch );
             }
 
             checkScmResult( scmResult, "check out from SCM" );
         }
         catch ( ScmException e )
         {
             logError( e.getMessage() );
 
             throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
         }
         catch ( IOException e )
         {
             logError( e.getMessage() );
 
             throw new MojoExecutionException( "An error occurred during the checkout process: " + e.getMessage(), e );
         }
     }
 
     private void checkCreateRemoteSvnPath()
         throws MojoExecutionException
     {
         getLog().debug( "AbstractSvnScmProvider used, so we can check if remote url exists and eventually create it." );
         AbstractSvnScmProvider svnScmProvider = (AbstractSvnScmProvider) scmProvider;
 
         try
         {
             boolean remoteExists = svnScmProvider.remoteUrlExist( scmRepository.getProviderRepository(), null );
 
             if ( remoteExists )
             {
                 return;
             }
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
 
         String remoteUrl = ( (SvnScmProviderRepository) scmRepository.getProviderRepository() ).getUrl();
 
         if ( !automaticRemotePathCreation )
         {
             // olamy: return ?? that will fail during checkout IMHO :-)
             logWarn( "Remote svn url %s does not exist and automatic remote path creation disabled.",
                      remoteUrl );
             return;
         }
 
         logInfo( "Remote svn url %s does not exist: creating.", remoteUrl );
 
         File baseDir = null;
         try
         {
 
             // create a temporary directory for svnexec
             baseDir = File.createTempFile( "scm", "tmp" );
             baseDir.delete();
             baseDir.mkdirs();
             // to prevent fileSet cannot be empty
             ScmFileSet scmFileSet = new ScmFileSet( baseDir, new File( "" ) );
 
             CommandParameters commandParameters = new CommandParameters();
             commandParameters.setString( CommandParameter.SCM_MKDIR_CREATE_IN_LOCAL, Boolean.FALSE.toString() );
             commandParameters.setString( CommandParameter.MESSAGE, "Automatic svn path creation: " + remoteUrl );
             svnScmProvider.mkdir( scmRepository.getProviderRepository(), scmFileSet, commandParameters );
 
             // new remote url so force checkout!
             if ( checkoutDirectory.exists() )
             {
                 FileUtils.deleteDirectory( checkoutDirectory );
             }
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         finally
         {
             if ( baseDir != null )
             {
                 try
                 {
                     FileUtils.forceDeleteOnExit( baseDir );
                 }
                 catch ( IOException e )
                 {
                     throw new MojoExecutionException( e.getMessage(), e );
                 }
             }
         }
     }
 
     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
         // setup the scm plugin with help from release plugin utilities
         try
         {
             setupScm();
         }
         catch ( ScmRepositoryException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
         catch ( NoSuchScmProviderException e )
         {
             throw new MojoExecutionException( e.getMessage(), e );
         }
 
         boolean tmpCheckout = false;
 
         if ( checkoutDirectory.getPath().contains( "${project." ) )
         {
             try
             {
                 tmpCheckout = true;
                 checkoutDirectory = File.createTempFile( "maven-scm-publish", ".checkout" );
                 checkoutDirectory.delete();
                 checkoutDirectory.mkdir();
             }
             catch ( IOException ioe )
             {
                 throw new MojoExecutionException( ioe.getMessage(), ioe );
             }
         }
 
         try
         {
             scmPublishExecute();
         }
         finally
         {
             if ( tmpCheckout )
             {
                 FileUtils.deleteQuietly( checkoutDirectory );
             }
         }
     }
 
     /**
      * Check-in content from scm checkout.
      *
      * @throws MojoExecutionException
      */
     protected void checkinFiles()
         throws MojoExecutionException
     {
         if ( skipCheckin )
         {
             return;
         }
 
         ScmFileSet updatedFileSet = new ScmFileSet( checkoutDirectory );
         try
         {
             logInfo( "Checking in to the scm" );
 
             CheckInScmResult checkinResult =
                 checkScmResult( scmProvider.checkIn( scmRepository, updatedFileSet, new ScmBranch( scmBranch ),
                                                      checkinComment ), "check-in files to SCM" );
 
             logInfo( "Checked in %d file(s) to revision: %s", checkinResult.getCheckedInFiles().size(),
                      checkinResult.getScmRevision() );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to perform SCM checkin", e );
         }
     }
 
     protected void deleteFiles( Collection<File> deleted )
         throws MojoExecutionException
     {
         if ( skipDeletedFiles )
         {
             logInfo( "Deleting files is skipped." );
             return;
         }
         List<File> deletedList = new ArrayList<File>();
         for ( File f : deleted )
         {
             deletedList.add( relativize( checkoutDirectory, f ) );
         }
         ScmFileSet deletedFileSet = new ScmFileSet( checkoutDirectory, deletedList );
         try
         {
             getLog().debug( "Deleting files: " + deletedList );
 
             checkScmResult( scmProvider.remove( scmRepository, deletedFileSet, "Deleting obsolete site files." ),
                             "delete files from SCM" );
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to delete removed files to SCM", e );
         }
     }
 
     /**
      * Add files to scm.
      *
      * @param added files to be added
      * @throws MojoFailureException
      * @throws MojoExecutionException
      */
     protected void addFiles( Collection<File> added )
         throws MojoFailureException, MojoExecutionException
     {
         List<File> addedList = new ArrayList<File>();
         Set<File> createdDirs = new HashSet<File>();
         Set<File> dirsToAdd = new TreeSet<File>();
 
         createdDirs.add( relativize( checkoutDirectory, checkoutDirectory ) );
 
         for ( File f : added )
         {
             for ( File dir = f.getParentFile(); !dir.equals( checkoutDirectory ); dir = dir.getParentFile() )
             {
                 File relativized = relativize( checkoutDirectory, dir );
                 //  we do the best we can with the directories
                 if ( createdDirs.add( relativized ) )
                 {
                     dirsToAdd.add( relativized );
                 }
                 else
                 {
                     break;
                 }
             }
             addedList.add( relativize( checkoutDirectory, f ) );
         }
 
         for ( File relativized : dirsToAdd )
         {
             try
             {
                 ScmFileSet fileSet = new ScmFileSet( checkoutDirectory, relativized );
                 getLog().debug( "scm add directory: " + relativized );
                 AddScmResult addDirResult = scmProvider.add( scmRepository, fileSet, "Adding directory" );
                 if ( !addDirResult.isSuccess() )
                 {
                     getLog().debug( " Error adding directory " + relativized + ": " + addDirResult.getCommandOutput() );
                 }
             }
             catch ( ScmException e )
             {
                 //
             }
         }
 
         // remove directories already added !
         addedList.removeAll( dirsToAdd );
 
         ScmFileSet addedFileSet = new ScmFileSet( checkoutDirectory, addedList );
         getLog().debug( "scm add files: " + addedList );
         try
         {
 
                 CommandParameters commandParameters = new CommandParameters();
                 commandParameters.setString( CommandParameter.MESSAGE, "Adding new site files." );
                 commandParameters.setString( CommandParameter.FORCE_ADD, Boolean.TRUE.toString() );
                 checkScmResult( scmProvider.add( scmRepository, addedFileSet, commandParameters ),
                                 "add new files to SCM" );
 
         }
         catch ( ScmException e )
         {
             throw new MojoExecutionException( "Failed to add new files to SCM", e );
         }
     }
 
     private<T extends ScmResult> T checkScmResult( T result, String failure )
         throws MojoExecutionException
     {
         if ( !result.isSuccess() )
         {
             String msg = "Failed to " + failure + ": " + result.getProviderMessage() + " " + result.getCommandOutput();
             logError( msg );
             throw new MojoExecutionException( msg );
         }
         return result;
     }
 
     public boolean isDryRun()
     {
         return dryRun;
     }
 
     public abstract void scmPublishExecute()
         throws MojoExecutionException, MojoFailureException;
 }