/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.utils;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Enumeration;
  import java.util.Formatter;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Properties;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * Cross-Platform command execution manager.
   * <p>
   * This class provides a configurable mechanism to invoke native commands
   * in a cross-platform way.
   *
   * @author Rodrigo Ruiz
   */
  public final class NativeShell {
  
    /**
     * Class logger.
     */
    private static final Log LOG = LogFactory.getLog(NativeShell.class);
  
    /**
     * Buffer size.
     */
    private static final int BUF_SIZE = 4096;
  
    /**
     * Command Alias map.
     */
    private static final FileProperties ALIAS;
  
    static {
      Properties defaults = new Properties();
      InputStream is = null;
      try {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        is = cl.getResourceAsStream("native-commands.properties");
        defaults.load(is);
      } catch (Exception e) {
        LOG.error("Could not load native-commands defaults", e);
      } finally {
        FileUtils.close(is);
      }
  
      File f = new File("native-commands.properties");
      ALIAS = new FileProperties(f, defaults);
    }
  
    /**
     * Sets the command alias configuration file.
     *
     * @param f The file
     */
    public static void setConfigFile(File f) {
      ALIAS.setFile(f);
    }
  
    /**
     * Environment.
     */
    private ProcessBuilder builder = new ProcessBuilder();
  
    /**
     * Standard Output redirection.
     */
    private OutputStream stdOut;
  
    /**
     * Standard Error redirection.
     */
    private OutputStream stdErr;
  
    /**
    * Close StdOut on end flag.
    */
   private boolean closeStdOut;
 
   /**
    * Close StdErr on end flag.
    */
   private boolean closeStdErr;
 
   /**
    * Creates an instance.
    */
   public NativeShell() {
   }
 
   /**
    * Gets a platform dependent alias for the specified command.
    *
    * @param cmd The command to search for
    * @param args Command parameters
    * @return The found alias
    */
   public static String alias(String cmd, Object... args) {
     String osName = SystemUtils.getOsName();
     return doAlias(osName, cmd, args);
   }
 
   /**
    * Gets a platform dependent alias for the specified command.
    *
    * @param cmd    The command to search for
    * @param osName The platform for which the command is expected
    * @param args Command parameters
    * @return The found alias
    */
   protected static String doAlias(String osName, String cmd, Object... args) {
     String osPrefix = SystemUtils.getSimpleOsName(osName);
     String osVersion = System.getProperty("os.version");
 
     String alias = ALIAS.getProperty(cmd + "_" + osPrefix + "_" + osVersion);
     if (alias == null) {
       alias = ALIAS.getProperty(cmd + "_" + osPrefix);
       if (alias == null) {
         alias = ALIAS.getProperty(cmd, "#null");
       }
     }
 
     if ("#null".equals(alias)) {
       return null;
     } else if (args.length == 0) {
       return alias;
     } else {
       Formatter f = new Formatter();
       return f.format(alias, args).toString();
     }
   }
 
   /**
    * Gets a list of all commands this instance is aware of. The list includes
    * commands that may be unsupported for the current platform. To get only
    * those commands available in the local platform, use the method
    * {@link #getAvailableCommands()} instead.
    *
    * @return A list of known command names
    */
   public static String[] getAllCommands() {
     HashSet<String> commands = new HashSet<String>();
     for (Enumeration< ? > names = ALIAS.propertyNames(); names.hasMoreElements();) {
       String name = names.nextElement().toString();
       int pos = name.indexOf('_');
       String cmd = (pos == -1) ? name : name.substring(0, pos);
       commands.add(cmd);
     }
 
     return commands.toArray(new String[commands.size()]);
   }
 
   /**
    * Gets a list of all commands available in this platform.
    *
    * @return A list of available command names
    */
   public static String[] getAvailableCommands() {
     String[] all = getAllCommands();
     HashSet<String> available = new HashSet<String>();
     for (String cmd : all) {
       String alias = alias(cmd);
       if (alias != null) {
         available.add(cmd);
       }
     }
 
     return available.toArray(new String[available.size()]);
   }
 
   /**
    * Gets an array to be used for executing the given command in a
    * platform dependent shell.
    * <p>
    * The command is converted in a platform dependent command by calling
    * {@link #alias(String, Object...)}.
    *
    * @param cmd  The command to execute
    * @param args The command arguments
    * @return An array that can be used in an exec() call
    */
   public static String[] shell(String cmd, Object... args) {
     String osName = SystemUtils.getOsName();
     return doShell(osName, cmd, args);
   }
 
   /**
    * Gets an array to be used for executing the given command in a
    * platform dependent shell.
    * <p>
    * The command is converted in a platform dependent command by calling
    * {@link #alias(String, Object...)}.
    *
    * @param osName The OS name
    * @param cmd    The command to execute
    * @param args   The command arguments
    * @return An array that can be used in an exec() call
    */
   protected static String[] doShell(String osName, String cmd, Object... args) {
     String alias = alias(osName, cmd, args);
     String shell = alias(osName, "shell");
     String shopts = alias(osName, "shopts");
 
     if (alias == null || shell == null) {
       return null;
     } else if (shopts == null) {
       return new String[] { shell, alias };
     } else {
       return new String[] { shell, shopts, alias };
     }
   }
 
   /**
    * Gets the shell environment.
    *
    * @return The environment
    */
   public Map<String, String> getEnv() {
     return this.builder.environment();
   }
 
   /**
    * Sets the working directory.
    *
    * @param dir The directory
    */
   public void setDirectory(File dir) {
     this.builder.directory(dir);
   }
 
   /**
    * Gets the working directory.
    *
    * @return The directory
    */
   public File getDirectory() {
     return this.builder.directory();
   }
 
   /**
    * Redirects the standard output to a file.
    *
    * @param f The file to redirect to
    * @throws IOException If the file cannot be created
    */
   public void setStdOut(File f) throws IOException {
     if (this.stdOut != null && this.closeStdOut) {
       FileUtils.close(this.stdOut);
     }
 
     if (f == null) {
       this.stdOut = null;
       this.closeStdOut = false;
     } else {
       File parent = f.getParentFile();
       if (parent != null) {
         parent.mkdirs();
       }
 
       this.stdOut = new FileOutputStream(f);
       this.closeStdOut = true;
     }
   }
 
   /**
    * Redirects the standard output to a stream.
    *
    * @param os The stream to redirect to
    */
   public void setStdOut(OutputStream os) {
     if (this.stdOut != null && this.closeStdOut) {
       FileUtils.close(this.stdOut);
     }
 
     this.stdOut = os;
     this.closeStdOut = false;
   }
 
   /**
    * Redirects the standard error to a file.
    *
    * @param f The file to redirect to
    * @throws IOException If the file cannot be created
    */
   public void setStdErr(File f) throws IOException {
     if (this.stdErr != null && this.closeStdErr) {
       FileUtils.close(this.stdErr);
     }
 
     if (f == null) {
       this.stdErr = null;
       this.closeStdErr = false;
     } else {
       File parent = f.getParentFile();
       if (parent != null) {
         parent.mkdirs();
       }
 
       this.stdErr = new FileOutputStream(f);
       this.closeStdErr = true;
     }
   }
 
   /**
    * Redirects the standard error to a stream.
    *
    * @param os The stream to redirect to
    */
   public void setStdErr(OutputStream os) {
     if (this.stdErr != null && this.closeStdErr) {
       FileUtils.close(this.stdErr);
     }
 
     this.stdErr = os;
     this.closeStdErr = false;
   }
 
   /**
    * Executes a native application.
    *
    * @param cmd  The command to execute
    * @param args The command arguments
    * @return null if nothing was executed, or the exit code
    * @throws IOException If an error occurs during the execution
    * @throws InterruptedException If the thread is interrupted
    */
   public Integer exec(String cmd, Object... args)
     throws IOException, InterruptedException {
     String osName = SystemUtils.getOsName();
     return doExec(osName, cmd, args);
   }
 
   /**
    * Executes a native application.
    *
    * @param osName The OS name
    * @param cmd    The command to execute
    * @param args   The command arguments
    * @return null if nothing was executed, or the exit code
    * @throws IOException If an error occurs during the execution
    * @throws InterruptedException If the thread is interrupted
    */
   protected Integer doExec(String osName, String cmd, Object... args)
     throws IOException, InterruptedException {
     String[] cmdline = doShell(osName, cmd, args);
     if (cmdline == null) {
       return null;
     } else {
       builder.command(cmdline);
       Process p = builder.start();
 
       Pipe out;
       Pipe err;
       if (stdOut == null) {
         out = null;
       } else {
         out = new Pipe(p.getInputStream(), stdOut, closeStdOut);
         out.start();
       }
       if (stdErr == null) {
         err = null;
       } else {
         err = new Pipe(p.getErrorStream(), stdErr, closeStdErr);
         err.start();
       }
 
       try {
         int exitCode = p.waitFor();
         if (out.getError() != null) {
           throw out.getError();
         } else if (err.getError() != null) {
           throw err.getError();
         } else {
           return exitCode;
         }
       } catch (InterruptedException e) {
         p.destroy(); // This closes the streams, cancelling the pipes
         throw e;
       }
     }
   }
 
   /**
    * Pipe type.
    */
   private static class Pipe extends Thread {
     /** Stream to read from. */
     private InputStream is;
     /** Stream to write to. */
     private OutputStream os;
     /** Error. */
     private IOException error;
     /** Close stream on end flag. */
     private boolean closeOutput;
 
     /**
      * Creates a new instance.
      *
      * @param is The stream to read from
      * @param os The stream to write to
      * @param closeOutput Whether to close the output stream or not
      */
     public Pipe(InputStream is, OutputStream os, boolean closeOutput) {
       this.is = is;
       this.os = os;
       this.closeOutput = closeOutput;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override public void run() {
       try {
         byte[] buf = new byte[BUF_SIZE];
         int count = is.read(buf);
         while (count != -1) {
           os.write(buf, 0, count);
           count = is.read(buf);
         }
         os.flush();
       } catch (IOException e) {
         this.error = e;
       } finally {
         FileUtils.close(is);
         if (closeOutput) {
           FileUtils.close(os);
         }
       }
     }
 
     /**
      * Gets the error, if any.
      *
      * @return The error
      */
     public IOException getError() {
       return this.error;
     }
   }
 }