/*
 * 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.camel.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;
import java.util.stream.Stream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * IO helper class.
 */
public final class IOHelper {

    public static Supplier<Charset> defaultCharset = Charset::defaultCharset;

    // Use the same default buffer size as the JVM
    public static final int DEFAULT_BUFFER_SIZE = 16384;

    public static final long INITIAL_OFFSET = 0;

    private static final Logger LOG = LoggerFactory.getLogger(IOHelper.class);

    // allows to turn on backwards compatible to turn off regarding the first
    // read byte with value zero (0b0) as EOL.
    // See more at CAMEL-11672
    private static final boolean ZERO_BYTE_EOL_ENABLED
            = "true".equalsIgnoreCase(System.getProperty("camel.zeroByteEOLEnabled", "true"));

    private IOHelper() {
        // Utility Class
    }

    /**
     * Wraps the passed <code>in</code> into a {@link BufferedInputStream} object and returns that. If the passed
     * <code>in</code> is already an instance of {@link BufferedInputStream} returns the same passed <code>in</code>
     * reference as is (avoiding double wrapping).
     *
     * @param  in the wrapee to be used for the buffering support
     * @return    the passed <code>in</code> decorated through a {@link BufferedInputStream} object as wrapper
     */
    public static BufferedInputStream buffered(InputStream in) {
        return (in instanceof BufferedInputStream bi) ? bi : new BufferedInputStream(in);
    }

    /**
     * Wraps the passed <code>out</code> into a {@link BufferedOutputStream} object and returns that. If the passed
     * <code>out</code> is already an instance of {@link BufferedOutputStream} returns the same passed <code>out</code>
     * reference as is (avoiding double wrapping).
     *
     * @param  out the wrapee to be used for the buffering support
     * @return     the passed <code>out</code> decorated through a {@link BufferedOutputStream} object as wrapper
     */
    public static BufferedOutputStream buffered(OutputStream out) {
        return (out instanceof BufferedOutputStream bo) ? bo : new BufferedOutputStream(out);
    }

    /**
     * Wraps the passed <code>reader</code> into a {@link BufferedReader} object and returns that. If the passed
     * <code>reader</code> is already an instance of {@link BufferedReader} returns the same passed <code>reader</code>
     * reference as is (avoiding double wrapping).
     *
     * @param  reader the wrapee to be used for the buffering support
     * @return        the passed <code>reader</code> decorated through a {@link BufferedReader} object as wrapper
     */
    public static BufferedReader buffered(Reader reader) {
        return (reader instanceof BufferedReader br) ? br : new BufferedReader(reader);
    }

    /**
     * Wraps the passed <code>writer</code> into a {@link BufferedWriter} object and returns that. If the passed
     * <code>writer</code> is already an instance of {@link BufferedWriter} returns the same passed <code>writer</code>
     * reference as is (avoiding double wrapping).
     *
     * @param  writer the writer to be used for the buffering support
     * @return        the passed <code>writer</code> decorated through a {@link BufferedWriter} object as wrapper
     */
    public static BufferedWriter buffered(Writer writer) {
        return (writer instanceof BufferedWriter bw) ? bw : new BufferedWriter(writer);
    }

    public static String toString(Reader reader) throws IOException {
        return toString(reader, INITIAL_OFFSET);
    }

    public static String toString(Reader reader, long offset) throws IOException {
        return toString(buffered(reader), offset);
    }

    public static String toString(BufferedReader reader) throws IOException {
        return toString(reader, INITIAL_OFFSET);
    }

    public static String toString(BufferedReader reader, long offset) throws IOException {
        StringBuilder sb = new StringBuilder(1024);

        reader.skip(offset);

        char[] buf = new char[1024];
        try {
            int len;
            // read until we reach then end which is the -1 marker
            while ((len = reader.read(buf)) != -1) {
                sb.append(buf, 0, len);
            }
        } finally {
            IOHelper.close(reader, "reader", LOG);
        }

        return sb.toString();
    }

    /**
     * Copies the data from the input stream to the output stream. Uses {@link InputStream#transferTo(OutputStream)}.
     *
     * @param  input       the input stream buffer
     * @param  output      the output stream buffer
     * @return             the number of bytes copied
     * @throws IOException for I/O errors
     */
    public static int copy(InputStream input, OutputStream output) throws IOException {
        int copied = (int) input.transferTo(output);
        output.flush();
        return copied;
    }

