/*
    * 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.
   */
  package org.apache.commons.crypto;
  
  import java.io.BufferedInputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.StandardCopyOption;
  import java.nio.file.attribute.PosixFileAttributes;
  import java.util.Objects;
  import java.util.Properties;
  import java.util.UUID;
  
  import org.apache.commons.crypto.utils.Utils;
  
  /**
   * A helper to load the native code i.e. libcommons-crypto.so. This handles the
   * fallback to either the bundled libcommons-crypto-Linux-i386-32.so or the
   * default java implementations where appropriate.
   */
  final class NativeCodeLoader {
  
      private static final String SIMPLE_NAME = NativeCodeLoader.class.getSimpleName();
  
      private static final String NATIVE_LIBNAME = "commons-crypto";
  
      private static final String NATIVE_LIBNAME_ALT = "lib" + NATIVE_LIBNAME + ".jnilib";
  
      /**
       * End of file pseudo-character.
       */
      private static final int EOF = -1;
  
      private static final Throwable libraryLoadingError;
  
      private static final boolean libraryLoaded;
  
      static {
          debug("%s static init start", SIMPLE_NAME);
          libraryLoadingError = loadLibrary(); // will be null if loaded OK
          libraryLoaded = libraryLoadingError == null;
          debug("%s libraryLoaded = %s, libraryLoadingError = %s", SIMPLE_NAME, libraryLoaded, libraryLoadingError);
          debug("%s static init end", SIMPLE_NAME);
      }
  
      /**
       * Returns the given InputStream if it is already a {@link BufferedInputStream},
       * otherwise creates a BufferedInputStream from the given InputStream.
       * <p>
       * Copied from Apache Commons IO 2.5.
       * </p>
       *
       * @param inputStream the InputStream to wrap or return (not null)
       * @return the given InputStream or a new {@link BufferedInputStream} for the
       *         given InputStream
       * @throws NullPointerException if the input parameter is null
       */
      @SuppressWarnings("resource")
      private static BufferedInputStream buffer(final InputStream inputStream) {
          // reject null early on rather than waiting for IO operation to fail
          // not checked by BufferedInputStream
          Objects.requireNonNull(inputStream, "inputStream");
          return inputStream instanceof BufferedInputStream ? (BufferedInputStream) inputStream
                  : new BufferedInputStream(inputStream);
      }
  
      /**
       * Checks whether in1 and in2 is equal.
       * <p>
       * Copied from Apache Commons IO 2.5.
       * </p>
       *
       * @param input1 the input1.
       * @param input2 the input2.
       * @return true if in1 and in2 is equal, else false.
       * @throws IOException if an I/O error occurs.
       */
      @SuppressWarnings("resource")
      private static boolean contentsEquals(final InputStream input1, final InputStream input2) throws IOException {
          if (input1 == input2) {
              return true;
         }
         if (input1 == null ^ input2 == null) {
             return false;
         }
         final BufferedInputStream bufferedInput1 = buffer(input1);
         final BufferedInputStream bufferedInput2 = buffer(input2);
         int ch = bufferedInput1.read();
         while (EOF != ch) {
             final int ch2 = bufferedInput2.read();
             if (ch != ch2) {
                 return false;
             }
             ch = bufferedInput1.read();
         }
         return bufferedInput2.read() == EOF;
     }
 
     /**
      * Logs debug messages.
      *
      * @param format See {@link String#format(String, Object...)}.
      * @param args   See {@link String#format(String, Object...)}.
      */
     private static void debug(final String format, final Object... args) {
         // TODO Find a better way to do this later.
         if (isDebug()) {
             System.out.println(String.format(format, args));
             if (args != null && args.length > 0 && args[0] instanceof Throwable) {
                 ((Throwable) args[0]).printStackTrace(System.out);
             }
         }
     }
 
     /**
      * Extracts the specified library file to the target folder.
      *
      * @param libFolderForCurrentOS the library in commons-crypto.lib.path.
      * @param libraryFileName       the library name.
      * @param targetFolder          Target folder for the native lib. Use the value
      *                              of commons-crypto.tempdir or java.io.tmpdir.
      * @return the library file.
      */
     private static File extractLibraryFile(final String libFolderForCurrentOS, final String libraryFileName,
             final String targetFolder) {
         final String nativeLibraryFilePath = libFolderForCurrentOS + File.separator + libraryFileName;
 
         // Attach UUID to the native library file to ensure multiple class loaders
         // can read the libcommons-crypto multiple times.
         final UUID uuid = UUID.randomUUID();
         final String extractedLibFileName = String.format("commons-crypto-%s-%s", uuid, libraryFileName);
         final File extractedLibFile = new File(targetFolder, extractedLibFileName);
         debug("Extracting '%s' to '%s'...", nativeLibraryFilePath, extractedLibFile);
         try (InputStream inputStream = NativeCodeLoader.class.getResourceAsStream(nativeLibraryFilePath)) {
             if (inputStream == null) {
                 debug("Resource not found: %s", nativeLibraryFilePath);
                 return null;
             }
             // Extract a native library file into the target directory
             final Path path;
             try {
                 path = extractedLibFile.toPath();
                 final long byteCount = Files.copy(inputStream, path, StandardCopyOption.REPLACE_EXISTING);
                 if (isDebug()) {
                     debug("Extracted '%s' to '%s': %,d bytes [%s]", nativeLibraryFilePath, extractedLibFile, byteCount,
                             Files.isExecutable(path) ? "X+" : "X-");
                     final PosixFileAttributes attributes = Files.readAttributes(path, PosixFileAttributes.class);
                     if (attributes != null) {
                         debug("Attributes '%s': %s %s %s", extractedLibFile, attributes.permissions(),
                                 attributes.owner(), attributes.group());
                     }
                 }
             } finally {
                 // Delete the extracted lib file on JVM exit.
                 debug("Delete on exit: %s", extractedLibFile);
                 extractedLibFile.deleteOnExit();
             }
 
             // Set executable (x) flag to enable Java to load the native library
             if (!extractedLibFile.setReadable(true) || !extractedLibFile.setExecutable(true)
                     || !extractedLibFile.setWritable(true, true)) {
                 throw new IllegalStateException("Invalid path for library path " + extractedLibFile);
             }
 
             // Check whether the contents are properly copied from the resource
             // folder
             try (InputStream nativeInputStream = NativeCodeLoader.class.getResourceAsStream(nativeLibraryFilePath)) {
                 try (InputStream extractedLibIn = Files.newInputStream(path)) {
                     debug("Validating '%s'...", extractedLibFile);
                     if (!contentsEquals(nativeInputStream, extractedLibIn)) {
                         throw new IllegalStateException(String.format("Failed to write a native library file %s to %s",
                                 nativeLibraryFilePath, extractedLibFile));
                     }
                 }
             }
             return extractedLibFile;
         } catch (final IOException e) {
             debug("Ignoring %s", e);
             return null;
         }
     }
 
     /**
      * Finds the native library.
      *
      * @return the jar file.
      */
     private static File findNativeLibrary() {
         // Get the properties once
         final Properties props = Utils.getDefaultProperties();
 
         // Try to load the library in commons-crypto.lib.path */
         String nativeLibraryPath = props.getProperty(Crypto.LIB_PATH_KEY);
         String nativeLibraryName = props.getProperty(Crypto.LIB_NAME_KEY, System.mapLibraryName(NATIVE_LIBNAME));
 
         debug("%s nativeLibraryPath %s = %s", SIMPLE_NAME, Crypto.LIB_PATH_KEY, nativeLibraryPath);
         debug("%s nativeLibraryName %s = %s", SIMPLE_NAME, Crypto.LIB_NAME_KEY, nativeLibraryName);
 
         if (nativeLibraryPath != null) {
             final File nativeLib = new File(nativeLibraryPath, nativeLibraryName);
             final boolean exists = nativeLib.exists();
             debug("%s nativeLib %s exists = %s", SIMPLE_NAME, nativeLib, exists);
             if (exists) {
                 return nativeLib;
             }
         }
 
         // Load an OS-dependent native library inside a jar file
         nativeLibraryPath = "/org/apache/commons/crypto/native/" + OsInfo.getNativeLibFolderPathForCurrentOS();
         debug("%s nativeLibraryPath = %s", SIMPLE_NAME, nativeLibraryPath);
         final String resource = nativeLibraryPath + File.separator + nativeLibraryName;
         boolean hasNativeLib = hasResource(resource);
         debug("%s resource %s exists = %s", SIMPLE_NAME, resource, hasNativeLib);
         if (!hasNativeLib) {
             final String altName = NATIVE_LIBNAME_ALT;
             if (OsInfo.getOSName().equals("Mac") && hasResource(nativeLibraryPath + File.separator + altName)) {
                 // Fix for openjdk7 for Mac
                 nativeLibraryName = altName;
                 hasNativeLib = true;
             }
         }
 
         if (!hasNativeLib) {
             final String errorMessage = String.format("No native library is found for os.name=%s and os.arch=%s", OsInfo.getOSName(), OsInfo.getArchName());
             throw new IllegalStateException(errorMessage);
         }
 
         // Temporary folder for the native lib. Use the value of
         // Crypto.LIB_TEMPDIR_KEY or java.io.tmpdir
         final String tempFolder = new File(props.getProperty(Crypto.LIB_TEMPDIR_KEY, System.getProperty("java.io.tmpdir"))).getAbsolutePath();
 
         // Extract and load a native library inside the jar file
         return extractLibraryFile(nativeLibraryPath, nativeLibraryName, tempFolder);
     }
 
     /**
      * Gets the error cause if loading failed.
      *
      * @return null, unless loading failed
      */
     static Throwable getLoadingError() {
         return libraryLoadingError;
     }
 
     /**
      * Checks whether the given path has resource.
      *
      * @param path the path.
      * @return the boolean.
      */
     private static boolean hasResource(final String path) {
         return NativeCodeLoader.class.getResource(path) != null;
     }
 
     private static boolean isDebug() {
         return Boolean.getBoolean(Crypto.CONF_PREFIX + "debug");
     }
 
     /**
      * Checks whether native code is loaded for this platform.
      *
      * @return {@code true} if native is loaded, else {@code false}.
      */
     static boolean isNativeCodeLoaded() {
         return libraryLoaded;
     }
 
     /**
      * Loads the library if possible.
      *
      * @return null if successful, otherwise the Throwable that was caught
      */
     static Throwable loadLibrary() {
         try {
             final File nativeLibFile = findNativeLibrary();
             if (nativeLibFile != null) {
                 // Load extracted or specified native library.
                 final String absolutePath = nativeLibFile.getAbsolutePath();
                 debug("%s System.load('%s')", SIMPLE_NAME, absolutePath);
                 System.load(absolutePath);
             } else {
                 // Load preinstalled library (in the path -Djava.library.path)
                 final String libname = NATIVE_LIBNAME;
                 debug("%s System.loadLibrary('%s')", SIMPLE_NAME, libname);
                 System.loadLibrary(libname);
             }
             return null; // OK
         } catch (final Exception | UnsatisfiedLinkError t) {
             return t;
         }
     }
 
     /**
      * The private constructor of {@link NativeCodeLoader}.
      */
     private NativeCodeLoader() {
     }
 }