package org.apache.maven.scm.provider.jazz;
   
   /*
    * 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.CommandParameters;
  import org.apache.maven.scm.ScmException;
  import org.apache.maven.scm.ScmFileSet;
  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.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.provider.AbstractScmProvider;
  import org.apache.maven.scm.provider.ScmProviderRepository;
  import org.apache.maven.scm.provider.jazz.command.JazzConstants;
  import org.apache.maven.scm.provider.jazz.command.add.JazzAddCommand;
  import org.apache.maven.scm.provider.jazz.command.blame.JazzBlameCommand;
  import org.apache.maven.scm.provider.jazz.command.branch.JazzBranchCommand;
  import org.apache.maven.scm.provider.jazz.command.changelog.JazzChangeLogCommand;
  import org.apache.maven.scm.provider.jazz.command.checkin.JazzCheckInCommand;
  import org.apache.maven.scm.provider.jazz.command.checkout.JazzCheckOutCommand;
  import org.apache.maven.scm.provider.jazz.command.diff.JazzDiffCommand;
  import org.apache.maven.scm.provider.jazz.command.edit.JazzEditCommand;
  import org.apache.maven.scm.provider.jazz.command.list.JazzListCommand;
  import org.apache.maven.scm.provider.jazz.command.status.JazzStatusCommand;
  import org.apache.maven.scm.provider.jazz.command.tag.JazzTagCommand;
  import org.apache.maven.scm.provider.jazz.command.unedit.JazzUnEditCommand;
  import org.apache.maven.scm.provider.jazz.command.update.JazzUpdateCommand;
  import org.apache.maven.scm.provider.jazz.repository.JazzScmProviderRepository;
  import org.apache.maven.scm.repository.ScmRepositoryException;
  
  import java.net.URI;
  
  /**
   * The maven scm provider for Jazz.
   * <p/>
   * This provider is a wrapper for the command line tool, "scm.sh" or "scm.exe" is that is
   * part of the Jazz SCM Server.
   * <p/>
   * This provider does not use a native API to communicate with the Jazz SCM server.
   * <p/>
   * The scm tool itself is documented at:
   * V2.0.0  - http://publib.boulder.ibm.com/infocenter/rtc/v2r0m0/topic/com.ibm.team.scm.doc/topics/r_scm_cli_scm.html
   * V3.0    - http://publib.boulder.ibm.com/infocenter/clmhelp/v3r0/topic/com.ibm.team.scm.doc/topics/r_scm_cli_scm.html
   * V3.0.1  -
   *  http://publib.boulder.ibm.com/infocenter/clmhelp/v3r0m1/topic/com.ibm.team.scm.doc/topics/r_scm_cli_scm.html
   *
   * @author <a href="mailto:ChrisGWarp@gmail.com">Chris Graham</a>
   * @plexus.component role="org.apache.maven.scm.provider.ScmProvider" role-hint="jazz"
   */
  public class JazzScmProvider
      extends AbstractScmProvider
  {
      // Example: scm:jazz:daviddl;passw0rd123@https://localhost:9443/jazz:Dave's Repository Workspace
      // If the username or password is supplied, then the @ must be used to delimit them.
      public static final String JAZZ_URL_FORMAT =
          "scm:jazz:[username[;password]@]http[s]://server_name[:port]/contextRoot:repositoryWorkspace";
  
      // ----------------------------------------------------------------------
      // ScmProvider Implementation
      // ----------------------------------------------------------------------
  
      public String getScmType()
      {
          return JazzConstants.SCM_TYPE;
      }
  
      /**
       * This method parses the scm URL and returns a SCM provider repository.
       * At this point, the scmUrl is the part after scm:provider_name: in your SCM URL.
       * <p/>
       * The basic url parsing approach is to be as loose as possible.
       * If you specify as per the docs you'll get what you expect.
      * If you do something else the result is undefined.
      * Don't use "/" "\" or "@" as the delimiter.
      * <p/>
      * Parse the scmUrl, which will be of the form:
      * [username[;password]@]http[s]://server_name[:port]/contextRoot:repositoryWorkspace
      * eg:
      * Deb;Deb@https://rtc:9444/jazz:BogusRepositoryWorkspace
      * {@inheritDoc}
      */
     public ScmProviderRepository makeProviderScmRepository( String scmUrl, char delimiter )
         throws ScmRepositoryException
     {
         // Called from:
         // AbstractScmProvider.makeScmRepository()
         // AbstractScmProvider.validateScmUrl()
         getLogger().debug( "JazzScmProvider:makeProviderScmRepository" );
         getLogger().debug( "Provided scm url   - " + scmUrl );
         getLogger().debug( "Provided delimiter - '" + delimiter + "'" );
 
         String jazzUrlAndWorkspace = null;
         String usernameAndPassword = null;
 
         // Look for the Jazz URL after any '@' delimiter used to pass
         // username/password etc (which may not have been specified)
         int lastAtPosition = scmUrl.lastIndexOf( '@' );
         if ( lastAtPosition == -1 )
         {
             // The username;password@ was not supplied.
             jazzUrlAndWorkspace = scmUrl;
         }
         else
         {
             // The username@ or username;password@ was supplied.
             jazzUrlAndWorkspace = ( lastAtPosition < 0 ) ? scmUrl : scmUrl.substring( lastAtPosition + 1 );
             usernameAndPassword = ( lastAtPosition < 0 ) ? null : scmUrl.substring( 0, lastAtPosition );
         }
 
         // jazzUrlAndWorkspace should be: http[s]://server_name:port/contextRoot:repositoryWorkspace
         // usernameAndPassword should be: username;password or null
 
         // username and password may not be supplied, and so may remain null.
         String username = null;
         String password = null;
 
         if ( usernameAndPassword != null )
         {
             // Can be:
             // username
             // username;password
             int delimPosition = usernameAndPassword.indexOf( ';' );
             username = delimPosition >= 0 ? usernameAndPassword.substring( 0, delimPosition ) : usernameAndPassword;
             password = delimPosition >= 0 ? usernameAndPassword.substring( delimPosition + 1 ) : null;
         }
 
         // We will now validate the jazzUrlAndWorkspace for right number of colons.
         // This has been observed in the wild, where the contextRoot:repositoryWorkspace was not properly formed
         // and this resulted in very strange results in the way in which things were parsed.
         int colonsCounted = 0;
         int colonIndex = 0;
         while ( colonIndex != -1 )
         {
             colonIndex = jazzUrlAndWorkspace.indexOf( ":", colonIndex + 1 );
             if ( colonIndex != -1 )
             {
                 colonsCounted++;
             }
         }
         // havePort may also be true when port is supplied, but otherwise have a malformed URL.
         boolean havePort = colonsCounted == 3;
 
         // Look for workspace after the end of the Jazz URL
         int repositoryWorkspacePosition = jazzUrlAndWorkspace.lastIndexOf( delimiter );
         String repositoryWorkspace = jazzUrlAndWorkspace.substring( repositoryWorkspacePosition + 1 );
         String jazzUrl = jazzUrlAndWorkspace.substring( 0, repositoryWorkspacePosition );
 
         // Validate the protocols.
         try
         {
             // Determine if it is a valid URI.
             URI jazzUri = URI.create( jazzUrl );
             String scheme = jazzUri.getScheme();
             getLogger().debug( "Scheme - " + scheme );
             if ( scheme == null || !( scheme.equalsIgnoreCase( "http" ) || scheme.equalsIgnoreCase( "https" ) ) )
             {
                 throw new ScmRepositoryException(
                     "Jazz Url \"" + jazzUrl + "\" is not a valid URL. The Jazz Url syntax is " + JAZZ_URL_FORMAT );
             }
         }
         catch ( IllegalArgumentException e )
         {
             throw new ScmRepositoryException(
                 "Jazz Url \"" + jazzUrl + "\" is not a valid URL. The Jazz Url syntax is " + JAZZ_URL_FORMAT );
         }
 
         // At this point, jazzUrl is guaranteed to start with either http:// or https://
         // Further process the jazzUrl to extract the server name and port.
         String hostname = null;
         int port = 0;
 
         if ( havePort )
         {
             // jazzUrlAndWorkspace should be: http[s]://server_name:port/contextRoot:repositoryWorkspace
             // jazzUrl should be            : http[s]://server_name:port/contextRoot
             int protocolIndex = jazzUrl.indexOf( ":" ) + 3;     // The +3 accounts for the "://"
             int portIndex = jazzUrl.indexOf( ":", protocolIndex + 1 );
             hostname = jazzUrl.substring( protocolIndex, portIndex );
             int pathIndex = jazzUrl.indexOf( "/", portIndex + 1 );
             String portNo = jazzUrl.substring( portIndex + 1, pathIndex );
             try
             {
                 port = Integer.parseInt( portNo );
             }
             catch ( NumberFormatException nfe )
             {
                 throw new ScmRepositoryException(
                     "Jazz Url \"" + jazzUrl + "\" is not a valid URL. The Jazz Url syntax is " + JAZZ_URL_FORMAT );
             }
         }
         else
         {
             // jazzUrlAndWorkspace should be: http[s]://server_name/contextRoot:repositoryWorkspace
             // jazzUrl should be            : http[s]://server_name/contextRoot
             // So we will set port to zero.
             int protocolIndex = jazzUrl.indexOf( ":" ) + 3;     // The +3 accounts for the "://"
             int pathIndex = jazzUrl.indexOf( "/", protocolIndex + 1 );
             if ( ( protocolIndex != -1 ) && ( pathIndex != -1 ) )
             {
                 hostname = jazzUrl.substring( protocolIndex, pathIndex );
             }
             else
             {
                 throw new ScmRepositoryException(
                     "Jazz Url \"" + jazzUrl + "\" is not a valid URL. The Jazz Url syntax is " + JAZZ_URL_FORMAT );
             }
         }
 
         getLogger().debug( "Creating JazzScmProviderRepository with the following values:" );
         getLogger().debug( "jazzUrl             - " + jazzUrl );
         getLogger().debug( "username            - " + username );
         getLogger().debug( "password            - " + password );
         getLogger().debug( "hostname            - " + hostname );
         getLogger().debug( "port                - " + port );
         getLogger().debug( "repositoryWorkspace - " + repositoryWorkspace );
 
         return new JazzScmProviderRepository( jazzUrl, username, password, hostname, port, repositoryWorkspace );
     }
 
     /**
      * {@inheritDoc}
      */
     public AddScmResult add( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         JazzAddCommand command = new JazzAddCommand();
         command.setLogger( getLogger() );
         return (AddScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected BranchScmResult branch( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
         throws ScmException
     {
         JazzBranchCommand command = new JazzBranchCommand();
         command.setLogger( getLogger() );
         return (BranchScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected BlameScmResult blame( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         JazzBlameCommand command = new JazzBlameCommand();
         command.setLogger( getLogger() );
         return (BlameScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected ChangeLogScmResult changelog( ScmProviderRepository repository, ScmFileSet fileSet,
                                             CommandParameters parameters )
         throws ScmException
     {
         // We need to call the status command first, so that we can get the details of the workspace.
         // This is needed for the list changesets command.
         // We could also 'trust' the value in the pom.
         JazzStatusCommand statusCommand = new JazzStatusCommand();
         statusCommand.setLogger( getLogger() );
         statusCommand.execute( repository, fileSet, parameters );
 
         JazzChangeLogCommand command = new JazzChangeLogCommand();
         command.setLogger( getLogger() );
         return (ChangeLogScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected CheckInScmResult checkin( ScmProviderRepository repository, ScmFileSet fileSet,
                                         CommandParameters parameters )
         throws ScmException
     {
         JazzCheckInCommand command = new JazzCheckInCommand();
         command.setLogger( getLogger() );
         return (CheckInScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected CheckOutScmResult checkout( ScmProviderRepository repository, ScmFileSet fileSet,
                                           CommandParameters parameters )
         throws ScmException
     {
         JazzCheckOutCommand command = new JazzCheckOutCommand();
         command.setLogger( getLogger() );
         return (CheckOutScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected DiffScmResult diff( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         JazzDiffCommand command = new JazzDiffCommand();
         command.setLogger( getLogger() );
         return (DiffScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected EditScmResult edit( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         JazzEditCommand command = new JazzEditCommand();
         command.setLogger( getLogger() );
         return (EditScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected ExportScmResult export( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
         throws ScmException
     {
         // Use checkout instead
         return super.export( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected ListScmResult list( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         // We need to call the status command first, so that we can get the details of the stream etc.
         // This is needed for workspace deliveries and snapshot promotions.
         JazzStatusCommand statusCommand = new JazzStatusCommand();
         statusCommand.setLogger( getLogger() );
         statusCommand.execute( repository, fileSet, parameters );
 
         JazzListCommand command = new JazzListCommand();
         command.setLogger( getLogger() );
         return (ListScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected StatusScmResult status( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
         throws ScmException
     {
         JazzStatusCommand command = new JazzStatusCommand();
         command.setLogger( getLogger() );
         return (StatusScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected TagScmResult tag( ScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters )
         throws ScmException
     {
         // We need to call the status command first, so that we can get the details of the stream etc.
         // This is needed for workspace deliveries and snapshot promotions.
         JazzStatusCommand statusCommand = new JazzStatusCommand();
         statusCommand.setLogger( getLogger() );
         statusCommand.execute( repository, fileSet, parameters );
 
         JazzTagCommand command = new JazzTagCommand();
         command.setLogger( getLogger() );
         return (TagScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected UpdateScmResult update( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
         throws ScmException
     {
         JazzUpdateCommand command = new JazzUpdateCommand();
         command.setLogger( getLogger() );
         return (UpdateScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     protected UnEditScmResult unedit( ScmProviderRepository repository, ScmFileSet fileSet,
                                       CommandParameters parameters )
         throws ScmException
     {
         JazzUnEditCommand command = new JazzUnEditCommand();
         command.setLogger( getLogger() );
         return (UnEditScmResult) command.execute( repository, fileSet, parameters );
     }
 
     /**
      * {@inheritDoc}
      */
     public String getScmSpecificFilename()
     {
         return JazzConstants.SCM_META_DATA_FOLDER;
     }
 
 }