package co.codewizards.cloudstore.core.util.childprocess;

import static java.util.Objects.*;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

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

/**
 * Thread continuously reading from an {@link InputStream} and writing everything to an {@link OutputStream}.
 * <p>
 * While this functionality is useful for multiple purposes, we use {@code DumpStreamThread} primarily for
 * child processes. When starting another process (e.g. via the
 * {@link java.lang.ProcessBuilder ProcessBuilder}), it is necessary to read the process' output. Without
 * doing this, the child process might block forever - especially on Windows (having a very limited
 * standard-output-buffer), this is a well-known problem.
 * <p>
 * Since the main thread (invoking the child process) usually blocks and waits for the child process to
 * return (i.e. exit), dumping its standard-out and standard-error to a buffer or a log file is done on a
 * separate thread.
 * <p>
 * Please note that {@code DumpStreamThread} can automatically write everything to the log. This is done via
 * an instance of {@link LogDumpedStreamThread}.
 * @author Marco หงุ่ยตระกูล-Schulze - marco at nightlabs dot de
 */
public class DumpStreamThread extends Thread
{
        private final Logger logger = LoggerFactory.getLogger(DumpStreamThread.class);
        private final InputStream inputStream;
        private final OutputStream outputStream;
        private volatile boolean ignoreErrors = false;
        private volatile boolean forceInterrupt = false;
        private final LogDumpedStreamThread logDumpedStreamThread;

        public void setIgnoreErrors(final boolean ignoreErrors) {
                this.ignoreErrors = ignoreErrors;
        }

        @Override
        public void interrupt() {
                forceInterrupt = true;
                super.interrupt();
        }

        @Override
        public boolean isInterrupted() {
                return forceInterrupt || super.isInterrupted();
        }

        /**
         * Creates an instance of {@code DumpStreamThread}.
         * @param inputStream the stream to read from. Must not be <code>null</code>.
         * @param outputStream the stream to write to. Must not be <code>null</code>.
         * @param childProcessLoggerName the name of the logger. May be <code>null</code> if logging is not
         * desired. In case of <code>null</code>, logging is completely disabled.
         */
        public DumpStreamThread(final InputStream inputStream, final OutputStream outputStream, final String childProcessLoggerName) {
                this(inputStream, outputStream, null, childProcessLoggerName);
        }

        /**
         * Creates an instance of {@code DumpStreamThread}.
         * @param inputStream the stream to read from. Must not be <code>null</code>.
         * @param outputStream the stream to write to. Must not be <code>null</code>.
         * @param childProcessLogger the logger. May be <code>null</code> if logging is not desired.
         */
        public DumpStreamThread(final InputStream inputStream, final OutputStream outputStream, final Logger childProcessLogger) {
                this(inputStream, outputStream, childProcessLogger, null);
        }

        private DumpStreamThread(final InputStream inputStream, final OutputStream outputStream,
                        final Logger childProcessLogger, final String childProcessLoggerName)
        {
                requireNonNull(inputStream, "inputStream");
                requireNonNull(outputStream, "outputStream");

                this.inputStream = inputStream;
                this.outputStream = outputStream;
                if (childProcessLogger != null)
                        this.logDumpedStreamThread = new LogDumpedStreamThread(childProcessLogger);
                else
                        this.logDumpedStreamThread = childProcessLoggerName == null ? null : new LogDumpedStreamThread(childProcessLoggerName);
        }

        @Override
        public synchronized void start() {
                if (logDumpedStreamThread != null)
                        logDumpedStreamThread.start();

                super.start();
        }

        @Override
        public void run() {
                try {
                        final byte[] buffer = new byte[10240];
                        while (!isInterrupted()) {
                                try {
                                        final int bytesRead = inputStream.read(buffer);
                                        if (bytesRead > 0) {
                                                outputStream.write(buffer, 0, bytesRead);

                                                if (logDumpedStreamThread != null)
                                                        logDumpedStreamThread.write(buffer, bytesRead);
                                        }
                                } catch (final Throwable e) {
                                        if (!ignoreErrors)
                                                logger.error("run: " + e, e); //$NON-NLS-1$
                                        else
                                                logger.info("run: " + e); //$NON-NLS-1$

                                        return;
                                }
                        }
                } finally {
                        if (logDumpedStreamThread != null)
                                logDumpedStreamThread.interrupt();

                        try {
                                outputStream.close();
                        } catch (final IOException e) {
                                logger.warn("run: outputStream.close() failed: " + e, e); //$NON-NLS-1$
                        }
                }
        }

        /**
         * Sets a {@link StringBuffer} for capturing all output.
         * <p>
         * Please note, that only data read from the stream after this was set is captured. You normally want to
         * set this {@code StringBuffer}.
         * <p>
         * This feature is only available, if logging is enabled.
         * @param outputStringBuffer the {@link StringBuffer} used for capturing. May be <code>null</code>.
         */
        public void setOutputStringBuffer(final StringBuffer outputStringBuffer) {
                if (logDumpedStreamThread == null)
                        throw new IllegalStateException("Not supported, if logging is disabled!");

                logDumpedStreamThread.setOutputStringBuffer(outputStringBuffer);
        }
        public StringBuffer getOutputStringBuffer() {
                if (logDumpedStreamThread == null)
                        throw new IllegalStateException("Not supported, if logging is disabled!");

                return logDumpedStreamThread.getOutputStringBuffer();
        }
        public void setOutputStringBufferMaxLength(final int outputStringBufferMaxLength) {
                if (logDumpedStreamThread == null)
                        throw new IllegalStateException("Not supported, if logging is disabled!");

                logDumpedStreamThread.setOutputStringBufferMaxLength(outputStringBufferMaxLength);
        }
        public int getOutputStringBufferMaxLength() {
                if (logDumpedStreamThread == null)
                        throw new IllegalStateException("Not supported, if logging is disabled!");

                return logDumpedStreamThread.getOutputStringBufferMaxLength();
        }

        public void flushBuffer() {
                if (logDumpedStreamThread != null)
                        logDumpedStreamThread.flushBuffer();
        }
}