    /**
     * Copies the data from the input stream to the output stream. Uses the legacy copy logic. Prefer using
     * {@link IOHelper#copy(InputStream, OutputStream)} unless you have to control how data is flushed the buffer
     *
     * @param  input       the input stream buffer
     * @param  output      the output stream buffer
     * @param  bufferSize  the size of the buffer used for the copies
     * @return             the number of bytes copied
     * @throws IOException for I/O errors
     */
    public static int copy(final InputStream input, final OutputStream output, int bufferSize) throws IOException {
        return copy(input, output, bufferSize, false);
    }

    /**
     * Copies the data from the input stream to the output stream. Uses the legacy copy logic. Prefer using
     * {@link IOHelper#copy(InputStream, OutputStream)} unless you have to control how data is flushed the buffer
     *
     * @param  input            the input stream buffer
     * @param  output           the output stream buffer
     * @param  bufferSize       the size of the buffer used for the copies
     * @param  flushOnEachWrite whether to flush the data everytime that data is written to the buffer
     * @return                  the number of bytes copied
     * @throws IOException      for I/O errors
     */
    public static int copy(final InputStream input, final OutputStream output, int bufferSize, boolean flushOnEachWrite)
            throws IOException {
        return copy(input, output, bufferSize, flushOnEachWrite, -1);
    }

    /**
     * Copies the data from the input stream to the output stream. Uses the legacy copy logic. Prefer using
     * {@link IOHelper#copy(InputStream, OutputStream)} unless you have to control how data is flushed the buffer
     *
     * @param  input            the input stream buffer
     * @param  output           the output stream buffer
     * @param  bufferSize       the size of the buffer used for the copies
     * @param  flushOnEachWrite whether to flush the data everytime that data is written to the buffer
     * @return                  the number of bytes copied
     * @throws IOException      for I/O errors
     */
    public static int copy(
            final InputStream input, final OutputStream output, int bufferSize, boolean flushOnEachWrite,
            long maxSize)
            throws IOException {

        if (input instanceof ByteArrayInputStream) {
            // optimized for byte arrays as we only need the max size it can be
            input.mark(0);
            input.reset();
            bufferSize = input.available();
        } else {
            int avail = input.available();
            if (avail > bufferSize) {
                bufferSize = avail;
            }
        }

        if (bufferSize > 262144) {
            // upper cap to avoid buffers too big
            bufferSize = 262144;
        }

        if (LOG.isTraceEnabled()) {
            LOG.trace("Copying InputStream: {} -> OutputStream: {} with buffer: {} and flush on each write {}", input, output,
                    bufferSize, flushOnEachWrite);
        }

        int total = 0;
        final byte[] buffer = new byte[bufferSize];
        int n = input.read(buffer);

        boolean hasData;
        if (ZERO_BYTE_EOL_ENABLED) {
            // workaround issue on some application servers which can return 0
            // (instead of -1)
            // as first byte to indicate the end of stream (CAMEL-11672)
            hasData = n > 0;
        } else {
            hasData = n > -1;
        }
        if (hasData) {
            while (-1 != n) {
                output.write(buffer, 0, n);
                if (flushOnEachWrite) {
                    output.flush();
                }
                total += n;
                if (maxSize > 0 && total > maxSize) {
                    throw new IOException("The InputStream entry being copied exceeds the maximum allowed size");
                }
                n = input.read(buffer);
            }
        }
        if (!flushOnEachWrite) {
            // flush at end, if we didn't do it during the writing
            output.flush();
        }
        return total;
    }

    /**
     * Copies the data from the input stream to the output stream and closes the input stream afterward. Uses
     * {@link InputStream#transferTo(OutputStream)}.
     *
     * @param  input       the input stream buffer
     * @param  output      the output stream buffer
     * @throws IOException
     */
    public static void copyAndCloseInput(InputStream input, OutputStream output) throws IOException {
        copy(input, output);
        close(input, null, LOG);
    }

