/*
   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.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  import java.util.regex.Pattern;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * General Utilities for several modules.
   *
   * @author Xmas
   * @version 1.0
   */
  public final class SystemUtils {
  
    //Platform names
    /** Windows x86. */
    public static final String WINDOWS_X86 = "Windows_NT+x86";
    /** Windows IA64. */
    public static final String WINDOWS_IA64 = "Windows_NT+ia64";
    /** SunOS sparc. */
    public static final String SUNOS_SPARC = "SunOS+sparc";
    /** SunOS i386. */
    public static final String SUNOS_I386 = "SunOS+i386";
    /** Linux i686. */
    public static final String LINUX_I686 = "Linux+i686";
    /** Linux IA64. */
    public static final String LINUX_IA64 = "Linux+ia64";
    /** Linux AMD64. */
    public static final String LINUX_AMD64 = "Linux+x86_64";
    /** HPUX PARISC. */
    public static final String HPUX_PA = "HP-UX+hppa2.0w";
    /** HPUX IA64. */
    public static final String HPUX_IA64 = "HP-UX+ia64";
    /** AIX PowerPC. */
    public static final String AIX_POWERPC = "AIX+powerpc";
    /** MacOSX PowerPC. */
    public static final String MACOSX_POWERPC = "Darwin+powerpc";
    /** MacOSX Intel. */
    public static final String MACOSX_I386 = "Darwin+i386";
  
  
  
    /**
     * Internal GridSystems Platform.
     */
    static OsMapEntry internalEntry;
  
    /**
     * Internal Normalized OS Name.
     */
    private static String osName;
  
    /**
     * Logger instance for this class.
     */
    private static Log log = LogFactory.getLog(SystemUtils.class);
  
    /**
     * Platform normalization mapping.
     */
    static final Map<String, OsMapEntry> MAP = new HashMap<String, OsMapEntry>();
  
    /**
     * OsMapEntry type.
     */
    static class OsMapEntry {
      /** Entry name. */
      private final String name;
      /** OS recognition pattern. */
      private final Pattern pattern;
      /** Prefix/Suffix for native shared libraries. */
      private final String[] libPreSuffix;
      /** CPU architecture mappings. */
     private final Map<String, String> archs = new HashMap<String, String>();
 
     /**
      * Creates a new instance.
      *
      * @param key   The key
      * @param value The value to be parsed
      */
     public OsMapEntry(String key, String value) {
       this.name = key;
       String[] tokens = value.split("\\s*,\\s*");
       int pos = 0;
       this.pattern = Pattern.compile(tokens[pos++]);
       this.libPreSuffix = new String[] { tokens[pos++], tokens[pos++] };
 
       for (int i = pos; i < tokens.length; i++) {
         String[] pair = tokens[i].split("\\s*=\\s*");
         this.archs.put(pair[0], pair[1]);
       }
     }
 
     /**
      * Gets if the specified string matches this entry pattern.
      *
      * @param s A platform name to process
      * @return true if it matches
      */
     public boolean matches(String s) {
       return this.pattern.matcher(s).matches();
     }
 
     /**
      * Gets the entry name.
      *
      * @return The entry name
      */
     public String getName() {
       return this.name;
     }
 
     /**
      * Maps the specified CPU architecture.
      *
      * @param s The native CPU architecture
      * @return The normalized CPU architecture
      */
     public String mapArch(String s) {
       String mapped = archs.get(s);
       return (mapped == null) ? s : mapped;
     }
 
     /**
      * Gets the prefix and suffix used for shared libraries.
      *
      * @return An array containing the pair [prefix, suffix]
      */
     public String[] getLibPreSuffix() {
       return this.libPreSuffix;
     }
   }
 
   /**
    * Initialise static attributes.
    */
   static {
 
     // Default OS Mappings
     register("Windows_NT", "^Windows.*, lib,.dll, ia64=IA64");
     register("SunOS", "^SunOS.*, lib,.so, x86=i386");
     register("Linux", "^Linux.*, lib,.so, i386=i686,amd64=x86_64");
     register("AIX", "^AIX.*, lib,.so");
     register("HP-UX", "^HP-UX.*, lib,.sl, PA_RISC2.0=hppa2.0w,IA64N=ia64");
     register("Darwin", "^Mac OS X.*, lib,.jnilib, ppc=powerpc");
 
     // Custom OS Mappings
     InputStream is;
     try {
       ClassLoader cl = Thread.currentThread().getContextClassLoader();
       is = cl.getResourceAsStream("os-map.properties");
       if (is != null) {
         Properties props = new Properties();
         props.load(is);
         is.close();
 
         for (Object obj : props.keySet()) {
           String key = (String)obj;
           String value = props.getProperty(key);
           register(new OsMapEntry(key, value));
         }
       }
     } catch (Exception ignore) { }
   }
 
   /**
    * Registers an entry.
    *
    * @param entry The entry to register
    */
   private static void register(OsMapEntry entry) {
     MAP.put(entry.name, entry);
   }
 
   /**
    * Registers an entry from a [key, value] pair.
    *
    * @param key   The entry key
    * @param value The entry value
    */
   private static void register(String key, String value) {
     try {
       register(new OsMapEntry(key, value));
       log.debug("Registered OS Map " + key);
     } catch (Exception ignore) {
     }
   }
 
   /**
    * Private Constructor. No need to instantiate this class
    */
   private SystemUtils() {
   }
 
 
   /**
    * Return true if this OS is windows.
    *
    * @return true if this operating system is Windows
    */
   public static boolean isWindows() {
     OsMapEntry entry = getInternalEntry();
     return entry != null && "Windows_NT".equals(entry.getName());
   }
 
   /**
    * Return true if this OS is not windows.
    *
    * @return true if this operating system is not Windows
    */
   public static boolean isUnix() {
     OsMapEntry entry = getInternalEntry();
     return entry != null && !"Windows_NT".equals(entry.getName());
   }
 
   /**
    * Gets the gridSystems platform name of this machine.
    *
    * @return A "normalized" name for this operating system
    */
   public static String getOsName() {
     if (osName == null) {
       String osId = System.getProperty("os.name");
       String arch = System.getProperty("os.arch");
       osName = getOsName(osId, arch);
     }
     return osName;
   }
 
   /**
    * Gets the local OS name without the CPU architecture.
    *
    * @return The OS Name
    */
   public static String getSimpleOsName() {
     return getInternalEntry().getName();
   }
 
   /**
    * Gets the local architecture name.
    *
    * @return The Architecture name
    */
   public static String getSimpleArchName() {
     String osArch = System.getProperty("os.arch");
     return getInternalEntry().mapArch(osArch);
   }
 
   /**
    * Extracts the simple OS name from the specified platform id.
    *
    * @param osName The platform id
    * @return The stripped OS name
    */
   public static String getSimpleOsName(String osName) {
     int pos = osName.indexOf('+');
     while (pos != -1) {
       String osPrefix = osName.substring(0, pos);
       OsMapEntry entry = getEntry(osPrefix);
       if (entry == null) {
         pos = osName.indexOf('+', pos + 1);
       } else {
         return entry.getName();
       }
     }
 
     return osName;
   }
 
   /**
    * Gets the GridSystems platform name for a machine with the passed properties.
    *
    * @param osName  A value for the "os.name" system property
    * @param osArch  A value for the "os.arch" system property
    * @return A platform name
    */
   public static String getOsName(String osName, String osArch) {
     OsMapEntry entry = getEntry(osName);
     if (entry == null) {
       log.debug("No entry found for [" + osName + "]. OS name not normalized");
       return osName + "+" + osArch;
     } else {
       return entry.name + "+" + entry.mapArch(osArch);
     }
   }
 
   /**
    * Gets the internal OS Map Entry.
    *
    * @return The internal entry
    */
   static OsMapEntry getInternalEntry() {
     if (internalEntry == null) {
       String osId = System.getProperty("os.name");
       internalEntry = getEntry(osId);
     }
     return internalEntry;
   }
 
   /**
    * Gets a GridSystems platform for the specified properties.
    *
    * @param osName  A value for the "os.name" system property
    * @return A platform entry, or null
    */
   protected static OsMapEntry getEntry(String osName) {
     for (OsMapEntry entry : MAP.values()) {
       if (entry.matches(osName)) {
         return entry;
       }
     }
     return null;
   }
 
   /**
    * @return Gets OS version.
    */
   public static String getOSVersion() {
     return System.getProperty("os.version");
   }
 
   /**
    * Retrieves the environment variables list from the system.
    *
    * @return The environment or an empty instance if an error occurs
    */
   public static Properties getEnvironment() {
     Map<String, String> envi = System.getenv();
     Properties env = new Properties();
     env.putAll(envi);
     return env;
 
   }
 
   /**
    * Extracts a Dynamic library of a jar file and load into memory.
    * @param dynamiclibraryname the DL name
    * @param pathclass the path class
    * @return Path to file extracted.
    * @throws Exception if error
    * @deprecated Use JNIUtils.extractDynamicLibrary method.
    */
   public static File extractDynamicLibrary(String dynamiclibraryname,
                                     Class< ? > pathclass) throws Exception {
     return JNIUtils.extractDynamicLibrary(dynamiclibraryname, pathclass);
   }
 
   /**
    * Extracts a Dynamic library of a jar file and loads it into memory.
    * @param dynamiclibraryname the DL name
    * @param path the path
    * @return Path to file extracted.
    * @throws Exception if error
    *  @deprecated Use JNIUtils.extractDynamicLibrary method.
    */
   public static File extractDynamicLibrary(
     String dynamiclibraryname, String path) throws Exception {
     return JNIUtils.extractDynamicLibrary(dynamiclibraryname, path);
   }
 
   /**
    * @return the temporal system directory
    */
   public static String getTempDir() {
     String tmpdir = System.getProperty("java.io.tmpdir", null);
     return ((tmpdir == null) ? System.getProperty("user.home") : tmpdir);
   }
 
   /**
    * Executes the given command and saves its output into a file.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param output Where store StdOut and StdErr of executable
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execAndSaveOutput(String command, String[] envp, File baseDir,
                                       OutputStream output) {
     String[] cmd = new String[] {command };
     final boolean executeAsArray = false;
     return execAndSaveOutput(cmd, envp, baseDir, output, executeAsArray);
   }
 
   /**
    * Executes the given command and saves its output into a file.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param output Where store StdOut and StdErr of executable
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execAndSaveOutput(String[] command, String[] envp, File baseDir,
                                       OutputStream output) {
     final boolean executeAsArray = true;
     return execAndSaveOutput(command, envp, baseDir, output, executeAsArray);
   }
 
   /**
    * Executes the given command and saves its output into a file.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param output Where store StdOut and StdErr of executable
    * @param executeAsArray Execute as full command line, or execute command
    *        and parameters.
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   private static Integer execAndSaveOutput(String[] command, String[] envp, File baseDir,
       OutputStream output, boolean executeAsArray) {
     try {
       Process p;
       if (executeAsArray) {
         p = Runtime.getRuntime().exec(command, envp, baseDir);
       } else {
         p = Runtime.getRuntime().exec(command[0], envp, baseDir);
       }
       SystemStream std = new SystemStream(p.getInputStream(), output);
       SystemStream err = new SystemStream(p.getErrorStream(), output);
       std.start();
       err.start();
 
       int exit = p.waitFor();
 
       try {
         std.stopThread();
       } catch (Exception ex) {
         log.error("Exception happened when stopping SystemStream", ex);
       }
       try {
         err.stopThread();
       } catch (Exception ex) {
         log.error("Exception happened when stopping SystemStream", ex);
       }
 
       return new Integer(exit);
     } catch (Exception ex) {
       log.error("Error executing command: " + command, ex);
       return null;
     }
   }
 
   /**
    * Executes the given command piping its input and output with System.out and System.in.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execPiped(String command, String[] envp, File baseDir) {
     final boolean executeAsArray = false;
     String[] cmd = new String[] { command };
     return execPiped(cmd, envp, baseDir, executeAsArray);
   }
 
   /**
    * Executes the given command piping its input and output with System.out and System.in.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param executeAsArray Execute as full command line, or execute command
    *        and parameters.
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   private static Integer execPiped(String[] command, String[] envp, File baseDir,
       boolean executeAsArray) {
 
     SystemStream[] ss = null;
     try {
       Process p;
       if (executeAsArray) {
         p = Runtime.getRuntime().exec(command, envp, baseDir);
       } else {
         p = Runtime.getRuntime().exec(command[0], envp, baseDir);
       }
       ss = new SystemStream[] {
         new SystemStream(p.getErrorStream(), System.out),
         new SystemStream(p.getInputStream(), System.out)
       };
       for (int i = 0; i < ss.length; i++) {
         ss[i].start();
       }
 
       int exit = p.waitFor();
 
       return new Integer(exit);
     } catch (Exception ex) {
       log.error("Error executing command '" + command + "'", ex);
       return null;
     } finally {
       if (ss != null) {
         for (int i = 0; i < ss.length; i++) {
           try {
             ss[i].stopThread();
           } catch (Exception ex) {
             log.error("Exception happened when stopping SystemStream(" + i + ")", ex);
           }
         }
       }
     }
   }
 
   /**
    * Executes the given command and saves its output into a file.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param outputFile the output file
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execAndSaveOutput(String[] command, String[] envp, File baseDir,
                                       File outputFile) {
     FileOutputStream output;
     try {
       output = new FileOutputStream(outputFile);
       final boolean executeAsArray = true;
       return execAndSaveOutput(command, envp, baseDir, output, executeAsArray);
     } catch (FileNotFoundException e) {
       log.error("Cannot create output file " + outputFile.toString());
       return null;
     }
   }
 
   /**
    * Executes the given command and saves its output into a file.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @param outputFile the output file
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execAndSaveOutput(String command, String[] envp, File baseDir,
                                       File outputFile) {
     final boolean executeAsArray = false;
     FileOutputStream output;
     try {
       output = new FileOutputStream(outputFile);
       String[] cmd = new String[]{ command };
       return execAndSaveOutput(cmd, envp, baseDir, output, executeAsArray);
     } catch (FileNotFoundException e) {
       log.error("Cannot create output file " + outputFile.toString());
       return null;
     }
   }
 
   /**
    * Executes the given command piping its input and output with System.out and System.in.
    * @param command the command to execute
    * @param envp the environment
    * @param baseDir the base directory
    * @return null, if execution has failed, otherwise return Integer with exit code
    */
   public static Integer execPiped(String[] command, String[] envp, File baseDir) {
     final boolean executeAsArray = true;
     return execPiped(command, envp, baseDir, executeAsArray);
   }
 
   /**
    * Nested class SystemStream is a thread that reads from an input stream and
    * writes what has read to an output stream, ad infinitum.
    */
   static class SystemStream extends Thread implements Runnable {
     /** Input stream. */
     InputStream pi = null;
     /** Output stream. */
     OutputStream po = null;
     /** Interruption flag. */
     boolean interruptFlag = false;
 
     /**
      * Creates a pipe between these two streams.
      *
      * @param pi the input stream
      * @param po the output stream
      */
     public SystemStream(InputStream pi, OutputStream po) {
       interruptFlag = false;
       this.pi = pi;
       this.po = po;
     }
 
     /**
      * Writes all incoming characters to the output stream.
      */
     @Override public void run() {
       int ch;
       try {
         while (!interruptFlag) {
           ch = pi.read();
           if (ch == -1) {
             break;
           }
           po.write(ch);
           po.flush();
         }
       } catch (Exception e) {
         e.printStackTrace();
       }
     }
 
     /**
      * Thread stop method.
      *
      */
     public void stopThread() {
       this.interruptFlag = true;
     }
   }
   // End of nested class SystemStream
 
 //  /**
 //   * Test main method.
 //   * @param args argument
 //   */
 //  public static void main(String[] args) {
 //    if (args.length == 0) {
 //      System.out.println("Usage: java SystemUtils GSOsName [LibName]");
 //      System.exit(1);
 //    }
 //
 //    log = new SimpleLog("SystemUtils.class");
 //    ((SimpleLog) log).setLevel(SimpleLog.LOG_LEVEL_OFF);
 //
 //    String gsOsname = args[0];
 //
 //    if (args.length == 1) {
 //      System.out.println(gsOsname);
 //    } else {
 //      String[] prepost = getNativePrefixPostfix(gsOsname);
 //      if (prepost == null) {
 //        System.err.print("Cannot find prefix/postfix for dynamic library of ");
 //        System.err.println(gsOsname);
 //        System.exit(3);
 //      } else {
 //        System.out.println(gsOsname + File.separator + prepost[0]
 //                           + args[1] + prepost[1]);
 //      }
 //    }
 //    System.exit(0);
 //  }
 }