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>

  * @version $Id: CvsConnection.java 1306867 2012-03-29 13:45:10Z olamy $

  */

 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;

     }

 }