package org.codehaus.plexus.util.cli;
   
   /*
    * Copyright The Codehaus Foundation.
    *
    * Licensed 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.
   */
  
  /***************************************************************************************************
   * CruiseControl, a Continuous Integration Toolkit Copyright (c) 2001-2003, ThoughtWorks, Inc. 651 W
   * Washington Ave. Suite 500 Chicago, IL 60661 USA All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without modification, are permitted
   * provided that the following conditions are met: + Redistributions of source code must retain the
   * above copyright notice, this list of conditions and the following disclaimer. + Redistributions
   * in binary form must reproduce the above copyright notice, this list of conditions and the
   * following disclaimer in the documentation and/or other materials provided with the distribution. +
   * Neither the name of ThoughtWorks, Inc., CruiseControl, nor the names of its contributors may be
   * used to endorse or promote products derived from this software without specific prior written
   * permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
   * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   **************************************************************************************************/
  
  /*
   * ====================================================================
   * Copyright 2003-2004 The Apache Software Foundation.
   *
   * Licensed 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.codehaus.plexus.util.Os;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.shell.BourneShell;
  import org.codehaus.plexus.util.cli.shell.CmdShell;
  import org.codehaus.plexus.util.cli.shell.CommandShell;
  import org.codehaus.plexus.util.cli.shell.Shell;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Vector;
  
  /**
   * <p>Commandline objects help handling command lines specifying processes to execute.</p>
   * 
   * <p>The class can be used to define a command line as nested elements or as a helper to define a command line by an
   * application.</p>
   * 
   * <code>
   * &lt;someelement&gt;<br>
   * &nbsp;&nbsp;&lt;acommandline executable="/executable/to/run"&gt;<br>
   * &nbsp;&nbsp;&nbsp;&nbsp;&lt;argument value="argument 1" /&gt;<br>
   * &nbsp;&nbsp;&nbsp;&nbsp;&lt;argument line="argument_1 argument_2 argument_3" /&gt;<br>
   * &nbsp;&nbsp;&nbsp;&nbsp;&lt;argument value="argument 4" /&gt;<br>
   * &nbsp;&nbsp;&lt;/acommandline&gt;<br>
   * &lt;/someelement&gt;<br>
   * </code>
   * 
   * <p>The element <code>someelement</code> must provide a method <code>createAcommandline</code> which returns an instance
   * of this class.</p>
   *
   * @author thomas.haas@softwired-inc.com
   * @author <a href="mailto:stefan.bodewig@epost.de">Stefan Bodewig</a>
   */
  public class Commandline
      implements Cloneable
  {
     /**
      * @deprecated Use {@link org.codehaus.plexus.util.Os} class instead.
      */
     @Deprecated
     protected static final String OS_NAME = "os.name";
 
     /**
      * @deprecated Use {@link org.codehaus.plexus.util.Os} class instead.
      */
     @Deprecated
     protected static final String WINDOWS = "Windows";
 
     protected Vector<Arg> arguments = new Vector<>();
 
     // protected Vector envVars = new Vector();
     // synchronized added to preserve synchronize of Vector class
     protected Map<String, String> envVars = Collections.synchronizedMap( new LinkedHashMap<String, String>() );
 
     private long pid = -1;
 
     private Shell shell;
 
     /**
      * @deprecated Use {@link Commandline#setExecutable(String)} instead.
      */
     @Deprecated
     protected String executable;
 
     /**
      * @deprecated Use {@link Commandline#setWorkingDirectory(File)} or {@link Commandline#setWorkingDirectory(String)}
      *             instead.
      */
     @Deprecated
     private File workingDir;
 
     /**
      * Create a new command line object. Shell is autodetected from operating system Shell usage is only desirable when
      * generating code for remote execution.
      *
      * @param toProcess sh to process
      * @param shell Shell to use
      */
     public Commandline( String toProcess, Shell shell )
     {
         this.shell = shell;
 
         String[] tmp = new String[0];
         try
         {
             tmp = CommandLineUtils.translateCommandline( toProcess );
         }
         catch ( Exception e )
         {
             System.err.println( "Error translating Commandline." );
         }
         if ( ( tmp != null ) && ( tmp.length > 0 ) )
         {
             setExecutable( tmp[0] );
             for ( int i = 1; i < tmp.length; i++ )
             {
                 createArgument().setValue( tmp[i] );
             }
         }
     }
 
     /**
      * Create a new command line object. Shell is autodetected from operating system Shell usage is only desirable when
      * generating code for remote execution.
      * @param shell the Shell
      */
     public Commandline( Shell shell )
     {
         this.shell = shell;
     }
 
     /**
      * Create a new command line object, given a command following POSIX sh quoting rules
      *
      * @param toProcess the process
      */
     public Commandline( String toProcess )
     {
         setDefaultShell();
         String[] tmp = new String[0];
         try
         {
             tmp = CommandLineUtils.translateCommandline( toProcess );
         }
         catch ( Exception e )
         {
             System.err.println( "Error translating Commandline." );
         }
         if ( ( tmp != null ) && ( tmp.length > 0 ) )
         {
             setExecutable( tmp[0] );
             for ( int i = 1; i < tmp.length; i++ )
             {
                 createArgument().setValue( tmp[i] );
             }
         }
     }
 
     /**
      * Create a new command line object.
      */
     public Commandline()
     {
         setDefaultShell();
     }
 
     public long getPid()
     {
         if ( pid == -1 )
         {
             pid = Long.parseLong( String.valueOf( System.currentTimeMillis() ) );
         }
 
         return pid;
     }
 
     public void setPid( long pid )
     {
         this.pid = pid;
     }
 
     /**
      * Class to keep track of the position of an Argument.
      */
     // <p>This class is there to support the srcfile and targetfile
     // elements of &lt;execon&gt; and &lt;transform&gt; - don't know
     // whether there might be additional use cases.</p> --SB
     public class Marker
     {
 
         private int position;
 
         private int realPos = -1;
 
         Marker( int position )
         {
             this.position = position;
         }
 
         /**
          * @return the number of arguments that preceded this marker.
          * 
          * <p>The name of the executable - if set - is counted as the very first argument.</p>
          */
         public int getPosition()
         {
             if ( realPos == -1 )
             {
                 realPos = ( getLiteralExecutable() == null ? 0 : 1 );
                 for ( int i = 0; i < position; i++ )
                 {
                     Arg arg = arguments.elementAt( i );
                     realPos += arg.getParts().length;
                 }
             }
             return realPos;
         }
     }
 
     /**
      * <p>
      * Sets the shell or command-line interpreter for the detected operating system, and the shell arguments.
      * </p>
      */
     private void setDefaultShell()
     {
         // If this is windows set the shell to command.com or cmd.exe with correct arguments.
         if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
         {
             if ( Os.isFamily( Os.FAMILY_WIN9X ) )
             {
                 setShell( new CommandShell() );
             }
             else
             {
                 setShell( new CmdShell() );
             }
         }
         else
         {
             setShell( new BourneShell() );
         }
     }
 
     /**
      * <p>Creates an argument object.</p>
      * 
      * <p>Each commandline object has at most one instance of the argument class. This method calls
      * <code>this.createArgument(false)</code>.</p>
      *
      * @return the argument object.
      * @see #createArgument(boolean)
      * @deprecated Use {@link Commandline#createArg()} instead
      */
     @Deprecated
     public Argument createArgument()
     {
         return this.createArgument( false );
     }
 
     /**
      * <p>Creates an argument object and adds it to our list of args.</p>
      * 
      * <p>Each commandline object has at most one instance of the argument class.</p>
      *
      * @param insertAtStart if true, the argument is inserted at the beginning of the list of args, otherwise it is
      *            appended.
      * @deprecated Use {@link Commandline#createArg(boolean)} instead
      * @return Argument the argument Object
      */
     @Deprecated
     public Argument createArgument( boolean insertAtStart )
     {
         Argument argument = new Argument();
         if ( insertAtStart )
         {
             arguments.insertElementAt( argument, 0 );
         }
         else
         {
             arguments.addElement( argument );
         }
         return argument;
     }
 
     /**
      * <p>Creates an argument object.</p>
      * 
      * <p>Each commandline object has at most one instance of the argument class. This method calls
      * <code>this.createArgument(false)</code>.</p>
      *
      * @return the argument object.
      * @see #createArgument(boolean)
      */
     public Arg createArg()
     {
         return this.createArg( false );
     }
 
     /**
      * @return Creates an argument object and adds it to our list of args.
      * 
      * <p>Each commandline object has at most one instance of the argument class.</p>
      *
      * @param insertAtStart if true, the argument is inserted at the beginning of the list of args, otherwise it is
      *            appended.
      */
     public Arg createArg( boolean insertAtStart )
     {
         Arg argument = new Argument();
         if ( insertAtStart )
         {
             arguments.insertElementAt( argument, 0 );
         }
         else
         {
             arguments.addElement( argument );
         }
         return argument;
     }
 
     /**
      * @param argument the argument
      * @see #addArg(Arg,boolean)
      */
     public void addArg( Arg argument )
     {
         this.addArg( argument, false );
     }
 
     /**
      * Adds an argument object to our list of args.
      * @param argument the argument
      * @param insertAtStart if true, the argument is inserted at the beginning of the list of args, otherwise it is
      *            appended.
      */
     public void addArg( Arg argument, boolean insertAtStart )
     {
         if ( insertAtStart )
         {
             arguments.insertElementAt( argument, 0 );
         }
         else
         {
             arguments.addElement( argument );
         }
     }
 
     /**
      * Sets the executable to run.
      * @param executable the executable
      */
     public void setExecutable( String executable )
     {
         shell.setExecutable( executable );
         this.executable = executable;
     }
 
     /**
      * @return Executable to be run, as a literal string (no shell quoting/munging)
      */
     public String getLiteralExecutable()
     {
         return executable;
     }
 
     /**
      * Return an executable name, quoted for shell use. Shell usage is only desirable when generating code for remote
      * execution.
      *
      * @return Executable to be run, quoted for shell interpretation
      */
     public String getExecutable()
     {
         String exec = shell.getExecutable();
 
         if ( exec == null )
         {
             exec = executable;
         }
 
         return exec;
     }
 
     public void addArguments( String[] line )
     {
         for ( String aLine : line )
         {
             createArgument().setValue( aLine );
         }
     }
 
     /**
      * Add an environment variable
      * @param name name
      * @param value value
      */
     public void addEnvironment( String name, String value )
     {
         // envVars.add( name + "=" + value );
         envVars.put( name, value );
     }
 
     /**
      * Add system environment variables
      * @throws Exception if error
      */
     public void addSystemEnvironment()
         throws Exception
     {
         Properties systemEnvVars = CommandLineUtils.getSystemEnvVars();
 
         for ( Object o : systemEnvVars.keySet() )
         {
             String key = (String) o;
             if ( !envVars.containsKey( key ) )
             {
                 addEnvironment( key, systemEnvVars.getProperty( key ) );
             }
         }
     }
 
     /**
      * @return String[] Return the list of environment variables
      * @throws CommandLineException if error
      */
     public String[] getEnvironmentVariables()
         throws CommandLineException
     {
         try
         {
             addSystemEnvironment();
         }
         catch ( Exception e )
         {
             throw new CommandLineException( "Error setting up environmental variables", e );
         }
         String[] environmentVars = new String[envVars.size()];
         int i = 0;
         for ( Object o : envVars.keySet() )
         {
             String name = (String) o;
             String value = envVars.get( name );
             environmentVars[i] = name + "=" + value;
             i++;
         }
         return environmentVars;
     }
 
     /**
      * @return Returns the executable and all defined arguments.
      *      For Windows Family, {@link Commandline#getShellCommandline()} is returned
      */
     public String[] getCommandline()
     {
         if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
         {
             return getShellCommandline();
         }
 
         return getRawCommandline();
     }
 
     /**
      * Returns the executable and all defined arguments.
      * @return the command line as array not escaped neither quoted
      */
     public String[] getRawCommandline()
     {
         final String[] args = getArguments();
         String executable = getLiteralExecutable();
 
         if ( executable == null )
         {
             return args;
         }
         final String[] result = new String[args.length + 1];
         result[0] = executable;
         System.arraycopy( args, 0, result, 1, args.length );
         return result;
     }
 
 	/**
      * Returns the shell, executable and all defined arguments. Shell usage is only desirable when generating code for
      * remote execution.
      * @return the command line as array
      */
     public String[] getShellCommandline()
     {
         // TODO: Provided only for backward compat. with <= 1.4
         verifyShellState();
 
         return getShell().getShellCommandLine( getArguments() ).toArray( new String[0] );
     }
 
     /**
      * @return Returns all arguments defined by <code>addLine</code>, <code>addValue</code> or the argument object.
      */
     public String[] getArguments()
     {
         Vector<String> result = new Vector<>( arguments.size() * 2 );
         for ( int i = 0; i < arguments.size(); i++ )
         {
             Arg arg = arguments.elementAt( i );
             String[] s = arg.getParts();
             if ( s != null )
             {
                 for ( String value : s )
                 {
                     result.addElement( value );
                 }
             }
         }
 
         String[] res = new String[result.size()];
         result.copyInto( res );
         return res;
     }
 
     @Override
     public String toString()
     {
         return StringUtils.join( getShellCommandline(), " " );
     }
 
     public int size()
     {
         return getCommandline().length;
     }
 
     @Override
     public Object clone()
     {
         Commandline c = new Commandline( (Shell) shell.clone() );
         c.executable = executable;
         c.workingDir = workingDir;
         c.addArguments( getArguments() );
         return c;
     }
 
     /**
      * Clear out the whole command line.
      */
     public void clear()
     {
         executable = null;
         workingDir = null;
         shell.setExecutable( null );
         shell.clearArguments();
         arguments.removeAllElements();
     }
 
     /**
      * Clear out the arguments but leave the executable in place for another operation.
      */
     public void clearArgs()
     {
         arguments.removeAllElements();
     }
 
     /**
      *
      * <p>This marker can be used to locate a position on the commandline - to insert something for example - when all
      * parameters have been set.
      * </p>
      * @return Return a marker.
      */
     public Marker createMarker()
     {
         return new Marker( arguments.size() );
     }
 
     /**
      * Sets execution directory.
      * @param path the working directory as String
      */
     public void setWorkingDirectory( String path )
     {
         shell.setWorkingDirectory( path );
         workingDir = new File( path );
     }
 
     /**
      * Sets execution directory.
      * @param workingDirectory the File used as working directory
      */
     public void setWorkingDirectory( File workingDirectory )
     {
         shell.setWorkingDirectory( workingDirectory );
         workingDir = workingDirectory;
     }
 
     public File getWorkingDirectory()
     {
         File workDir = shell.getWorkingDirectory();
 
         if ( workDir == null )
         {
             workDir = workingDir;
         }
 
         return workDir;
     }
 
     /**
      * Executes the command.
      * @return the Process
      * @throws CommandLineException if error
      */
     public Process execute()
         throws CommandLineException
     {
         // TODO: Provided only for backward compat. with <= 1.4
         verifyShellState();
 
         Process process;
 
         // addEnvironment( "MAVEN_TEST_ENVAR", "MAVEN_TEST_ENVAR_VALUE" );
 
         String[] environment = getEnvironmentVariables();
 
         File workingDir = shell.getWorkingDirectory();
 
         try
         {
             if ( workingDir == null )
             {
                 process = Runtime.getRuntime().exec( getCommandline(), environment, workingDir );
             }
             else
             {
                 if ( !workingDir.exists() )
                 {
                     throw new CommandLineException( "Working directory \"" + workingDir.getPath()
                         + "\" does not exist!" );
                 }
                 else if ( !workingDir.isDirectory() )
                 {
                     throw new CommandLineException( "Path \"" + workingDir.getPath()
                         + "\" does not specify a directory." );
                 }
 
                 process = Runtime.getRuntime().exec( getCommandline(), environment, workingDir );
             }
         }
         catch ( IOException ex )
         {
             throw new CommandLineException( "Error while executing process.", ex );
         }
 
         return process;
     }
 
     /**
      * @deprecated Remove once backward compat with plexus-utils <= 1.4 is no longer a consideration
      */
     @Deprecated
     private void verifyShellState()
     {
         if ( shell.getWorkingDirectory() == null )
         {
             shell.setWorkingDirectory( workingDir );
         }
 
         if ( shell.getOriginalExecutable() == null )
         {
             shell.setExecutable( executable );
         }
     }
 
     public Properties getSystemEnvVars()
         throws Exception
     {
         return CommandLineUtils.getSystemEnvVars();
     }
 
     /**
      * Allows to set the shell to be used in this command line. Shell usage is only desirable when generating code for
      * remote execution.
      *
      * @param shell Shell to use
      * @since 1.2
      */
     public void setShell( Shell shell )
     {
         this.shell = shell;
     }
 
     /**
      * Get the shell to be used in this command line. Shell usage is only desirable when generating code for remote
      * execution.
      * 
      * @since 1.2
      * @return the Shell
      */
     public Shell getShell()
     {
         return shell;
     }
 
     /**
      * @param toProcess the process
      * @return the command line arguments
      * @throws Exception if error happen
      * @deprecated Use {@link CommandLineUtils#translateCommandline(String)} instead.
      */
     @Deprecated
     public static String[] translateCommandline( String toProcess )
         throws Exception
     {
         return CommandLineUtils.translateCommandline( toProcess );
     }
 
     /**
      * @param argument the argument
      * @return the quote arg
      * @throws CommandLineException if error happen
      * @deprecated Use {@link CommandLineUtils#quote(String)} instead.
      */
     @Deprecated
     public static String quoteArgument( String argument )
         throws CommandLineException
     {
         return CommandLineUtils.quote( argument );
     }
 
     /**
      * @deprecated Use {@link CommandLineUtils#toString(String[])} instead.
      * @param line the lines
      * @return lines as single String
      */
     @Deprecated
     public static String toString( String[] line )
     {
         return CommandLineUtils.toString( line );
     }
 
     public static class Argument
         implements Arg
     {
         private String[] parts;
 
         /*
          * (non-Javadoc)
          * @see org.codehaus.plexus.util.cli.Argument#setValue(java.lang.String)
          */
         @Override
         public void setValue( String value )
         {
             if ( value != null )
             {
                 parts = new String[] { value };
             }
         }
 
         /*
          * (non-Javadoc)
          * @see org.codehaus.plexus.util.cli.Argument#setLine(java.lang.String)
          */
         @Override
         public void setLine( String line )
         {
             if ( line == null )
             {
                 return;
             }
             try
             {
                 parts = CommandLineUtils.translateCommandline( line );
             }
             catch ( Exception e )
             {
                 System.err.println( "Error translating Commandline." );
             }
         }
 
         /*
          * (non-Javadoc)
          * @see org.codehaus.plexus.util.cli.Argument#setFile(java.io.File)
          */
         @Override
         public void setFile( File value )
         {
             parts = new String[] { value.getAbsolutePath() };
         }
 
         /*
          * (non-Javadoc)
          * @see org.codehaus.plexus.util.cli.Argument#getParts()
          */
         @Override
         public String[] getParts()
         {
             return parts;
         }
     }
 }