/*
   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 org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.gridsystems.utils.SystemUtils.OsMapEntry;
  
  /**
   * Utility methods for JNI.
   * @author Xmas
   *
   */
  public final class JNIUtils {
  
    /** Maximum index to use to store libraries into disk. */
    private static final int MAX_DYN_LIB_INDEX = 100;
  
    /**
     * Logger instance for this class.
     */
    private static Log log = LogFactory.getLog(JNIUtils.class);
  
    /**
     * Constructor.
     */
    private JNIUtils() {
      super();
    }
  
    /**
     *  Return prefix and postfix of the dinamic libraries name in
     *  the operating system 'os'.
     *
     *  @param os the operating system
     *  @return A string array of lenght 2: position 0 contains prefix and
     *          position 1 contains posfix of dinamic library.
     */
    public static String[] getNativePrefixPostfix(String os) {
      if (os == null) {
        return null;
      }
  
      int pos = os.lastIndexOf("_");
      String osPrefix = os.substring(0, pos);
  
      OsMapEntry entry = SystemUtils.MAP.get(osPrefix);
      if (entry == null) {
        log.error("Cannot find native prefix/postfix for OS " + os);
        return null;
      } else {
        return entry.getLibPreSuffix();
      }
    }
  
    /**
     * 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
     */
    public static File extractDynamicLibrary(String dynamiclibraryname,
                                      Class< ? > pathclass) throws Exception {
      String path = pathclass.getPackage().getName().replace('.', '/');
      return extractDynamicLibrary(dynamiclibraryname, path);
    }
  
    /**
     * 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
     */
    public static File extractDynamicLibrary(
      String dynamiclibraryname, String path) throws Exception {
  
      OsMapEntry entry = SystemUtils.getInternalEntry();
     if (entry == null) {
       // "There is not Dynamic Library Information for OS "+os
       throw new Exception(I18n.translate("error.dll.noinfo", SystemUtils.getOsName()));
     }
 
     String[] prefixes = entry.getLibPreSuffix();
     File lib = null;
     InputStream is;
 
     ClassLoader cl = Thread.currentThread().getContextClassLoader();
     String libFile = prefixes[0] + dynamiclibraryname + prefixes[1];
     String ruta = path + "/" + SystemUtils.getOsName() + "/" + libFile;
 
     int i = 0;
     try {
       File tmpDir = null;
       if (SystemUtils.isWindows()) {
         tmpDir = new File(SystemUtils.getTempDir());
       } else {
         tmpDir = new File(SystemUtils.getTempDir(), "xDynLib_" + System.nanoTime());
         tmpDir.mkdir();
         tmpDir.deleteOnExit();
       }
       while (true) {
         lib = getDllTempFile(prefixes[0] + dynamiclibraryname, i, prefixes[1], tmpDir);
         is = cl.getResourceAsStream(ruta);
         if (is == null) {
           // No encuentra el recurso demandado
           throw new Exception(I18n.translate("error.resourcenotfound", ruta));
         }
 
         boolean fileAlreadyExisted = lib.exists();
 
         boolean success = copyLibrary(lib, is, dynamiclibraryname);
 
         if (success) {
           // If the JVM exits normally, the file will be deleted.
           lib.deleteOnExit();
           // The library was successfully stored.
           if ("HP-UX".equals(entry.getName())) {
             FileUtils.chmod("0555", lib, false);
           }
 
           System.load(lib.getAbsolutePath());
           return lib;
         }
         // From here, success = false
         if (!fileAlreadyExisted) {
           // If could not write the file and the file did not exist previously,
           // then the failure is not due to a locked file
           throw new Exception(I18n.translate("error.write.file"));
         }
         i++;
         // Try with the next integer;
         if (i > MAX_DYN_LIB_INDEX) {
           throw new Exception(I18n.translate("error.dll.maxindex"));
         }
       }
     } catch (Exception ex) {
       String[] params = new String[]{dynamiclibraryname, ex.getMessage()};
       String msg = I18n.translate("error.dll.load", params);
       log.error(msg, ex);
       throw new Exception(msg);
     } finally {
       if ((lib != null) && (SystemUtils.isUnix())) {
         new File(lib.getParentFile().getAbsolutePath()).deleteOnExit();
       }
     }
   }
 
   /**
    * Gets a name where a dll will be tried to be saved.
    *
    * @param dllName the name of the library (not the file name).
    * @param index the numbers of attempts previously failed.
    * @param dllExtension the extension to assign to the file.
    * @param tmpDir Temporal directory where store dll.
    * @return the File to use to store the dll in disk.
    */
   private static File getDllTempFile(
     String dllName, int index, String dllExtension, File tmpDir) {
 
     if (!tmpDir.exists()) {
       System.err.println("TEMPORAL DIRECTORY " + tmpDir
         + " DOES NOT EXIST! EXITING!");
       System.out.println("TEMPORAL DIRECTORY " + tmpDir
         + " DOES NOT EXIST! EXITING!");
       log.fatal("TEMPORAL DIRECTORY " + tmpDir + " DOES NOT EXIST!");
       System.exit(-1);
     }
     String systemUser = System.getProperty("user.name", "none");
     String newFileName = null;
     if (index == 0) {
       newFileName = dllName + "_" + systemUser + dllExtension;
     } else {
       newFileName = dllName + "_" + systemUser + "_" + index + dllExtension;
     }
     return new File(tmpDir, newFileName);
   }
 
   /**
    * Copies a file from a InputStream to a file in disk.
    *
    * @param dst the destination file.
    * @param is the inputstream from which read. This method will close it.
    * @param name the name of the library being copied (for log purposes).
    *
    * @return true if and only if the file was successfully copied, and false if
    * an error happened when writting to the new file.
    * @throws IOException if an error happened when reading from the is.
    */
   private static boolean copyLibrary(File dst, InputStream is, String name)
     throws IOException {
     // If after storing the file this flag is still false, the file was
     // successfully stored
     FileOutputStream fos = null;
     try {
       try {
         fos = new FileOutputStream(dst);
       } catch (IOException ioe) {
         log.info("Could not open outputstream to " + dst);
         return false;
       }
 
       int length;
       byte[] datos = new byte[FileUtils.ONE_KB_IN_BYTES];
       while ((length = is.read(datos)) != -1) {
         try {
           fos.write(datos, 0, length);
         } catch (IOException ioe) {
           log.warn("Could not extract the " + name + " to " + dst, ioe);
           return false;
         }
       }
     } finally {
       try {
         is.close();
       } catch (Exception e) {
         log.warn("Exception closing InputStream from classloader");
       }
       try {
         fos.close();
       } catch (Exception e) {
         log.warn("Exception closing OutputStream from classloader");
       }
     }
     return true;
   }
 
 }