package org.apache.maven.scm.provider.accurev;
   
   /*
    * 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.Date;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.maven.scm.ScmVersion;
  import org.apache.maven.scm.log.ScmLogger;
  import org.apache.maven.scm.provider.ScmProviderRepositoryWithHost;
  import org.apache.maven.scm.provider.accurev.util.WorkspaceUtils;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * 
   */
  public class AccuRevScmProviderRepository
      extends ScmProviderRepositoryWithHost
  {
      public static final String DEFAULT_TAG_FORMAT = "%s";
  
      private AccuRev accurev;
  
      private String streamName;
  
      private String projectPath;
  
      private String tagFormat = DEFAULT_TAG_FORMAT;
  
      private ScmLogger logger;
  
      public AccuRevScmProviderRepository()
      {
          super();
          // True is a more sensible default (ie for tck tests)
          // TODO raise jira so tck tests properly handle setPersist
          setPersistCheckout( true );
  
          setShouldUseExportForNonPersistentCheckout( true );
      }
  
      public String getTagFormat()
      {
          return tagFormat;
      }
  
      public void setTagFormat( String tagFormat )
      {
          if ( tagFormat == null || !tagFormat.contains( "%s" ) )
          {
              throw new IllegalArgumentException( "tagFormat must contain '%s' to be replaced" );
          }
          this.tagFormat = tagFormat;
      }
  
      public String getStreamName()
      {
          return streamName;
      }
  
      public void setStreamName( String streamName )
      {
          this.streamName = streamName;
      }
  
      public String getProjectPath()
      {
          return projectPath;
      }
  
      public void setProjectPath( String projectPath )
      {
          this.projectPath = projectPath;
          setCheckoutRelativePath( projectPath );
      }
  
      public AccuRev getAccuRev()
      {
         return this.accurev;
     }
 
     public void setAccuRev( AccuRev accurev )
     {
         this.accurev = accurev;
     }
 
     /**
      * @param info
      * @return true if info indicates a root of the workspace.
      */
     public boolean isWorkSpaceRoot( AccuRevInfo info )
     {
         String p = getProjectPath();
         return ( p != null && WorkspaceUtils.isSameFile( info.getBasedir(), new File( info.getTop(), p ) ) )
             || isWorkSpaceTop( info );
     }
 
     public boolean isWorkSpaceTop( AccuRevInfo info )
     {
         return info.isWorkSpaceTop();      
 
     }
 
     String tagToStream( String tagName )
     {
         return String.format( getTagFormat(), tagName );
     }
 
     String streamToTag( String streamName )
     {
         tagFormat = getTagFormat();
         // TODO - strictly we should quote either side of the %s
         String tagPatternString = tagToStream( "(.*)" );
         Pattern tagPattern = Pattern.compile( tagPatternString );
 
         Matcher tagMatcher = tagPattern.matcher( streamName );
         if ( tagMatcher.matches() )
         {
             return tagMatcher.group( 1 );
         }
         else
         {
             return streamName;
         }
 
     }
 
     public void setLogger( ScmLogger logger )
     {
         this.logger = logger;
     }
 
     // TODO raise JIRA to pull up these methods to ScmProviderRepository
 
     private String checkoutRelativePath;
 
     private boolean shouldUseExportForNonPersistentCheckout = true;
 
     /**
      * The relative path of the directory of the checked out project in comparison to the checkout directory, or an
      * empty String in case the checkout directory equals the project directory.
      * <p/>
      * With most SCMs, this is just an empty String, meaning that the checkout directory equals the project directory.
      * But there are cases (e.g. ClearCase) where within the checkout directory, the directory structure of the SCM
      * system is repeated. E.g. if you check out the project "my/project" to "/some/dir", the project sources are
      * actually checked out to "some/dir/my/project". In this example, relativePathProjectDirectory would contain
      * "my/project".
      */
     public String getCheckoutRelativePath()
     {
         if ( this.checkoutRelativePath == null )
         {
             return "";
         }
         return this.checkoutRelativePath;
     }
 
     public void setCheckoutRelativePath( String checkoutRelativePath )
     {
         this.checkoutRelativePath = checkoutRelativePath;
     }
 
     /**
      * Relative project path for export
      * 
      * @return default same as {@link #getCheckoutRelativePath()}
      */
     public String getExportRelativePath()
     {
         return getCheckoutRelativePath();
     }
 
     /**
      * When checkout is not expected to be refreshed or committed, should export be used instead? Perforce, Clearcase
      * and AccuRev store their meta-data about file status within the server rather than files in the source tree. This
      * makes checkouts within checkouts (eg release:perform) difficult. Typically there is a way to do a lightweight
      * export instead which can be implemented as the "export" command. This is a hint to downstream applications that
      * "export" is available and should be used in preference to "checkout" in cases where "update" and "commit" are not
      * intended to be used. (ie release:perform)
      * 
      * @return false by default
      */
     public boolean shouldUseExportForNonPersistentCheckout()
     {
         return this.shouldUseExportForNonPersistentCheckout;
     }
 
     public void setShouldUseExportForNonPersistentCheckout( boolean shouldUseExportForNonPersistentCheckout )
     {
         this.shouldUseExportForNonPersistentCheckout = shouldUseExportForNonPersistentCheckout;
     }
 
     public String getDepotRelativeProjectPath()
     {
         return "/./" + ( projectPath == null ? "" : projectPath );
     }
 
     public AccuRevVersion getAccuRevVersion( ScmVersion scmVersion )
     {
 
         String tran = null;
         String basisStream = null;
 
         if ( scmVersion == null )
         {
             basisStream = getStreamName();
         }
         else
         {
             String name = StringUtils.clean( scmVersion.getName() );
 
             String[] versionComponents = name.split( "[/\\\\]", 2 );
             basisStream = versionComponents[0];
             if ( basisStream.length() == 0 )
             {
                 // Use the default stream from the URL
                 basisStream = getStreamName();
             }
             else
             {
                 // name is a tag name - convert to a stream.
                 basisStream = tagToStream( basisStream );
             }
 
             if ( versionComponents.length == 2 && versionComponents[1].length() > 0 )
             {
                 tran = versionComponents[1];
             }
         }
 
         return new AccuRevVersion( basisStream, tran );
     }
 
     public String getSnapshotName( String tagName )
     {
         return tagToStream( tagName );
     }
 
     public String getRevision( String streamName, Date date )
     {
         return getRevision( streamName, AccuRev.ACCUREV_TIME_SPEC.format( date == null ? new Date() : date ) );
     }
 
     public String getRevision( String stream, long fromTranId )
     {
         return getRevision( stream, Long.toString( fromTranId ) );
     }
 
     public String getRevision( String streamName, String transaction )
     {
         return streamToTag( streamName ) + "/" + transaction;
     }
 
     public String getWorkSpaceRevision( String workspace )
         throws AccuRevException
     {
         return getRevision( workspace, Long.toString( getCurrentTransactionId( workspace ) ) );
     }
 
     public Transaction getDepotTransaction( String stream, String tranSpec )
         throws AccuRevException
     {
 
         if ( tranSpec == null )
         {
             tranSpec = "now";
         }
 
         List<Transaction> transactions = getAccuRev().history( stream, tranSpec, null, 1, true, true );
 
         if ( transactions == null || transactions.isEmpty() )
         {
             logger.warn( "Unable to find transaction for tranSpec=" + tranSpec );
             return null;
         }
         else
         {
             return transactions.get( 0 );
         }
 
     }
 
     public String getDepotTransactionId( String stream, String tranSpec )
         throws AccuRevException
     {
         Transaction t = getDepotTransaction( stream, tranSpec );
 
         return t == null ? tranSpec : Long.toString( t.getTranId() );
     }
 
     private long getCurrentTransactionId( String workSpaceName )
         throws AccuRevException
     {
         // AccuRev does not have a way to get at this workspace info by name.
         // So we have to do it the hard way...
 
         AccuRev accuRev = getAccuRev();
 
         Map<String, WorkSpace> workSpaces = accuRev.showWorkSpaces();
 
         WorkSpace workspace = workSpaces.get( workSpaceName );
 
         if ( workspace == null )
         {
             // Must be a reftree
             workSpaces = accuRev.showRefTrees();
             workspace = workSpaces.get( workSpaceName );
         }
 
         if ( workspace == null )
         {
             throw new AccuRevException( "Can't find workspace " + workSpaceName );
         }
         return workspace.getTransactionId();
     }
 
     public String toString()
     {
         StringBuilder buff = new StringBuilder( "AccuRevScmProviderRepository" );
         buff.append( " user=" );
         buff.append( getUser() );
         buff.append( " pass=" );
         buff.append( getPassword() == null ? "null" : StringUtils.repeat( "*", getPassword().length() ) );
         buff.append( " host=" );
         buff.append( getHost() );
         buff.append( " port=" );
         buff.append( getPort() );
         buff.append( " stream=" );
         buff.append( getStreamName() );
         buff.append( " projectPath=" );
         buff.append( getProjectPath() );
 
         return buff.toString();
     }
 
     public static String formatTimeSpec( Date when )
     {
 
         if ( when == null )
         {
             return "now";
         }
 
         return AccuRev.ACCUREV_TIME_SPEC.format( when );
 
     }
 
 }