    /**
     * Copies the data from the input stream to the output stream and closes the input stream afterward. Uses Camel's
     * own copying logic. Prefer using {@link IOHelper#copyAndCloseInput(InputStream, OutputStream)} unless you need a
     * specific buffer size.
     *
     * @param  input       the input stream buffer
     * @param  output      the output stream buffer
     * @param  bufferSize  the size of the buffer used for the copies
     * @throws IOException
     */
    public static void copyAndCloseInput(InputStream input, OutputStream output, int bufferSize) throws IOException {
        copy(input, output, bufferSize);
        close(input, null, LOG);
    }

    public static int copy(final Reader input, final Writer output, int bufferSize) throws IOException {
        final char[] buffer = new char[bufferSize];
        int n = input.read(buffer);
        int total = 0;
        while (-1 != n) {
            output.write(buffer, 0, n);
            total += n;
            n = input.read(buffer);
        }
        output.flush();
        return total;
    }

    public static void transfer(ReadableByteChannel input, WritableByteChannel output) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
        while (input.read(buffer) >= 0) {
            buffer.flip();
            while (buffer.hasRemaining()) {
                output.write(buffer);
            }
            buffer.clear();
        }
    }

    /**
     * Forces any updates to this channel's file to be written to the storage device that contains it.
     *
     * @param channel the file channel
     * @param name    the name of the resource
     * @param log     the log to use when reporting warnings, will use this class's own {@link Logger} if
     *                <tt>log == null</tt>
     */
    public static void force(FileChannel channel, String name, Logger log) {
        try {
            if (channel != null) {
                channel.force(true);
            }
        } catch (Exception e) {
            if (log == null) {
                // then fallback to use the own Logger
                log = LOG;
            }
            if (name != null) {
                log.debug("Cannot force FileChannel: {}. Reason: {}", name, e.getMessage(), e);
            } else {
                log.debug("Cannot force FileChannel. Reason: {}", e.getMessage(), e);
            }
        }
    }

    /**
     * Forces any updates to a FileOutputStream be written to the storage device that contains it.
     *
     * @param os   the file output stream
     * @param name the name of the resource
     * @param log  the log to use when reporting warnings, will use this class's own {@link Logger} if
     *             <tt>log == null</tt>
     */
    public static void force(FileOutputStream os, String name, Logger log) {
        try {
            if (os != null) {
                os.getFD().sync();
            }
        } catch (Exception e) {
            if (log == null) {
                // then fallback to use the own Logger
                log = LOG;
            }
            if (name != null) {
                log.debug("Cannot sync FileDescriptor: {}. Reason: {}", name, e.getMessage(), e);
            } else {
                log.debug("Cannot sync FileDescriptor. Reason: {}", e.getMessage(), e);
            }
        }
    }

    /**
     * Closes the given writer, logging any closing exceptions to the given log. An associated FileOutputStream can
     * optionally be forced to disk.
     *
     * @param writer the writer to close
     * @param os     an underlying FileOutputStream that will to be forced to disk according to the force parameter
     * @param name   the name of the resource
     * @param log    the log to use when reporting warnings, will use this class's own {@link Logger} if
     *               <tt>log == null</tt>
     * @param force  forces the FileOutputStream to disk
     */
    public static void close(Writer writer, FileOutputStream os, String name, Logger log, boolean force) {
        if (writer != null && force) {
            // flush the writer prior to syncing the FD
            try {
                writer.flush();
            } catch (Exception e) {
                if (log == null) {
                    // then fallback to use the own Logger
                    log = LOG;
                }
                if (name != null) {
                    log.debug("Cannot flush Writer: {}. Reason: {}", name, e.getMessage(), e);
                } else {
                    log.debug("Cannot flush Writer. Reason: {}", e.getMessage(), e);
                }
            }
            force(os, name, log);
        }
        close(writer, name, log);
    }

    /**
     * Closes the given resource if it is available, logging any closing exceptions to the given log.
     *
     * @param closeable the object to close
     * @param name      the name of the resource
     * @param log       the log to use when reporting closure warnings, will use this class's own {@link Logger} if
     *                  <tt>log == null</tt>
     */
    public static void close(Closeable closeable, String name, Logger log) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                if (log == null) {
                    // then fallback to use the own Logger
                    log = LOG;
                }
                if (name != null) {
                    log.debug("Cannot close: {}. Reason: {}", name, e.getMessage(), e);
                } else {
                    log.debug("Cannot close. Reason: {}", e.getMessage(), e);
                }
            }
        }
    }

    /**
     * Closes the given resource if it is available and don't catch the exception
     *
     * @param closeable the object to close
     */
    public static void closeWithException(Closeable closeable) throws IOException {
        if (closeable != null) {
            closeable.close();
        }
    }

    /**
     * Closes the given channel if it is available, logging any closing exceptions to the given log. The file's channel
     * can optionally be forced to disk.
     *
     * @param channel the file channel
     * @param name    the name of the resource
     * @param log     the log to use when reporting warnings, will use this class's own {@link Logger} if
     *                <tt>log == null</tt>
     * @param force   forces the file channel to disk
     */
    public static void close(FileChannel channel, String name, Logger log, boolean force) {
        if (force) {
            force(channel, name, log);
        }
        close(channel, name, log);
    }

    /**
     * Closes the given resource if it is available.
     *
     * @param closeable the object to close
     * @param name      the name of the resource
     */
    public static void close(Closeable closeable, String name) {
        close(closeable, name, LOG);
    }

    /**
     * Closes the given resource if it is available.
     *
     * @param closeable the object to close
     */
    public static void close(Closeable closeable) {
        close(closeable, null, LOG);
    }

    /**
     * Closes the given resources if they are available.
     *
     * @param closeables the objects to close
     */
    public static void close(Closeable... closeables) {
        for (Closeable closeable : closeables) {
            close(closeable);
        }
    }

    public static void closeIterator(Object it) throws IOException {
        if (it instanceof Closeable closeable) {
            IOHelper.closeWithException(closeable);
        }
        if (it instanceof java.util.Scanner scanner) {
            IOException ioException = scanner.ioException();
            if (ioException != null) {
                throw ioException;
            }
        }
    }

    public static void validateCharset(String charset) throws UnsupportedCharsetException {
        if (charset != null) {
            if (Charset.isSupported(charset)) {
                Charset.forName(charset);
                return;
            }
        }
        throw new UnsupportedCharsetException(charset);
    }

    /**
     * Loads the entire stream into memory as a String and returns it.
     * <p/>
     * <b>Notice:</b> This implementation appends a <tt>\n</tt> as line terminator at the of the text.
     * <p/>
     * Warning, don't use for crazy big streams :)
     */
    public static String loadText(InputStream in) throws IOException {
        StringBuilder builder = new StringBuilder(2048);
        InputStreamReader isr = new InputStreamReader(in);
        try {
            BufferedReader reader = buffered(isr);
            while (true) {
                String line = reader.readLine();
                if (line != null) {
                    builder.append(line);
                    builder.append("\n");
                } else {
                    break;
                }
            }
            return builder.toString();
        } finally {
            close(isr, in);
        }
    }

    /**
     * Loads the entire stream into memory as a String and returns the given line number.
     * <p/>
     * Warning, don't use for crazy big streams :)
     */
    public static String loadTextLine(InputStream in, int lineNumber) throws IOException {
        int i = 0;
        InputStreamReader isr = new InputStreamReader(in);
        try {
            BufferedReader reader = buffered(isr);
            while (true) {
                String line = reader.readLine();
                if (line != null) {
                    i++;
                    if (i >= lineNumber) {
                        return line;
                    }
                } else {
                    break;
                }
            }
        } finally {
            close(isr, in);
        }

        return null;
    }

    /**
     * Appends the text to the file.
     */
    public static void appendText(String text, File file) throws IOException {
        doWriteText(text, file, true);
    }

    /**
     * Writes the text to the file.
     */
    public static void writeText(String text, File file) throws IOException {
        doWriteText(text, file, false);
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    private static void doWriteText(String text, File file, boolean append) throws IOException {
        if (!file.exists()) {
            String path = FileUtil.onlyPath(file.getPath());
            if (path != null) {
                new File(path).mkdirs();
            }
        }
        writeText(text, new FileOutputStream(file, append));
    }

    /**
     * Writes the text to the stream.
     */
    public static void writeText(String text, OutputStream os) throws IOException {
        try {
            os.write(text.getBytes());
        } finally {
            close(os);
        }
    }

    /**
     * Get the charset name from the content type string
     *
     * @param  contentType the content type
     * @return             the charset name, or <tt>UTF-8</tt> if no found
     */
    public static String getCharsetNameFromContentType(String contentType) {
        // try optimized for direct match without using splitting
        int pos = contentType.indexOf("charset=");
        if (pos != -1) {
            // special optimization for utf-8 which is a common charset
            if (contentType.regionMatches(true, pos + 8, "utf-8", 0, 5)) {
                return "UTF-8";
            }

            int end = contentType.indexOf(';', pos);
            String charset;
            if (end > pos) {
                charset = contentType.substring(pos + 8, end);
            } else {
                charset = contentType.substring(pos + 8);
            }
            return normalizeCharset(charset);
        }

        String[] values = contentType.split(";");
        for (String value : values) {
            value = value.trim();
            // Perform a case insensitive "startsWith" check that works for different locales
            String prefix = "charset=";
            if (value.regionMatches(true, 0, prefix, 0, prefix.length())) {
                // Take the charset name
                String charset = value.substring(8);
                return normalizeCharset(charset);
            }
        }
        // use UTF-8 as default
        return "UTF-8";
    }

    /**
     * This method will take off the quotes and double quotes of the charset
     */
    public static String normalizeCharset(String charset) {
        if (charset != null) {
            boolean trim = false;
            String answer = charset.trim();
            if (answer.startsWith("'") || answer.startsWith("\"")) {
                answer = answer.substring(1);
                trim = true;
            }
            if (answer.endsWith("'") || answer.endsWith("\"")) {
                answer = answer.substring(0, answer.length() - 1);
                trim = true;
            }
            return trim ? answer.trim() : answer;
        } else {
            return null;
        }
    }

    /**
     * Lookup the OS environment variable in a safe manner by using upper case keys and underscore instead of dash.
     *
     * At first lookup attempt is made without considering camelCase keys. The second lookup is converting camelCase to
     * underscores.
     *
     * For example given an ENV variable in either format: - CAMEL_KAMELET_AWS_S3_SOURCE_BUCKETNAMEORARN=myArn -
     * CAMEL_KAMELET_AWS_S3_SOURCE_BUCKET_NAME_OR_ARN=myArn
     *
     * Then the following keys can look up both ENV formats above: - camel.kamelet.awsS3Source.bucketNameOrArn -
     * camel.kamelet.aws-s3-source.bucketNameOrArn - camel.kamelet.aws-s3-source.bucket-name-or-arn
     */
    public static String lookupEnvironmentVariable(String key) {
        // lookup OS env with upper case key
        String upperKey = key.toUpperCase();
        String value = System.getenv(upperKey);

        if (value == null) {
            value = System.getenv(normalizeEnvironmentVariable(upperKey));
        }
        if (value == null) {
            // camelCase keys should use underscore as separator
            String caseKey = StringHelper.camelCaseToDash(key);
            value = System.getenv(normalizeEnvironmentVariable(caseKey));
        }
        return value;
    }

    /**
     * Convert given key into an OS environment variable. Uses uppercase keys and converts dashes and dots to
     * underscores.
     */
    public static String normalizeEnvironmentVariable(String key) {
        String upperKey = key.toUpperCase();
        // some OS do not support dashes in keys, so replace with underscore
        String normalizedKey = upperKey.replace('-', '_');

        // and replace dots with underscores so keys like my.key are
        // translated to MY_KEY
        return normalizedKey.replace('.', '_');
    }

    /**
     * Encoding-aware input stream.
     */
    public static class EncodingInputStream extends InputStream {

        private final Lock lock = new ReentrantLock();
        private final Path file;
        private final BufferedReader reader;
        private final Charset defaultStreamCharset;

        private ByteBuffer bufferBytes;
        private final CharBuffer bufferedChars = CharBuffer.allocate(4096);

        public EncodingInputStream(Path file, String charset) throws IOException {
            this.file = file;
            reader = toReader(file, charset);
            defaultStreamCharset = defaultCharset.get();
        }

        @Override
        public int read() throws IOException {
            if (bufferBytes == null || bufferBytes.remaining() <= 0) {
                BufferCaster.cast(bufferedChars).clear();
                int len = reader.read(bufferedChars);
                bufferedChars.flip();
                if (len == -1) {
                    return -1;
                }
                bufferBytes = defaultStreamCharset.encode(bufferedChars);
            }
            return bufferBytes.get() & 0xFF;
        }

        @Override
        public void close() throws IOException {
            reader.close();
        }

        @Override
        public void reset() throws IOException {
            lock.lock();
            try {
                reader.reset();
            } finally {
                lock.unlock();
            }
        }

        public InputStream toOriginalInputStream() throws IOException {
            return Files.newInputStream(file);
        }
    }

    /**
     * Encoding-aware file reader.
     */
    public static class EncodingFileReader extends InputStreamReader {

        private final FileInputStream in;

        /**
         * @param in      file to read
         * @param charset character set to use
         */
        public EncodingFileReader(FileInputStream in, String charset) throws UnsupportedEncodingException {
            super(in, charset);
            this.in = in;
        }

        /**
         * @param in      file to read
         * @param charset character set to use
         */
        public EncodingFileReader(FileInputStream in, Charset charset) {
            super(in, charset);
            this.in = in;
        }

        @Override
        public void close() throws IOException {
            try {
                super.close();
            } finally {
                in.close();
            }
        }
    }

    /**
     * Encoding-aware file writer.
     */
    public static class EncodingFileWriter extends OutputStreamWriter {

        private final FileOutputStream out;

        /**
         * @param out     file to write
         * @param charset character set to use
         */
        public EncodingFileWriter(FileOutputStream out, String charset) throws UnsupportedEncodingException {
            super(out, charset);
            this.out = out;
        }

        /**
         * @param out     file to write
         * @param charset character set to use
         */
        public EncodingFileWriter(FileOutputStream out, Charset charset) {
            super(out, charset);
            this.out = out;
        }

        @Override
        public void close() throws IOException {
            try {
                super.close();
            } finally {
                out.close();
            }
        }
    }

    /**
     * Converts the given {@link File} with the given charset to {@link InputStream} with the JVM default charset
     *
     * @param  file    the file to be converted
     * @param  charset the charset the file is read with
     * @return         the input stream with the JVM default charset
     */
    public static InputStream toInputStream(File file, String charset) throws IOException {
        return toInputStream(file.toPath(), charset);
    }

    /**
     * Converts the given {@link File} with the given charset to {@link InputStream} with the JVM default charset
     *
     * @param  file    the file to be converted
     * @param  charset the charset the file is read with
     * @return         the input stream with the JVM default charset
     */
    public static InputStream toInputStream(Path file, String charset) throws IOException {
        if (charset != null) {
            return new EncodingInputStream(file, charset);
        } else {
            return buffered(Files.newInputStream(file));
        }
    }

    public static BufferedReader toReader(Path file, String charset) throws IOException {
        return toReader(file, charset != null ? Charset.forName(charset) : null);
    }

    public static BufferedReader toReader(File file, String charset) throws IOException {
        return toReader(file, charset != null ? Charset.forName(charset) : null);
    }

    public static BufferedReader toReader(File file, Charset charset) throws IOException {
        return toReader(file.toPath(), charset);
    }

    public static BufferedReader toReader(Path file, Charset charset) throws IOException {
        if (charset != null) {
            return Files.newBufferedReader(file, charset);
        } else {
            return Files.newBufferedReader(file);
        }
    }

    public static BufferedWriter toWriter(FileOutputStream os, String charset) throws IOException {
        return IOHelper.buffered(new EncodingFileWriter(os, charset));
    }

    public static BufferedWriter toWriter(FileOutputStream os, Charset charset) {
        return IOHelper.buffered(new EncodingFileWriter(os, charset));
    }

    /**
     * Reads the file under the given {@code path}, strips lines starting with {@code commentPrefix} and optionally also
     * strips blank lines (the ones for which {@link String#isBlank()} returns {@code true}. Normalizes EOL characters
     * to {@code '\n'}.
     *
     * @param  path            the path of the file to read
     * @param  commentPrefix   the leading character sequence of comment lines.
     * @param  stripBlankLines if true {@code true} the lines matching {@link String#isBlank()} will not appear in the
     *                         result
     * @return                 the filtered content of the file
     */
    public static String stripLineComments(Path path, String commentPrefix, boolean stripBlankLines) {
        StringBuilder result = new StringBuilder(2048);
        try (Stream<String> lines = Files.lines(path)) {
            lines
                    .filter(l -> !stripBlankLines || !l.isBlank())
                    .filter(line -> !line.startsWith(commentPrefix))
                    .forEach(line -> result.append(line).append('\n'));
        } catch (IOException e) {
            throw new RuntimeException("Cannot read file: " + path, e);
        }
        return result.toString();
    }

}