package org.apache.maven.scm.manager;

 /*

  * 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.util.ArrayList;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import org.apache.maven.scm.ScmBranch;

 import org.apache.maven.scm.ScmBranchParameters;

 import org.apache.maven.scm.ScmException;

 import org.apache.maven.scm.ScmFileSet;

 import org.apache.maven.scm.ScmTagParameters;

 import org.apache.maven.scm.ScmVersion;

 import org.apache.maven.scm.command.add.AddScmResult;

 import org.apache.maven.scm.command.blame.BlameScmResult;

 import org.apache.maven.scm.command.branch.BranchScmResult;

 import org.apache.maven.scm.command.changelog.ChangeLogScmResult;

 import org.apache.maven.scm.command.checkin.CheckInScmResult;

 import org.apache.maven.scm.command.checkout.CheckOutScmResult;

 import org.apache.maven.scm.command.diff.DiffScmResult;

 import org.apache.maven.scm.command.edit.EditScmResult;

 import org.apache.maven.scm.command.export.ExportScmResult;

 import org.apache.maven.scm.command.list.ListScmResult;

 import org.apache.maven.scm.command.mkdir.MkdirScmResult;

 import org.apache.maven.scm.command.remove.RemoveScmResult;

 import org.apache.maven.scm.command.status.StatusScmResult;

 import org.apache.maven.scm.command.tag.TagScmResult;

 import org.apache.maven.scm.command.unedit.UnEditScmResult;

 import org.apache.maven.scm.command.update.UpdateScmResult;

 import org.apache.maven.scm.log.ScmLogger;

 import org.apache.maven.scm.provider.ScmProvider;

 import org.apache.maven.scm.provider.ScmProviderRepository;

 import org.apache.maven.scm.provider.ScmUrlUtils;

 import org.apache.maven.scm.repository.ScmRepository;

 import org.apache.maven.scm.repository.ScmRepositoryException;

 import org.apache.maven.scm.repository.UnknownRepositoryStructure;

 /**

  * @author <a href="mailto:trygvis@inamo.no">Trygve Laugst&oslash;l</a>

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>

  * @version $Id: AbstractScmManager.java 1294387 2012-02-27 23:12:45Z hboutemy $

  */

 public abstract class AbstractScmManager

     implements ScmManager

 {

     private Map<String, ScmProvider> scmProviders = new HashMap<String, ScmProvider>();

     private ScmLogger logger;

     private Map<String, String> userProviderTypes = new HashMap<String, String>();

     protected void setScmProviders( Map<String, ScmProvider> providers )

     {

         this.scmProviders = providers;

     }

     /**

      * @deprecated use {@link #setScmProvider(String,ScmProvider)} instead

      */

     protected void addScmProvider( String providerType, ScmProvider provider )

     {

         setScmProvider( providerType, provider );

     }

     /**

      * Set a provider to be used for a type of SCM.

      * If there was already a designed provider for that type it will be replaced.

      *

      * @param providerType the type of SCM, eg. <code>svn</code>, <code>cvs</code>

      * @param provider     the provider that will be used for that SCM type

      */

     public void setScmProvider( String providerType, ScmProvider provider )

     {

         scmProviders.put( providerType, provider );

     }

     protected abstract ScmLogger getScmLogger();

     // ----------------------------------------------------------------------

     // ScmManager Implementation

     // ----------------------------------------------------------------------

     /** {@inheritDoc} */

     public ScmProvider getProviderByUrl( String scmUrl )

         throws ScmRepositoryException, NoSuchScmProviderException

     {

         if ( scmUrl == null )

         {

             throw new NullPointerException( "The scm url cannot be null." );

         }

         String providerType = ScmUrlUtils.getProvider( scmUrl );

         return getProviderByType( providerType );

     }

     /** {@inheritDoc} */

     public void setScmProviderImplementation( String providerType, String providerImplementation )

     {

         userProviderTypes.put( providerType, providerImplementation );

     }

     /** {@inheritDoc} */

     public ScmProvider getProviderByType( String providerType )

         throws NoSuchScmProviderException

     {

         if ( logger == null )

         {

             logger = getScmLogger();

             for ( Entry<String, ScmProvider> entry : scmProviders.entrySet() )

             {

                 ScmProvider p = entry.getValue();

                 p.addListener( logger );

             }

         }

         String usedProviderType = System.getProperty( "maven.scm.provider." + providerType + ".implementation" );

         if ( usedProviderType == null )

         {

             if ( userProviderTypes.containsKey( providerType ) )

             {

                 usedProviderType = userProviderTypes.get( providerType );

             }

             else

             {

                 usedProviderType = providerType;

             }

         }

         ScmProvider scmProvider = scmProviders.get( usedProviderType );

         if ( scmProvider == null )

         {

             throw new NoSuchScmProviderException( usedProviderType );

         }

         return scmProvider;

     }

     /** {@inheritDoc} */

     public ScmProvider getProviderByRepository( ScmRepository repository )

         throws NoSuchScmProviderException

     {

         return getProviderByType( repository.getProvider() );

     }

     // ----------------------------------------------------------------------

     // Repository

     // ----------------------------------------------------------------------

     /** {@inheritDoc} */

     public ScmRepository makeScmRepository( String scmUrl )

         throws ScmRepositoryException, NoSuchScmProviderException

     {

         if ( scmUrl == null )

         {

             throw new NullPointerException( "The scm url cannot be null." );

         }

         char delimiter = ScmUrlUtils.getDelimiter( scmUrl ).charAt( 0 );

         String providerType = ScmUrlUtils.getProvider( scmUrl );

         ScmProvider provider = getProviderByType( providerType );

         String scmSpecificUrl = cleanScmUrl( scmUrl.substring( providerType.length() + 5 ) );

         ScmProviderRepository providerRepository = provider.makeProviderScmRepository( scmSpecificUrl, delimiter );

         return new ScmRepository( providerType, providerRepository );

     }

     /**

      * Clean the SCM url by removing all ../ in path

      *

      * @param scmUrl the SCM url

      * @return the cleaned SCM url

      */

     protected String cleanScmUrl( String scmUrl )

     {

         if ( scmUrl == null )

         {

             throw new NullPointerException( "The scm url cannot be null." );

         }

         String pathSeparator = "";

         int indexOfDoubleDot = -1;

         // Clean Unix path

         if ( scmUrl.indexOf( "../" ) > 1 )

         {

             pathSeparator = "/";

             indexOfDoubleDot = scmUrl.indexOf( "../" );

         }

         // Clean windows path

         if ( scmUrl.indexOf( "..\\" ) > 1 )

         {

             pathSeparator = "\\";

             indexOfDoubleDot = scmUrl.indexOf( "..\\" );

         }

         if ( indexOfDoubleDot > 1 )

         {

             int startOfTextToRemove = scmUrl.substring( 0, indexOfDoubleDot - 1 ).lastIndexOf( pathSeparator );

             String beginUrl = "";

             if ( startOfTextToRemove >= 0 )

             {

                 beginUrl = scmUrl.substring( 0, startOfTextToRemove );

             }

             String endUrl = scmUrl.substring( indexOfDoubleDot + 3 );

             scmUrl = beginUrl + pathSeparator + endUrl;

             // Check if we have other double dot

             if ( scmUrl.indexOf( "../" ) > 1 || scmUrl.indexOf( "..\\" ) > 1 )

             {

                 scmUrl = cleanScmUrl( scmUrl );

             }

         }

         return scmUrl;

     }

     /** {@inheritDoc} */

     public ScmRepository makeProviderScmRepository( String providerType, File path )

         throws ScmRepositoryException, UnknownRepositoryStructure, NoSuchScmProviderException

     {

         if ( providerType == null )

         {

             throw new NullPointerException( "The provider type cannot be null." );

         }

         ScmProvider provider = getProviderByType( providerType );

         ScmProviderRepository providerRepository = provider.makeProviderScmRepository( path );

         return new ScmRepository( providerType, providerRepository );

     }

     /** {@inheritDoc} */

     public List<String> validateScmRepository( String scmUrl )

     {

         List<String> messages = new ArrayList<String>();

         messages.addAll( ScmUrlUtils.validate( scmUrl ) );

         String providerType = ScmUrlUtils.getProvider( scmUrl );

         ScmProvider provider;

         try

         {

             provider = getProviderByType( providerType );

         }

         catch ( NoSuchScmProviderException e )

         {

             messages.add( "No such provider installed '" + providerType + "'." );

             return messages;

         }

         String scmSpecificUrl = cleanScmUrl( scmUrl.substring( providerType.length() + 5 ) );

         List<String> providerMessages =

             provider.validateScmUrl( scmSpecificUrl, ScmUrlUtils.getDelimiter( scmUrl ).charAt( 0 ) );

         if ( providerMessages == null )

         {

             throw new RuntimeException( "The SCM provider cannot return null from validateScmUrl()." );

         }

         messages.addAll( providerMessages );

         return messages;

     }

     /** {@inheritDoc} */

     public AddScmResult add( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).add( repository, fileSet );

     }

     /** {@inheritDoc} */

     public AddScmResult add( ScmRepository repository, ScmFileSet fileSet, String message )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).add( repository, fileSet, message );

     }

     /** {@inheritDoc} */

     public BranchScmResult branch( ScmRepository repository, ScmFileSet fileSet, String branchName )

         throws ScmException

     {

         ScmBranchParameters scmBranchParameters = new ScmBranchParameters( "" );

         return this.getProviderByRepository( repository ).branch( repository, fileSet, branchName, scmBranchParameters );

     }

     /** {@inheritDoc} */

     public BranchScmResult branch( ScmRepository repository, ScmFileSet fileSet, String branchName, String message )

         throws ScmException

     {

         ScmBranchParameters scmBranchParameters = new ScmBranchParameters( message );

         return this.getProviderByRepository( repository ).branch( repository, fileSet, branchName, scmBranchParameters );

     }

     /** {@inheritDoc} */

     public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,

                                          int numDays, ScmBranch branch )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).changeLog( repository, fileSet, startDate, endDate, numDays,

                                                                      branch );

     }

     /** {@inheritDoc} */

     public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, Date startDate, Date endDate,

                                          int numDays, ScmBranch branch, String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).changeLog( repository, fileSet, startDate, endDate, numDays,

                                                                      branch, datePattern );

     }

     /** {@inheritDoc} */

     public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion,

                                          ScmVersion endVersion )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).changeLog( repository, fileSet, startVersion, endVersion );

     }

     /** {@inheritDoc} */

     public ChangeLogScmResult changeLog( ScmRepository repository, ScmFileSet fileSet, ScmVersion startRevision,

                                          ScmVersion endRevision, String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).changeLog( repository, fileSet, startRevision, endRevision,

                                                                      datePattern );

     }

     /** {@inheritDoc} */

     public CheckInScmResult checkIn( ScmRepository repository, ScmFileSet fileSet, String message )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkIn( repository, fileSet, message );

     }

     /** {@inheritDoc} */

     public CheckInScmResult checkIn( ScmRepository repository, ScmFileSet fileSet, ScmVersion revision, String message )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkIn( repository, fileSet, revision, message );

     }

     /** {@inheritDoc} */

     public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkOut( repository, fileSet );

     }

     /** {@inheritDoc} */

     public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, ScmVersion version )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkOut( repository, fileSet, version );

     }

     /** {@inheritDoc} */

     public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, boolean recursive )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkOut( repository, fileSet, recursive );

     }

     /** {@inheritDoc} */

     public CheckOutScmResult checkOut( ScmRepository repository, ScmFileSet fileSet, ScmVersion version,

                                        boolean recursive )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).checkOut( repository, fileSet, version, recursive );

     }

     /** {@inheritDoc} */

     public DiffScmResult diff( ScmRepository repository, ScmFileSet fileSet, ScmVersion startVersion,

                                ScmVersion endVersion )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).diff( repository, fileSet, startVersion, endVersion );

     }

     /** {@inheritDoc} */

     public EditScmResult edit( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).edit( repository, fileSet );

     }

     /** {@inheritDoc} */

     public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).export( repository, fileSet );

     }

     /** {@inheritDoc} */

     public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, ScmVersion version )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).export( repository, fileSet, version );

     }

     /** {@inheritDoc} */

     public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, String outputDirectory )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).export( repository, fileSet, (ScmVersion) null,

                                                                   outputDirectory );

     }

     /** {@inheritDoc} */

     public ExportScmResult export( ScmRepository repository, ScmFileSet fileSet, ScmVersion version,

                                    String outputDirectory )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).export( repository, fileSet, version, outputDirectory );

     }

     /** {@inheritDoc} */

     public ListScmResult list( ScmRepository repository, ScmFileSet fileSet, boolean recursive, ScmVersion version )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).list( repository, fileSet, recursive, version );

     }

     /** {@inheritDoc} */

     public MkdirScmResult mkdir( ScmRepository repository, ScmFileSet fileSet, String message, boolean createInLocal )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).mkdir( repository, fileSet, message, createInLocal );

     }

     /** {@inheritDoc} */

     public RemoveScmResult remove( ScmRepository repository, ScmFileSet fileSet, String message )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).remove( repository, fileSet, message );

     }

     /** {@inheritDoc} */

     public StatusScmResult status( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).status( repository, fileSet );

     }

     /** {@inheritDoc} */

     public TagScmResult tag( ScmRepository repository, ScmFileSet fileSet, String tagName )

         throws ScmException

     {

         return this.tag( repository, fileSet, tagName, "" );

     }

     /** {@inheritDoc} */

     public TagScmResult tag( ScmRepository repository, ScmFileSet fileSet, String tagName, String message )

         throws ScmException

     {

         ScmTagParameters scmTagParameters = new ScmTagParameters( message );

         return this.getProviderByRepository( repository ).tag( repository, fileSet, tagName, scmTagParameters );

     }

     /** {@inheritDoc} */

     public UnEditScmResult unedit( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).unedit( repository, fileSet );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion version )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, version );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, boolean runChangelog )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, runChangelog );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion version,

                                    boolean runChangelog )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, version, runChangelog );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, (ScmVersion) null, datePattern );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion version,

                                    String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, version, datePattern );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, Date lastUpdate )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, (ScmVersion) null, lastUpdate );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion version, Date lastUpdate )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, version, lastUpdate );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, Date lastUpdate, String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, (ScmVersion) null, lastUpdate,

                                                                   datePattern );

     }

     /** {@inheritDoc} */

     public UpdateScmResult update( ScmRepository repository, ScmFileSet fileSet, ScmVersion version, Date lastUpdate,

                                    String datePattern )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).update( repository, fileSet, version, lastUpdate,

                                                                   datePattern );

     }

      /** {@inheritDoc} */

     public BlameScmResult blame( ScmRepository repository, ScmFileSet fileSet, String filename )

         throws ScmException

     {

         return this.getProviderByRepository( repository ).blame( repository, fileSet, filename );

     }

 }