/*
    * 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.geometry.io.core.internal;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.Closeable;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.io.UncheckedIOException;
  import java.net.URL;
  import java.nio.charset.Charset;
  import java.nio.file.Path;
  import java.util.stream.Stream;
  
  import org.apache.commons.geometry.io.core.input.GeometryInput;
  import org.apache.commons.geometry.io.core.output.GeometryOutput;
  
  /** Internal class containing utility methods for IO operations.
   */
  public final class GeometryIOUtils {
  
      /** Path separator character used on Unix-like systems. */
      private static final char UNIX_PATH_SEP = '/';
  
      /** Path separator character used on Windows. */
      private static final char WINDOWS_PATH_SEP = '\\';
  
      /** Utility class; no instantiation. */
      private GeometryIOUtils() {}
  
      /** Get the file name of the given path or null if one does not exist
       * or is the empty string.
       * @param path path to get the file name of
       * @return file name of the given path
       */
      public static String getFileName(final Path path) {
          if (path != null) {
              return getFileName(path.toString());
          }
  
          return null;
      }
  
      /** Get the file name of the given url or null if one does not exist or is
       * the empty string.
       * @param url url to get the file name of
       * @return file name of the given url
       */
      public static String getFileName(final URL url) {
          if (url != null) {
              return getFileName(url.getPath());
          }
  
          return null;
      }
  
      /** Get the file name from the given path string, defined as
       * the substring following the last path separator character.
       * Null is returned if the argument is null or the file name is
       * the empty string.
       * @param path path to get the file name from
       * @return file name of the given path string or null if a
       *      non-empty file name does not exist
       */
      public static String getFileName(final String path) {
          if (path != null) {
              final int lastSep = Math.max(
                      path.lastIndexOf(UNIX_PATH_SEP),
                      path.lastIndexOf(WINDOWS_PATH_SEP));
  
              if (lastSep < path.length() - 1) {
                  return path.substring(lastSep + 1);
              }
          }
  
          return null;
      }
  
      /** Get the part of the file name after the last dot.
       * @param fileName file name to get the extension for
       * @return the extension of the file name, the empty string if no extension is found, or
       *      null if the argument is null
      */
     public static String getFileExtension(final String fileName) {
         if (fileName != null) {
             final int idx = fileName.lastIndexOf('.');
             if (idx > -1) {
                 return fileName.substring(idx + 1);
             }
 
             return "";
         }
 
         return null;
     }
 
     /** Create a {@link BufferedReader} for reading from the given input. The charset used is the charset
      * defined in {@code input} or {@code defaultCharset} if null.
      * @param input input to read from
      * @param defaultCharset charset to use if no charset is defined in the input
      * @return new reader instance
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static BufferedReader createBufferedReader(final GeometryInput input, final Charset defaultCharset) {
         final Charset charset = input.getCharset() != null ?
                 input.getCharset() :
                 defaultCharset;
 
         return new BufferedReader(new InputStreamReader(input.getInputStream(), charset));
     }
 
     /** Create a {@link BufferedWriter} for writing to the given output. The charset used is the charset
      * defined in {@code output} or {@code defaultCharset} if null.
      * @param output output to write to
      * @param defaultCharset charset to use if no charset is defined in the output
      * @return new writer instance
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static BufferedWriter createBufferedWriter(final GeometryOutput output, final Charset defaultCharset) {
         final Charset charset = output.getCharset() != null ?
                 output.getCharset() :
                 defaultCharset;
 
         return new BufferedWriter(new OutputStreamWriter(output.getOutputStream(), charset));
     }
 
     /** Get a value from {@code supplier}, wrapping any {@link IOException} with
      * {@link UncheckedIOException}.
      * @param <T> returned type
      * @param supplier object supplying the return value
      * @return supplied value
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static <T> T getUnchecked(final IOSupplier<T> supplier) {
         try {
             return supplier.get();
         } catch (IOException exc) {
             throw createUnchecked(exc);
         }
     }
 
     /** Pass the given argument to the consumer, wrapping any {@link IOException} with
      * {@link UncheckedIOException}.
      * @param <T> argument type
      * @param consumer function to call
      * @param arg function argument
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static <T> void acceptUnchecked(final IOConsumer<T> consumer, final T arg) {
         try {
             consumer.accept(arg);
         } catch (IOException exc) {
             throw createUnchecked(exc);
         }
     }
 
     /** Call the given function with the argument and return the {@code int} result, wrapping any
      * {@link IOException} with {@link UncheckedIOException}.
      * @param <T> argument type
      * @param fn function to call
      * @param arg function argument
      * @return int value
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static <T> int applyAsIntUnchecked(final IOToIntFunction<T> fn, final T arg) {
         try {
             return fn.applyAsInt(arg);
         } catch (IOException exc) {
             throw createUnchecked(exc);
         }
     }
 
     /** Close the argument, wrapping any IO exceptions with {@link UncheckedIOException}.
      * @param closeable argument to close
      * @throws UncheckedIOException if an I/O error occurs
      */
     public static void closeUnchecked(final Closeable closeable) {
         try {
             closeable.close();
         } catch (IOException exc) {
             throw createUnchecked(exc);
         }
     }
 
     /** Create an unchecked exception from the given checked exception. The message of the
      * returned exception contains the original exception's type and message.
      * @param exc exception to wrap in an unchecked exception
      * @return the unchecked exception
      */
     public static UncheckedIOException createUnchecked(final IOException exc) {
         final String msg = exc.getClass().getSimpleName() + ": " + exc.getMessage();
         return new UncheckedIOException(msg, exc);
     }
 
     /** Create an exception indicating a parsing or syntax error.
      * @param msg exception message
      * @return an exception indicating a parsing or syntax error
      */
     public static IllegalStateException parseError(final String msg) {
         return parseError(msg, null);
     }
 
     /** Create an exception indicating a parsing or syntax error.
      * @param msg exception message
      * @param cause exception cause
      * @return an exception indicating a parsing or syntax error
      */
     public static IllegalStateException parseError(final String msg, final Throwable cause) {
         return new IllegalStateException(msg, cause);
     }
 
     /** Pass a supplied {@link Closeable} instance to {@code function} and return the result.
      * The {@code Closeable} instance returned by the supplier is closed if function execution
      * fails, otherwise the instance is <em>not</em> closed.
      * @param <T> Return type
      * @param <C> Closeable type
      * @param function function called with the supplied Closeable instance
      * @param closeableSupplier supplier used to obtain a Closeable instance
      * @return result of calling {@code function} with a supplied Closeable instance
      * @throws java.io.UncheckedIOException if an I/O error occurs
      */
     public static <T, C extends Closeable> T tryApplyCloseable(final IOFunction<C, T> function,
             final IOSupplier<? extends C> closeableSupplier) {
         C closeable = null;
         RuntimeException exc;
         try {
             closeable = closeableSupplier.get();
             return function.apply(closeable);
         } catch (RuntimeException e) {
             exc = e;
         } catch (IOException e) {
             exc = createUnchecked(e);
         }
 
         if (closeable != null) {
             try {
                 closeable.close();
             } catch (IOException suppressed) {
                 exc.addSuppressed(suppressed);
             }
         }
 
         throw exc;
     }
 
     /** Create a stream associated with an input stream. The input stream is closed when the
      * stream is closed and also closed if stream creation fails. Any {@link IOException} thrown
      * when the input stream is closed after the return of this method are wrapped with {@link UncheckedIOException}.
      * @param <T> Stream element type
      * @param <I> Input stream type
      * @param streamFunction function accepting an input stream and returning a stream
      * @param inputStreamSupplier supplier used to obtain the input stream
      * @return stream associated with the input stream return by the supplier
      * @throws java.io.UncheckedIOException if an I/O error occurs during input stream and stream creation
      */
     public static <T, I extends InputStream> Stream<T> createCloseableStream(
             final IOFunction<I, Stream<T>> streamFunction, final IOSupplier<? extends I> inputStreamSupplier) {
         return tryApplyCloseable(
                 in -> streamFunction.apply(in).onClose(closeAsUncheckedRunnable(in)),
                 inputStreamSupplier);
     }
 
     /** Return a {@link Runnable} that calls {@link Closeable#getClass() close()} on the argument,
      * wrapping any {@link IOException} with {@link UncheckedIOException}.
      * @param closeable instance to be closed
      * @return runnable that calls {@code close()) on the argument
      */
     private static Runnable closeAsUncheckedRunnable(final Closeable closeable) {
         return () -> closeUnchecked(closeable);
     }
 }