package org.apache.maven.wagon.providers.scm;
   
   /*
    * 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.maven.scm.ScmBranch;
  import org.apache.maven.scm.ScmException;
  import org.apache.maven.scm.ScmFile;
  import org.apache.maven.scm.ScmFileSet;
  import org.apache.maven.scm.ScmResult;
  import org.apache.maven.scm.ScmRevision;
  import org.apache.maven.scm.ScmTag;
  import org.apache.maven.scm.ScmVersion;
  import org.apache.maven.scm.command.add.AddScmResult;
  import org.apache.maven.scm.command.checkout.CheckOutScmResult;
  import org.apache.maven.scm.command.list.ListScmResult;
  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.ScmProviderRepository;
  import org.apache.maven.scm.provider.ScmProviderRepositoryWithHost;
  import org.apache.maven.scm.repository.ScmRepository;
  import org.apache.maven.scm.repository.ScmRepositoryException;
  import org.apache.maven.wagon.AbstractWagon;
  import org.apache.maven.wagon.ConnectionException;
  import org.apache.maven.wagon.ResourceDoesNotExistException;
  import org.apache.maven.wagon.TransferFailedException;
  import org.apache.maven.wagon.authorization.AuthorizationException;
  import org.apache.maven.wagon.events.TransferEvent;
  import org.apache.maven.wagon.resource.Resource;
  import org.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.text.DecimalFormat;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Random;
  import java.util.Stack;
  
  /**
   * Wagon provider to get and put files from and to SCM systems, using Maven-SCM as underlying transport.
   * <p/>
   * TODO it probably creates problems if the same wagon is used in two different SCM protocols, as instance variables can
   * keep incorrect state.
   * TODO: For doing releases we either have to be able to add files with checking out the repository structure which may not be
   * possible, or the checkout directory needs to be a constant. Doing releases won't scale if you have to checkout the
   * whole repository structure in order to add 3 files.
   *
   * @author <a href="brett@apache.org">Brett Porter</a>
   * @author <a href="evenisse@apache.org">Emmanuel Venisse</a>
   * @author <a href="carlos@apache.org">Carlos Sanchez</a>
   * @author Jason van Zyl
   * @version $Id: ScmWagon.java 1174113 2011-09-22 13:16:22Z olamy $
   * @plexus.component role="org.apache.maven.wagon.Wagon" role-hint="scm" instantiation-strategy="per-lookup"
   */
  public class ScmWagon
      extends AbstractWagon
  {
      /**
       * @plexus.requirement
       */
      private ScmManager scmManager;
  
      /**
       * The SCM version, if any.
       *
       * @parameter
       */
      private String scmVersion;
  
      /**
       * The SCM version type, if any. Defaults to "branch".
       *
       * @parameter
       */
      private String scmVersionType;
  
      private File checkoutDirectory;
  
      /**
      * Get the {@link ScmManager} used in this Wagon
      *
      * @return the {@link ScmManager}
      */
     public ScmManager getScmManager()
     {
         return scmManager;
     }
 
     /**
      * Set the {@link ScmManager} used in this Wagon
      *
      * @param scmManager
      */
     public void setScmManager( ScmManager scmManager )
     {
         this.scmManager = scmManager;
     }
 
     /**
      * Get the scmVersion used in this Wagon
      *
      * @return the scmVersion
      */
     public String getScmVersion()
     {
         return scmVersion;
     }
 
     /**
      * Set the scmVersion
      *
      * @param scmVersion the scmVersion to set
      */
     public void setScmVersion( String scmVersion )
     {
         this.scmVersion = scmVersion;
     }
 
     /**
      * Get the scmVersionType used in this Wagon
      *
      * @return the scmVersionType
      */
     public String getScmVersionType()
     {
         return scmVersionType;
     }
 
     /**
      * Set the scmVersionType
      *
      * @param scmVersionType the scmVersionType to set
      */
     public void setScmVersionType( String scmVersionType )
     {
         this.scmVersionType = scmVersionType;
     }
 
     /**
      * Get the directory where Wagon will checkout files from SCM. This directory will be deleted!
      *
      * @return directory
      */
     public File getCheckoutDirectory()
     {
         return checkoutDirectory;
     }
 
     /**
      * Set the directory where Wagon will checkout files from SCM. This directory will be deleted!
      *
      * @param checkoutDirectory
      */
     public void setCheckoutDirectory( File checkoutDirectory )
     {
         this.checkoutDirectory = checkoutDirectory;
     }
 
     /**
      * Convenience method to get the {@link ScmProvider} implementation to handle the provided SCM type
      *
      * @param scmType type of SCM, eg. <code>svn</code>, <code>cvs</code>
      * @return the {@link ScmProvider} that will handle provided SCM type
      * @throws NoSuchScmProviderException if there is no {@link ScmProvider} able to handle that SCM type
      */
     public ScmProvider getScmProvider( String scmType )
         throws NoSuchScmProviderException
     {
         return getScmManager().getProviderByType( scmType );
     }
 
     /**
      * This will cleanup the checkout directory
      */
     public void openConnectionInternal()
         throws ConnectionException
     {
         if ( checkoutDirectory == null )
         {
             checkoutDirectory = createCheckoutDirectory();
         }
 
         if ( checkoutDirectory.exists() )
         {
             removeCheckoutDirectory();
         }
 
         checkoutDirectory.mkdirs();
     }
 
     private File createCheckoutDirectory()
     {
         File checkoutDirectory;
 
         DecimalFormat fmt = new DecimalFormat( "#####" );
 
         Random rand = new Random( System.currentTimeMillis() + Runtime.getRuntime().freeMemory() );
 
         synchronized ( rand )
         {
             do
             {
                 checkoutDirectory = new File( System.getProperty( "java.io.tmpdir" ),
                                               "wagon-scm" + fmt.format( Math.abs( rand.nextInt() ) ) + ".checkout" );
             }
             while ( checkoutDirectory.exists() );
         }
 
         return checkoutDirectory;
     }
 
 
     private void removeCheckoutDirectory()
         throws ConnectionException
     {
         if ( checkoutDirectory == null )
         {
             return; // Silently return.
         }
 
         try
         {
             FileUtils.deleteDirectory( checkoutDirectory );
         }
         catch ( IOException e )
         {
             throw new ConnectionException( "Unable to cleanup checkout directory", e );
         }
     }
 
     /**
      * Construct the ScmVersion to use for operations.
      * <p/>
      * <p>If scmVersion is supplied, scmVersionType must also be supplied to
      * take effect.</p>
      */
     private ScmVersion makeScmVersion()
     {
         if ( StringUtils.isBlank( scmVersion ) )
         {
             return null;
         }
         if ( scmVersion.length() > 0 )
         {
             if ( "revision".equals( scmVersionType ) )
             {
                 return new ScmRevision( scmVersion );
             }
             else if ( "tag".equals( scmVersionType ) )
             {
                 return new ScmTag( scmVersion );
             }
             else if ( "branch".equals( scmVersionType ) )
             {
                 return new ScmBranch( scmVersion );
             }
         }
 
         return null;
     }
 
     private ScmRepository getScmRepository( String url )
         throws ScmRepositoryException, NoSuchScmProviderException
     {
         String username = null;
 
         String password = null;
 
         String privateKey = null;
 
         String passphrase = null;
 
         if ( authenticationInfo != null )
         {
             username = authenticationInfo.getUserName();
 
             password = authenticationInfo.getPassword();
 
             privateKey = authenticationInfo.getPrivateKey();
 
             passphrase = authenticationInfo.getPassphrase();
         }
 
         ScmRepository scmRepository = getScmManager().makeScmRepository( url );
 
         ScmProviderRepository providerRepository = scmRepository.getProviderRepository();
 
         if ( StringUtils.isNotEmpty( username ) )
         {
             providerRepository.setUser( username );
         }
 
         if ( StringUtils.isNotEmpty( password ) )
         {
             providerRepository.setPassword( password );
         }
 
         if ( providerRepository instanceof ScmProviderRepositoryWithHost )
         {
             ScmProviderRepositoryWithHost providerRepo = (ScmProviderRepositoryWithHost) providerRepository;
 
             if ( StringUtils.isNotEmpty( privateKey ) )
             {
                 providerRepo.setPrivateKey( privateKey );
             }
 
             if ( StringUtils.isNotEmpty( passphrase ) )
             {
                 providerRepo.setPassphrase( passphrase );
             }
         }
 
         return scmRepository;
     }
 
     public void put( File source, String targetName )
         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
     {
         if ( source.isDirectory() )
         {
             throw new IllegalArgumentException( "Source is a directory: " + source );
         }
         putInternal( source, targetName );
     }
 
     /**
      * Puts both files and directories
      *
      * @param source
      * @param targetName
      * @throws TransferFailedException
      */
     private void putInternal( File source, String targetName )
         throws TransferFailedException
     {
         Resource target = new Resource( targetName );
 
         firePutInitiated( target, source );
 
         try
         {
             ScmRepository scmRepository = getScmRepository( getRepository().getUrl() );
 
             target.setContentLength( source.length() );
             target.setLastModified( source.lastModified() );
 
             firePutStarted( target, source );
 
             String msg = "Wagon: Adding " + source.getName() + " to repository";
 
             ScmProvider scmProvider = getScmProvider( scmRepository.getProvider() );
 
             String checkoutTargetName = source.isDirectory() ? targetName : getDirname( targetName );
             String relPath = checkOut( scmProvider, scmRepository, checkoutTargetName, target );
 
             File newCheckoutDirectory = new File( checkoutDirectory, relPath );
 
             File scmFile = new File( newCheckoutDirectory, source.isDirectory() ? "" : getFilename( targetName ) );
 
             boolean fileAlreadyInScm = scmFile.exists();
 
             if ( !scmFile.equals( source ) )
             {
                 if ( source.isDirectory() )
                 {
                     FileUtils.copyDirectoryStructure( source, scmFile );
                 }
                 else
                 {
                     FileUtils.copyFile( source, scmFile );
                 }
             }
 
             if ( !fileAlreadyInScm || scmFile.isDirectory() )
             {
                 int addedFiles = addFiles( scmProvider, scmRepository, newCheckoutDirectory,
                                            source.isDirectory() ? "" : scmFile.getName() );
 
                 if ( !fileAlreadyInScm && addedFiles == 0 )
                 {
                     throw new ScmException(
                         "Unable to add file to SCM: " + scmFile + "; see error messages above for more information" );
                 }
             }
 
             ScmResult result =
                 scmProvider.checkIn( scmRepository, new ScmFileSet( checkoutDirectory ), makeScmVersion(), msg );
 
             checkScmResult( result );
         }
         catch ( ScmException e )
         {
             fireTransferError( target, e, TransferEvent.REQUEST_GET );
 
             throw new TransferFailedException( "Error interacting with SCM: " + e.getMessage(), e );
         }
         catch ( IOException e )
         {
             fireTransferError( target, e, TransferEvent.REQUEST_GET );
 
             throw new TransferFailedException( "Error interacting with SCM: " + e.getMessage(), e );
         }
 
         if ( source.isFile() )
         {
             postProcessListeners( target, source, TransferEvent.REQUEST_PUT );
         }
 
         firePutCompleted( target, source );
     }
 
     /**
      * Returns the relative path to targetName in the checkout dir. If the targetName already exists in the scm, this
      * will be the empty string.
      *
      * @param scmProvider
      * @param scmRepository
      * @param targetName
      * @return
      * @throws TransferFailedException
      */
     private String checkOut( ScmProvider scmProvider, ScmRepository scmRepository, String targetName,
                              Resource resource )
         throws TransferFailedException
     {
         checkoutDirectory = createCheckoutDirectory();
 
         Stack stack = new Stack();
 
         String target = targetName;
 
         // totally ignore scmRepository parent stuff since that is not supported by all scms.
         // Instead, assume that that url exists. If not, then that's an error.
         // Check whether targetName, which is a relative path into the scm, exists.
         // If it doesn't, check the parent, etc.
 
         try
         {
             while ( target.length() > 0 && !scmProvider.list( scmRepository,
                                                               new ScmFileSet( new File( "." ), new File( target ) ),
                                                               false, makeScmVersion() ).isSuccess() )
             {
                 stack.push( getFilename( target ) );
                 target = getDirname( target );
             }
         }
         catch ( ScmException e )
         {
             fireTransferError( resource, e, TransferEvent.REQUEST_PUT );
 
             throw new TransferFailedException( "Error listing repository: " + e.getMessage(), e );
         }
 
         // ok, we've established that target exists, or is empty.
         // Check the resource out; if it doesn't exist, that means we're in the svn repo url root,
         // and the configuration is incorrect. We will not try repo.getParent since most scm's don't
         // implement that.
 
         try
         {
             String repoUrl = getRepository().getUrl();
             if ( "svn".equals( scmProvider.getScmType() ) )
             {
                 // Subversion is the only SCM that adds path structure to represent tags and branches.
                 // The rest use scmVersion and scmVersionType.
                 repoUrl += "/" + target.replace( '\\', '/' );
             }
             scmRepository = getScmRepository( repoUrl );
             CheckOutScmResult ret =
                 scmProvider.checkOut( scmRepository, new ScmFileSet( new File( checkoutDirectory, "" ) ),
                                       makeScmVersion(), false );
 
             checkScmResult( ret );
         }
         catch ( ScmException e )
         {
             fireTransferError( resource, e, TransferEvent.REQUEST_PUT );
 
             throw new TransferFailedException( "Error checking out: " + e.getMessage(), e );
         }
 
         // now create the subdirs in target, if it's a parent of targetName
 
         String relPath = "";
 
         while ( !stack.isEmpty() )
         {
             String p = (String) stack.pop();
             relPath += p + "/";
 
             File newDir = new File( checkoutDirectory, relPath );
             if ( !newDir.mkdirs() )
             {
                 throw new TransferFailedException(
                     "Failed to create directory " + newDir.getAbsolutePath() + "; parent should exist: "
                         + checkoutDirectory );
             }
 
             try
             {
                 addFiles( scmProvider, scmRepository, checkoutDirectory, relPath );
             }
             catch ( ScmException e )
             {
                 fireTransferError( resource, e, TransferEvent.REQUEST_PUT );
 
                 throw new TransferFailedException( "Failed to add directory " + newDir + " to working copy", e );
             }
         }
 
         return relPath;
     }
 
     /**
      * Add a file or directory to a SCM repository. If it's a directory all its contents are added recursively.
      * <p/>
      * TODO this is less than optimal, SCM API should provide a way to add a directory recursively
      *
      * @param scmProvider   SCM provider
      * @param scmRepository SCM repository
      * @param basedir       local directory corresponding to scmRepository
      * @param scmFilePath   path of the file or directory to add, relative to basedir
      * @return the number of files added.
      * @throws ScmException
      */
     private int addFiles( ScmProvider scmProvider, ScmRepository scmRepository, File basedir, String scmFilePath )
         throws ScmException
     {
         int addedFiles = 0;
 
         File scmFile = new File( basedir, scmFilePath );
 
         if ( scmFilePath.length() != 0 )
         {
             AddScmResult result = scmProvider.add( scmRepository, new ScmFileSet( basedir, new File( scmFilePath ) ) );
 
             /*
              * TODO dirty fix to work around files with property svn:eol-style=native if a file has that property, first
              * time file is added it fails, second time it succeeds the solution is check if the scm provider is svn and
              * unset that property when the SCM API allows it
              */
             if ( !result.isSuccess() )
             {
                 result = scmProvider.add( scmRepository, new ScmFileSet( basedir, new File( scmFilePath ) ) );
             }
 
             addedFiles = result.getAddedFiles().size();
         }
 
         String reservedScmFile = scmProvider.getScmSpecificFilename();
 
         if ( scmFile.isDirectory() )
         {
             File[] files = scmFile.listFiles();
 
             for ( int i = 0; i < files.length; i++ )
             {
                 if ( reservedScmFile != null && !reservedScmFile.equals( files[i].getName() ) )
                 {
                     addedFiles += addFiles( scmProvider, scmRepository, basedir,
                                             ( scmFilePath.length() == 0 ? "" : scmFilePath + "/" )
                                                 + files[i].getName() );
                 }
             }
         }
 
         return addedFiles;
     }
 
     /**
      * @return true
      */
     public boolean supportsDirectoryCopy()
     {
         return true;
     }
 
     public void putDirectory( File sourceDirectory, String destinationDirectory )
         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
     {
         if ( !sourceDirectory.isDirectory() )
         {
             throw new IllegalArgumentException( "Source is not a directory: " + sourceDirectory );
         }
 
         putInternal( sourceDirectory, destinationDirectory );
     }
 
     /**
      * Check that the ScmResult was a successful operation
      *
      * @param result
      * @throws TransferFailedException if result was not a successful operation
      * @throws ScmException
      */
     private void checkScmResult( ScmResult result )
         throws ScmException
     {
         if ( !result.isSuccess() )
         {
             throw new ScmException(
                 "Unable to commit file. " + result.getProviderMessage() + " " + ( result.getCommandOutput() == null
                     ? ""
                     : result.getCommandOutput() ) );
         }
     }
 
     public void closeConnection()
         throws ConnectionException
     {
         removeCheckoutDirectory();
     }
 
     /**
      * Not implemented
      *
      * @throws UnsupportedOperationException always
      */
     public boolean getIfNewer( String resourceName, File destination, long timestamp )
         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
     {
         throw new UnsupportedOperationException( "Not currently supported: getIfNewer" );
     }
 
     public void get( String resourceName, File destination )
         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
     {
         Resource resource = new Resource( resourceName );
 
         fireGetInitiated( resource, destination );
 
         String url = getRepository().getUrl() + "/" + resourceName;
 
         // remove the file
         url = url.substring( 0, url.lastIndexOf( '/' ) );
 
         try
         {
             ScmRepository scmRepository = getScmRepository( url );
 
             fireGetStarted( resource, destination );
 
             // TODO: limitations:
             // - destination filename must match that in the repository - should allow the "-d" CVS equiv to be passed
             //   in
             // - we don't get granular exceptions from SCM (ie, auth, not found)
             // - need to make it non-recursive to save time
             // - exists() check doesn't test if it is in SCM already
 
             File scmFile = new File( checkoutDirectory, resourceName );
 
             File basedir = scmFile.getParentFile();
 
             ScmProvider scmProvider = getScmProvider( scmRepository.getProvider() );
 
             String reservedScmFile = scmProvider.getScmSpecificFilename();
 
             if ( reservedScmFile != null && new File( basedir, reservedScmFile ).exists() )
             {
                 scmProvider.update( scmRepository, new ScmFileSet( basedir ), makeScmVersion() );
             }
             else
             {
                 // TODO: this should be checking out a full hierarchy (requires the -d equiv)
                 basedir.mkdirs();
 
                 scmProvider.checkOut( scmRepository, new ScmFileSet( basedir ), makeScmVersion() );
             }
 
             if ( !scmFile.exists() )
             {
                 throw new ResourceDoesNotExistException( "Unable to find resource " + destination + " after checkout" );
             }
 
             if ( !scmFile.equals( destination ) )
             {
                 FileUtils.copyFile( scmFile, destination );
             }
         }
         catch ( ScmException e )
         {
             fireTransferError( resource, e, TransferEvent.REQUEST_GET );
 
             throw new TransferFailedException( "Error getting file from SCM", e );
         }
         catch ( IOException e )
         {
             fireTransferError( resource, e, TransferEvent.REQUEST_GET );
 
             throw new TransferFailedException( "Error getting file from SCM", e );
         }
 
         postProcessListeners( resource, destination, TransferEvent.REQUEST_GET );
 
         fireGetCompleted( resource, destination );
     }
 
     /**
      * @return a List&lt;String&gt; with filenames/directories at the resourcepath.
      * @see org.apache.maven.wagon.AbstractWagon#getFileList(java.lang.String)
      */
     public List<String> getFileList( String resourcePath )
         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
     {
         try
         {
             ScmRepository repository = getScmRepository( getRepository().getUrl() );
 
             ScmProvider provider = getScmProvider( repository.getProvider() );
 
             ListScmResult result =
                 provider.list( repository, new ScmFileSet( new File( "." ), new File( resourcePath ) ), false,
                                makeScmVersion() );
 
             if ( !result.isSuccess() )
             {
                 throw new ResourceDoesNotExistException( result.getProviderMessage() );
             }
 
             List<String> files = new ArrayList<String>();
 
             for ( Iterator<ScmFile> it = result.getFiles().iterator(); it.hasNext(); )
             {
                 ScmFile f = it.next();
                 files.add( f.getPath() );
             }
 
             return files;
         }
         catch ( ScmException e )
         {
             throw new TransferFailedException( "Error getting filelist from SCM", e );
         }
     }
 
     public boolean resourceExists( String resourceName )
         throws TransferFailedException, AuthorizationException
     {
         try
         {
             getFileList( resourceName );
 
             return true;
         }
         catch ( ResourceDoesNotExistException e )
         {
             return false;
         }
     }
 
     private String getFilename( String filename )
     {
         String fname = StringUtils.replace( filename, "/", File.separator );
         return FileUtils.filename( fname );
     }
 
     private String getDirname( String filename )
     {
         String fname = StringUtils.replace( filename, "/", File.separator );
         return FileUtils.dirname( fname );
     }
 }