/*

 * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.test.lib.process;

import jdk.test.lib.Asserts;

import java.io.IOException;

import java.io.PrintStream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public final class OutputAnalyzer {

    private final OutputBuffer buffer;

    /**

     * Create an OutputAnalyzer, a utility class for verifying output and exit

     * value from a Process

     *

     * @param process Process to analyze

     * @throws IOException If an I/O error occurs.

     */

    public OutputAnalyzer(Process process) throws IOException {

        buffer = OutputBuffer.of(process);

    }

    /**

     * Create an OutputAnalyzer, a utility class for verifying output

     *

     * @param buf String buffer to analyze

     */

    public OutputAnalyzer(String buf) {

        buffer = OutputBuffer.of(buf, buf);

    }

    /**

     * Create an OutputAnalyzer, a utility class for verifying output

     *

     * @param file File to analyze

     */

    public OutputAnalyzer(Path file) throws IOException {

        this(Files.readString(file));

    }

    /**

     * Create an OutputAnalyzer, a utility class for verifying output

     *

     * @param stdout stdout buffer to analyze

     * @param stderr stderr buffer to analyze

     */

    public OutputAnalyzer(String stdout, String stderr) {

        buffer = OutputBuffer.of(stdout, stderr);

    }

    /**

     * Create an OutputAnalyzer, a utility class for verifying output

     *

     * @param stdout stdout buffer to analyze

     * @param stderr stderr buffer to analyze

     * @param stderr exitValue result to analyze

     */

    public OutputAnalyzer(String stdout, String stderr, int exitValue)

    {

        buffer = OutputBuffer.of(stdout, stderr, exitValue);

    }

    /**

     * Verify that the stdout contents of output buffer is empty

     *

     * @throws RuntimeException

     *             If stdout was not empty

     */

    public OutputAnalyzer stdoutShouldBeEmpty() {

        if (!getStdout().isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stdout was not empty");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer is empty

     *

     * @throws RuntimeException

     *             If stderr was not empty

     */

    public OutputAnalyzer stderrShouldBeEmpty() {

        if (!getStderr().isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stderr was not empty");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer is empty,

     * after filtering out the Hotspot warning messages

     *

     * @throws RuntimeException

     *             If stderr was not empty

     */

    public OutputAnalyzer stderrShouldBeEmptyIgnoreVMWarnings() {

        if (!getStderr().replaceAll(jvmwarningmsg + "\\R", "").isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stderr was not empty");

        }

        return this;

    }

    /**

     * Verify that the stdout contents of output buffer is not empty

     *

     * @throws RuntimeException

     *             If stdout was empty

     */

    public OutputAnalyzer stdoutShouldNotBeEmpty() {

        if (getStdout().isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stdout was empty");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer is not empty

     *

     * @throws RuntimeException

     *             If stderr was empty

     */

    public OutputAnalyzer stderrShouldNotBeEmpty() {

        if (getStderr().isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stderr was empty");

        }

        return this;

    }

    /**

     * Verify that the stdout and stderr contents of output buffer contains the string

     *

     * @param expectedString String that buffer should contain

     * @throws RuntimeException If the string was not found

     */

    public OutputAnalyzer shouldContain(String expectedString) {

        String stdout = getStdout();

        String stderr = getStderr();

        if (!stdout.contains(expectedString) && !stderr.contains(expectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + expectedString + "' missing from stdout/stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout contents of output buffer contains the string

     *

     * @param expectedString String that buffer should contain

     * @throws RuntimeException If the string was not found

     */

    public OutputAnalyzer stdoutShouldContain(String expectedString) {

        String stdout = getStdout();

        if (!stdout.contains(expectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + expectedString + "' missing from stdout \n");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer contains the string

     *

     * @param expectedString String that buffer should contain

     * @throws RuntimeException If the string was not found

     */

    public OutputAnalyzer stderrShouldContain(String expectedString) {

        String stderr = getStderr();

        if (!stderr.contains(expectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + expectedString + "' missing from stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout and stderr contents of output buffer does not contain the string

     *

     * @param notExpectedString String that the buffer should not contain

     * @throws RuntimeException If the string was found

     */

    public OutputAnalyzer shouldNotContain(String notExpectedString) {

        String stdout = getStdout();

        String stderr = getStderr();

        if (stdout.contains(notExpectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + notExpectedString + "' found in stdout \n");

        }

        if (stderr.contains(notExpectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + notExpectedString + "' found in stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout and stderr contents of output buffer are empty

     *

     * @throws RuntimeException If the stdout and stderr are not empty

     */

    public OutputAnalyzer shouldBeEmpty() {

        String stdout = getStdout();

        String stderr = getStderr();

        if (!stdout.isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stdout was not empty");

        }

        if (!stderr.isEmpty()) {

            reportDiagnosticSummary();

            throw new RuntimeException("stderr was not empty");

        }

        return this;

    }

    /**

     * Verify that the stdout contents of output buffer does not contain the string

     *

     * @param notExpectedString String that the buffer should not contain

     * @throws RuntimeException If the string was found

     */

    public OutputAnalyzer stdoutShouldNotContain(String notExpectedString) {

        String stdout = getStdout();

        if (stdout.contains(notExpectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + notExpectedString + "' found in stdout \n");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer does not contain the string

     *

     * @param notExpectedString String that the buffer should not contain

     * @throws RuntimeException If the string was found

     */

    public OutputAnalyzer stderrShouldNotContain(String notExpectedString) {

        String stderr = getStderr();

        if (stderr.contains(notExpectedString)) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + notExpectedString + "' found in stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout and stderr contents of output buffer matches

     * the pattern

     *

     * @param regexp

     * @throws RuntimeException If the pattern was not found

     */

    public OutputAnalyzer shouldMatch(String regexp) {

        String stdout = getStdout();

        String stderr = getStderr();

        Pattern pattern = Pattern.compile(regexp, Pattern.MULTILINE);

        Matcher stdoutMatcher = pattern.matcher(stdout);

        Matcher stderrMatcher = pattern.matcher(stderr);

        if (!stdoutMatcher.find() && !stderrMatcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                  + "' missing from stdout/stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout contents of output buffer matches the

     * pattern

     *

     * @param regexp

     * @throws RuntimeException If the pattern was not found

     */

    public OutputAnalyzer stdoutShouldMatch(String regexp) {

        String stdout = getStdout();

        Matcher matcher = Pattern.compile(regexp, Pattern.MULTILINE).matcher(stdout);

        if (!matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                  + "' missing from stdout \n");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer matches the

     * pattern

     *

     * @param pattern

     * @throws RuntimeException If the pattern was not found

     */

    public OutputAnalyzer stderrShouldMatch(String pattern) {

        String stderr = getStderr();

        Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stderr);

        if (!matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + pattern

                  + "' missing from stderr \n");

        }

        return this;

    }

    /**

     * Verify that the stdout and stderr contents of output buffer does not

     * match the pattern

     *

     * @param regexp

     * @throws RuntimeException If the pattern was found

     */

    public OutputAnalyzer shouldNotMatch(String regexp) {

        String stdout = getStdout();

        Pattern pattern = Pattern.compile(regexp, Pattern.MULTILINE);

        Matcher matcher = pattern.matcher(stdout);

        if (matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                    + "' found in stdout: '" + matcher.group() + "' \n");

        }

        String stderr = getStderr();

        matcher = pattern.matcher(stderr);

        if (matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                    + "' found in stderr: '" + matcher.group() + "' \n");

        }

        return this;

    }

    /**

     * Verify that the stdout contents of output buffer does not match the

     * pattern

     *

     * @param regexp

     * @throws RuntimeException If the pattern was found

     */

    public OutputAnalyzer stdoutShouldNotMatch(String regexp) {

        String stdout = getStdout();

        Matcher matcher = Pattern.compile(regexp, Pattern.MULTILINE).matcher(stdout);

        if (matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                    + "' found in stdout \n");

        }

        return this;

    }

    /**

     * Verify that the stderr contents of output buffer does not match the

     * pattern

     *

     * @param regexp

     * @throws RuntimeException If the pattern was found

     */

    public OutputAnalyzer stderrShouldNotMatch(String regexp) {

        String stderr = getStderr();

        Matcher matcher = Pattern.compile(regexp, Pattern.MULTILINE).matcher(stderr);

        if (matcher.find()) {

            reportDiagnosticSummary();

            throw new RuntimeException("'" + regexp

                    + "' found in stderr \n");

        }

        return this;

    }

    /**

     * Get the captured group of the first string matching the pattern.

     * stderr is searched before stdout.

     *

     * @param regexp The multi-line pattern to match

     * @param group The group to capture

     * @return The matched string or null if no match was found

     */

    public String firstMatch(String regexp, int group) {

        Pattern pattern = Pattern.compile(regexp, Pattern.MULTILINE);

        String stderr = getStderr();

        Matcher stderrMatcher = pattern.matcher(stderr);

        if (stderrMatcher.find()) {

            return stderrMatcher.group(group);

        }

        String stdout = getStdout();

        Matcher stdoutMatcher = pattern.matcher(stdout);

        if (stdoutMatcher.find()) {

            return stdoutMatcher.group(group);

        }

        return null;

    }

    /**

     * Get the first string matching the pattern.

     * stderr is searched before stdout.

     *

     * @param pattern The multi-line pattern to match

     * @return The matched string or null if no match was found

     */

    public String firstMatch(String pattern) {

        return firstMatch(pattern, 0);

    }

    /**

     * Verify the exit value of the process

     *

     * @param expectedExitValue Expected exit value from process

     * @throws RuntimeException If the exit value from the process did not match the expected value

     */

    public OutputAnalyzer shouldHaveExitValue(int expectedExitValue) {

        if (getExitValue() != expectedExitValue) {

            reportDiagnosticSummary();

            throw new RuntimeException("Expected to get exit value of ["

                    + expectedExitValue + "]\n");

        }

        return this;

    }

    /**

     * Verify the exit value of the process

     *

     * @param notExpectedExitValue Unexpected exit value from process

     * @throws RuntimeException If the exit value from the process did match the expected value

     */

    public OutputAnalyzer shouldNotHaveExitValue(int notExpectedExitValue) {

        if (getExitValue() == notExpectedExitValue) {

            reportDiagnosticSummary();

            throw new RuntimeException("Unexpected to get exit value of ["

                    + notExpectedExitValue + "]\n");

        }

        return this;

    }

    /**

     * Report summary that will help to diagnose the problem

     * Currently includes:

     *  - standard input produced by the process under test

     *  - standard output

     *  - exit code

     *  Note: the command line is printed by the ProcessTools

     */

    public void reportDiagnosticSummary() {

        String msg =

            " stdout: [" + getStdout() + "];\n" +

            " stderr: [" + getStderr() + "]\n" +

            " exitValue = " + getExitValue() + "\n";

        System.err.println(msg);

    }

    /**

     * Print the stdout buffer to the given {@code PrintStream}.

     *

     * @return this OutputAnalyzer

     */

    public OutputAnalyzer outputTo(PrintStream out) {

        out.println(getStdout());

        return this;

    }