package org.apache.maven.scm.provider.cvslib.cvsjava.util;
   
   /*
    * 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.log.ScmLogger;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.netbeans.lib.cvsclient.CVSRoot;
  import org.netbeans.lib.cvsclient.Client;
  import org.netbeans.lib.cvsclient.admin.StandardAdminHandler;
  import org.netbeans.lib.cvsclient.command.Command;
  import org.netbeans.lib.cvsclient.command.CommandAbortedException;
  import org.netbeans.lib.cvsclient.command.CommandException;
  import org.netbeans.lib.cvsclient.command.GlobalOptions;
  import org.netbeans.lib.cvsclient.commandLine.CommandFactory;
  import org.netbeans.lib.cvsclient.commandLine.GetOpt;
  import org.netbeans.lib.cvsclient.connection.AbstractConnection;
  import org.netbeans.lib.cvsclient.connection.AuthenticationException;
  import org.netbeans.lib.cvsclient.connection.Connection;
  import org.netbeans.lib.cvsclient.connection.ConnectionFactory;
  import org.netbeans.lib.cvsclient.connection.PServerConnection;
  import org.netbeans.lib.cvsclient.connection.StandardScrambler;
  import org.netbeans.lib.cvsclient.event.CVSListener;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  
  /**
   * A Cvs connection that simulates a command line interface.
   *
   * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
   *
   */
  public class CvsConnection
  {
  
      /**
       * The path to the repository on the server
       */
      @SuppressWarnings( "unused" )
      private String repository;
  
      /**
       * The local path to use to perform operations (the top level)
       */
      private String localPath;
  
      /**
       * The connection to the server
       */
      private Connection connection;
  
      /**
       * The client that manages interactions with the server
       */
      private Client client;
  
      /**
       * The global options being used. GlobalOptions are only global for a
       * particular command.
       */
      private GlobalOptions globalOptions;
  
      private CvsConnection()
      {
      }
  
      /**
       * Execute a configured CVS command
       *
       * @param command the command to execute
       * @throws CommandException if there is an error running the command
       */
      public boolean executeCommand( Command command )
          throws CommandException, AuthenticationException
      {
          return client.executeCommand( command, globalOptions );
      }
  
      public void setRepository( String repository )
     {
         this.repository = repository;
     }
 
     public void setLocalPath( String localPath )
     {
         this.localPath = localPath;
     }
 
     public void setGlobalOptions( GlobalOptions globalOptions )
     {
         this.globalOptions = globalOptions;
     }
 
     /**
      * Creates the connection and the client and connects.
      */
     private void connect( CVSRoot root, String password )
         throws AuthenticationException, CommandAbortedException
     {
         if ( CVSRoot.METHOD_EXT.equals( root.getMethod() ) )
         {
             String cvsRsh = System.getProperty( "maven.scm.cvs.java.cvs_rsh" );
             if ( cvsRsh == null )
             {
                 try
                 {
                     cvsRsh = CommandLineUtils.getSystemEnvVars().getProperty( "CVS_RSH" );
                 }
                 catch ( IOException e )
                 {
                     // we assume searching env var can't fail
                 }
             }
 
             if ( cvsRsh != null )
             {
                 if ( cvsRsh.indexOf( ' ' ) < 0 )
                 {
                     //cvs_rsh should be 'rsh' or 'ssh'
                     //Complete the command to use
                     String username = root.getUserName();
                     if ( username == null )
                     {
                         username = System.getProperty( "user.name" );
                     }
 
                     cvsRsh += " " + username + "@" + root.getHostName() + " cvs server";
                 }
 
                 AbstractConnection conn = new org.netbeans.lib.cvsclient.connection.ExtConnection( cvsRsh );
                 conn.setRepository( root.getRepository() );
                 connection = conn;
             }
             else
             {
                 connection = new ExtConnection( root );
             }
         }
         else
         {
             connection = ConnectionFactory.getConnection( root );
             if ( CVSRoot.METHOD_PSERVER.equals( root.getMethod() ) )
             {
                 ( (PServerConnection) connection ).setEncodedPassword( password );
             }
         }
         connection.open();
 
         client = new Client( connection, new StandardAdminHandler() );
         client.setLocalPath( localPath );
     }
 
     private void disconnect()
     {
         if ( connection != null && connection.isOpen() )
         {
             try
             {
                 connection.close();
             }
             catch ( IOException e )
             {
                 //ignore
             }
         }
     }
 
     private void addListener( CVSListener listener )
     {
         if ( client != null )
         {
             // add a listener to the client
             client.getEventManager().addCVSListener( listener );
         }
     }
 
     /**
      * Obtain the CVS root, either from the -D option cvs.root or from the CVS
      * directory
      *
      * @return the CVSRoot string
      */
     private static String getCVSRoot( String workingDir )
     {
         String root = null;
         BufferedReader r = null;
         if ( workingDir == null )
         {
             workingDir = System.getProperty( "user.dir" );
         }
         try
         {
             File f = new File( workingDir );
             File rootFile = new File( f, "CVS/Root" );
             if ( rootFile.exists() )
             {
                 r = new BufferedReader( new FileReader( rootFile ) );
                 root = r.readLine();
             }
         }
         catch ( IOException e )
         {
             // ignore
         }
         finally
         {
             try
             {
                 if ( r != null )
                 {
                     r.close();
                 }
             }
             catch ( IOException e )
             {
                 System.err.println( "Warning: could not close CVS/Root file!" );
             }
         }
         if ( root == null )
         {
             root = System.getProperty( "cvs.root" );
         }
         return root;
     }
 
     /**
      * Process global options passed into the application
      *
      * @param args          the argument list, complete
      * @param globalOptions the global options structure that will be passed to
      *                      the command
      */
     private static int processGlobalOptions( String[] args, GlobalOptions globalOptions )
     {
         final String getOptString = globalOptions.getOptString();
         GetOpt go = new GetOpt( args, getOptString );
         int ch;
         while ( ( ch = go.getopt() ) != GetOpt.optEOF )
         {
             //System.out.println("Global option '"+((char) ch)+"',
             // '"+go.optArgGet()+"'");
             String arg = go.optArgGet();
             boolean success = globalOptions.setCVSCommand( (char) ch, arg );
             if ( !success )
             {
                 throw new IllegalArgumentException( "Failed to set CVS Command: -" + ch + " = " + arg );
             }
         }
 
         return go.optIndexGet();
     }
 
     /**
      * Lookup the password in the .cvspass file. This file is looked for in the
      * user.home directory if the option cvs.passfile is not set
      *
      * @param cvsRoot the CVS root for which the password is being searched
      * @return the password, scrambled
      */
     private static String lookupPassword( String cvsRoot, ScmLogger logger )
     {
         File passFile = new File( System.getProperty( "cygwin.user.home", System.getProperty( "user.home" ) ) + File
             .separatorChar + ".cvspass" );
 
         BufferedReader reader = null;
         String password = null;
 
         try
         {
             reader = new BufferedReader( new FileReader( passFile ) );
             password = processCvspass( cvsRoot, reader );
         }
         catch ( IOException e )
         {
             if ( logger.isWarnEnabled() )
             {
                 logger.warn( "Could not read password for '" + cvsRoot + "' from '" + passFile + "'", e );
             }
             return null;
         }
         finally
         {
             if ( reader != null )
             {
                 try
                 {
                     reader.close();
                 }
                 catch ( IOException e )
                 {
                     if ( logger.isErrorEnabled() )
                     {
                         logger.error( "Warning: could not close password file." );
                     }
                 }
             }
         }
         if ( password == null )
         {
             if ( logger.isErrorEnabled() )
             {
                 logger.error( "Didn't find password for CVSROOT '" + cvsRoot + "'." );
             }
         }
         return password;
     }
 
     /**
      * Read in a list of return delimited lines from .cvspass and retreive
      * the password.  Return null if the cvsRoot can't be found.
      *
      * @param cvsRoot the CVS root for which the password is being searched
      * @param reader  A buffered reader of lines of cvspass information
      * @return The password, or null if it can't be found.
      * @throws IOException
      */
     static String processCvspass( String cvsRoot, BufferedReader reader )
         throws IOException
     {
         String line;
         String password = null;
         while ( ( line = reader.readLine() ) != null )
         {
             if ( line.startsWith( "/" ) )
             {
                 String[] cvspass = StringUtils.split( line, " " );
                 String cvspassRoot = cvspass[1];
                 if ( compareCvsRoot( cvsRoot, cvspassRoot ) )
                 {
                     int index = line.indexOf( cvspassRoot ) + cvspassRoot.length() + 1;
                     password = line.substring( index );
                     break;
                 }
             }
             else if ( line.startsWith( cvsRoot ) )
             {
                 password = line.substring( cvsRoot.length() + 1 );
                 break;
             }
         }
         return password;
     }
 
     static boolean compareCvsRoot( String cvsRoot, String target )
     {
         String s1 = completeCvsRootPort( cvsRoot );
         String s2 = completeCvsRootPort( target );
         return s1 != null && s1.equals( s2 );
 
     }
 
     private static String completeCvsRootPort( String cvsRoot )
     {
         String result = cvsRoot;
         int idx = cvsRoot.indexOf( ':' );
         for ( int i = 0; i < 2 && idx != -1; i++ )
         {
             idx = cvsRoot.indexOf( ':', idx + 1 );
         }
         if ( idx != -1 && cvsRoot.charAt( idx + 1 ) == '/' )
         {
             StringBuilder sb = new StringBuilder();
             sb.append( cvsRoot.substring( 0, idx + 1 ) );
             sb.append( "2401" );
             sb.append( cvsRoot.substring( idx + 1 ) );
             result = sb.toString();
         }
         return result;
 
     }
 
     /**
      * Process the CVS command passed in args[] array with all necessary
      * options. The only difference from main() method is, that this method
      * does not exit the JVM and provides command output.
      *
      * @param args The command with options
      */
     public static boolean processCommand( String[] args, String localPath, CVSListener listener, ScmLogger logger )
         throws Exception
     {
         // Set up the CVSRoot. Note that it might still be null after this
         // call if the user has decided to set it with the -d command line
         // global option
         GlobalOptions globalOptions = new GlobalOptions();
         globalOptions.setCVSRoot( getCVSRoot( localPath ) );
 
         // Set up any global options specified. These occur before the
         // name of the command to run
         int commandIndex;
 
         try
         {
             commandIndex = processGlobalOptions( args, globalOptions );
         }
         catch ( IllegalArgumentException e )
         {
             if ( logger.isErrorEnabled() )
             {
                 logger.error( "Invalid argument: " + e );
             }
             return false;
         }
 
         // if we don't have a CVS root by now, the user has messed up
         if ( globalOptions.getCVSRoot() == null )
         {
             if ( logger.isErrorEnabled() )
             {
                 logger.error( "No CVS root is set. Check your <repository> information in the POM." );
             }
             return false;
         }
 
         // parse the CVS root into its constituent parts
         CVSRoot root;
         final String cvsRoot = globalOptions.getCVSRoot();
         try
         {
             root = CVSRoot.parse( cvsRoot );
         }
         catch ( IllegalArgumentException e )
         {
             if ( logger.isErrorEnabled() )
             {
                 logger.error( "Incorrect format for CVSRoot: " + cvsRoot + "\nThe correct format is: "
                     + "[:method:][[user][:password]@][hostname:[port]]/path/to/repository"
                     + "\nwhere \"method\" is pserver." );
             }
             return false;
         }
 
         final String command = args[commandIndex];
 
         // this is not login, but a 'real' cvs command, so construct it,
         // set the options, and then connect to the server and execute it
 
         Command c;
         try
         {
             c = CommandFactory.getDefault().createCommand( command, args, ++commandIndex, globalOptions, localPath );
         }
         catch ( IllegalArgumentException e )
         {
             if ( logger.isErrorEnabled() )
             {
                 logger.error( "Illegal argument: " + e.getMessage() );
             }
             return false;
         }
 
         String password = null;
 
         if ( CVSRoot.METHOD_PSERVER.equals( root.getMethod() ) )
         {
             password = root.getPassword();
             if ( password != null )
             {
                 password = StandardScrambler.getInstance().scramble( password );
             }
             else
             {
                 password = lookupPassword( cvsRoot, logger );
                 if ( password == null )
                 {
                     password = StandardScrambler.getInstance().scramble( "" );
                     // an empty password
                 }
             }
         }
         CvsConnection cvsCommand = new CvsConnection();
         cvsCommand.setGlobalOptions( globalOptions );
         cvsCommand.setRepository( root.getRepository() );
         // the local path is just the path where we executed the
         // command. This is the case for command-line CVS but not
         // usually for GUI front-ends
         cvsCommand.setLocalPath( localPath );
 
         cvsCommand.connect( root, password );
         cvsCommand.addListener( listener );
         if ( logger.isDebugEnabled() )
         {
             logger.debug( "Executing CVS command: " + c.getCVSCommand() );
         }
         boolean result = cvsCommand.executeCommand( c );
         cvsCommand.disconnect();
         return result;
     }
 }