/*

 * Copyright (c) 2013, 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.

 */

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.net.URI;

import java.nio.charset.Charset;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardOpenOption;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.EnumSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.ToolProvider;

import com.sun.source.util.JavacTask;

import com.sun.tools.javac.api.JavacTaskImpl;

import sun.tools.jar.Main;

import static java.nio.file.StandardCopyOption.*;

/**

 * Toolbox for jtreg tests.

 */

public class ToolBox {

    public static final String lineSeparator = System.getProperty("line.separator");

    public static final String jdkUnderTest = System.getProperty("test.jdk");

    public static final String testVMOpts = System.getProperty("test.tool.vm.opts");

    public static final String javaBinary = Paths.get(jdkUnderTest, "bin", "java").toString();

    //why this one private. Because the function which provide also the test options should be used

    private static final String javacBinary = Paths.get(jdkUnderTest, "bin", "javac").toString();

    private static final Charset defaultCharset = Charset.defaultCharset();

    static final JavaCompiler comp = ToolProvider.getSystemJavaCompiler();

    /**

     * The expected result of command-like method execution.

     */

    public enum Expect {SUCCESS, FAIL}

    enum AcceptedParams {

        EXPECT,

        SOURCES,

        OPTIONS,

        STD_OUTPUT,

        ERR_OUTPUT,

        EXTRA_ENV,

    }

    enum OutputKind {STD, ERR}

    /**

     * Helper class to abstract the processing of command's output.

     */

    static abstract class WriterHelper {

        OutputKind kind;

        public abstract void pipeOutput(ProcessBuilder pb);

        public abstract void readFromStream(Process p) throws IOException;

        public abstract void addAll(Collection<? extends String> c) throws IOException;

    }

    /**

     * Helper class for redirecting command's output to a file.

     */

    static class FileWriterHelper extends WriterHelper {

        File file;

        FileWriterHelper(File file, OutputKind kind) {

            this.file = file;

            this.kind = kind;

        }

        @Override

        public void pipeOutput(ProcessBuilder pb) {

            if (file != null) {

                switch (kind) {

                    case STD:

                        pb.redirectInput(file);

                        break;

                    case ERR:

                        pb.redirectError(file);

                        break;

                }

            }

        }

        @Override

        public void readFromStream(Process p) throws IOException {}

        @Override

        public void addAll(Collection<? extends String> c) throws IOException {

            if (file.exists())

                Files.write(file.toPath(), c, defaultCharset,

                        StandardOpenOption.WRITE, StandardOpenOption.APPEND);

            else

                Files.write(file.toPath(), c, defaultCharset);

        }

    }

    /**

     * Helper class for redirecting command's output to a String list.

     */

    static class ListWriterHelper extends WriterHelper {

        List<String> list;

        public ListWriterHelper(List<String> list, OutputKind kind) {

            this.kind = kind;

            this.list = list;

        }

        @Override

        public void pipeOutput(ProcessBuilder pb) {}

        @Override

        public void readFromStream(Process p) throws IOException {

            BufferedReader br = null;

            switch (kind) {

                case STD:

                    br = new BufferedReader(new InputStreamReader(p.getInputStream()));

                    break;

                case ERR:

                    br = new BufferedReader(new InputStreamReader(p.getErrorStream()));

                    break;

            }

            String line;

            while ((line = br.readLine()) != null) {

                list.add(line);

            }

        }

        public void addAll(Collection<? extends String> c) {

            list.addAll(c);

        }

    }

    /**

     * Simple factory class for creating a WriterHelper instance.

     */

    static class WriterHelperFactory {

        static WriterHelper make(File file, OutputKind kind) {

            return new FileWriterHelper(file, kind);

        }

        static WriterHelper make(List<String> list, OutputKind kind) {

            return new ListWriterHelper(list, kind);

        }

    }

    /**

     * A generic class for holding command's arguments.

     */

    public static abstract class GenericArgs <T extends GenericArgs> {

        protected static List<Set<AcceptedParams>> minAcceptedParams;

        protected Set<AcceptedParams> currentParams =

                EnumSet.<AcceptedParams>noneOf(AcceptedParams.class);

        protected Expect whatToExpect;

        protected WriterHelper stdOutput;

        protected WriterHelper errOutput;

        protected List<String> options;

        protected String[] optionsArr;

        protected GenericArgs() {

            set(Expect.SUCCESS);

        }

        public T set(Expect whatToExpt) {

            currentParams.add(AcceptedParams.EXPECT);

            this.whatToExpect = whatToExpt;

            return (T)this;

        }

        public T setStdOutput(List<String> stdOutput) {

            currentParams.add(AcceptedParams.STD_OUTPUT);

            this.stdOutput = WriterHelperFactory.make(stdOutput, OutputKind.STD);

            return (T)this;

        }

        public T setStdOutput(File output) {

            currentParams.add(AcceptedParams.STD_OUTPUT);

            this.stdOutput = WriterHelperFactory.make(output, OutputKind.STD);

            return (T)this;

        }

        public T setErrOutput(List<String> errOutput) {

            currentParams.add(AcceptedParams.ERR_OUTPUT);

            this.errOutput = WriterHelperFactory.make(errOutput, OutputKind.ERR);

            return (T)this;

        }

        public T setErrOutput(File errOutput) {

            currentParams.add(AcceptedParams.ERR_OUTPUT);

            this.errOutput = WriterHelperFactory.make(errOutput, OutputKind.ERR);

            return (T)this;

        }

        public T setAllArgs(String... args) {

            currentParams.add(AcceptedParams.OPTIONS);

            this.optionsArr = args;

            return (T)this;

        }

        public T setOptions(List<String> options) {

            currentParams.add(AcceptedParams.OPTIONS);

            this.options = options;

            return (T)this;

        }

        public T setOptions(String... options) {

            currentParams.add(AcceptedParams.OPTIONS);

            this.options = Arrays.asList(options);

            return (T)this;

        }

        public boolean hasMinParams() {

            for (Set<AcceptedParams> minSet : minAcceptedParams) {

                if (currentParams.containsAll(minSet)) {

                    return true;

                }

            }

            return false;

        }

    }

    /**

     * A more specific class for holding javac-like command's arguments.

     */

    public static class JavaToolArgs extends GenericArgs<JavaToolArgs> {

        static {

            minAcceptedParams = new ArrayList<>();

            minAcceptedParams.add(EnumSet.<AcceptedParams>of(

                    AcceptedParams.EXPECT, AcceptedParams.OPTIONS));

            minAcceptedParams.add(EnumSet.<AcceptedParams>of(

                    AcceptedParams.EXPECT, AcceptedParams.SOURCES));

        }

        protected List<? extends JavaFileObject> sources;

        public JavaToolArgs() {

            super();

        }

        public JavaToolArgs(Expect whatToExpt) {

            super.set(whatToExpt);

        }

        public JavaToolArgs setSources(List<? extends JavaFileObject> sources) {

            currentParams.add(AcceptedParams.SOURCES);

            this.sources = sources;

            return this;

        }

        public JavaToolArgs setSources(JavaSource... sources) {

            return setSources(Arrays.asList(sources));

        }

        public JavaToolArgs setSources(String... sources) {

            List<JavaSource> javaSrcs = new ArrayList<>();

            for (String source : sources) {

                javaSrcs.add(new JavaSource(source));

            }

            return setSources(javaSrcs);

        }

    }

    /**

     * A more specific class for holding any command's arguments.

     */

    public static class AnyToolArgs extends GenericArgs<AnyToolArgs> {

        static {

            minAcceptedParams = new ArrayList<>();

            minAcceptedParams.add(EnumSet.<AcceptedParams>of(

                    AcceptedParams.EXPECT, AcceptedParams.OPTIONS));

        }

        Map<String, String> extraEnv;

        public AnyToolArgs() {

            super();

        }

        public AnyToolArgs(Expect whatToExpt) {

            set(whatToExpt);

        }

        public AnyToolArgs set(Map<String, String> extraEnv) {

            currentParams.add(AcceptedParams.EXTRA_ENV);

            this.extraEnv = extraEnv;

            return this;

        }

    }

    /**

     * Custom exception for bad command execution.

     */

    public static class CommandExecutionException extends Exception {

        CommandExecutionException(List<String> command, Expect whatToExpt) {

            super(createMessage(command, whatToExpt));

        }

        CommandExecutionException(Expect whatToExpt, String... command) {

            this(Arrays.asList(command), whatToExpt);

        }

        private static String createMessage(List<String> command, Expect whatToExpt) {

            StringBuilder sb = new StringBuilder().append("Command : ");

            sb.append(command.toString()).append(lineSeparator);

            switch (whatToExpt) {

                case SUCCESS:

                    sb.append("    has unexpectedly failed");

                    break;

                case FAIL:

                    sb.append("    has been unexpectedly successful");

                    break;

            }

            return sb.toString();

        }

    }

    /**

     * Custom exception for not equal resources.

     */

    public static class ResourcesNotEqualException extends Exception {

        public ResourcesNotEqualException() {

            super("The resources provided for comparison are different");

        }

        public ResourcesNotEqualException(Path path1, Path path2) {

            super(createMessage(path1, path2));

        }

        private static String createMessage(Path path1, Path path2) {

            return new StringBuilder()

                    .append("The resources provided for comparison in paths \n")

                    .append(path1.toString()).append(" and \n")

                    .append(path2.toString()).append("are different").toString();

        }

    }

    /**

     * Method to get the a path to the javac command available at the jdk being

     * tested along with the test vm options.

     * @return a String[] with the two components mentioned.

     */

    public static String[] getJavacBin() {

        return new String[]{javacBinary, testVMOpts};

    }

    /**

     * A javac compiler caller method.

     */

    public static int javac(JavaToolArgs params)

            throws CommandExecutionException, IOException {

        if (params.hasMinParams()) {

            if (params.optionsArr != null) {

                return genericJavaCMD(JavaCMD.JAVAC, params);

            } else {

                return genericJavaCMD(JavaCMD.JAVAC_API, params);

            }

        }

        throw new AssertionError("javac command has been invoked with less parameters than needed");

    }

    /**

     * A javap calling method.

     */

    public static String javap(JavaToolArgs params)

            throws CommandExecutionException, IOException {

        if (params.hasMinParams()) {

            List<String> list = new ArrayList<>();

            params.setErrOutput(list);

            genericJavaCMD(JavaCMD.JAVAP, params);

            return listToString(list);

        }

        throw new AssertionError("javap command has been invoked with less parameters than needed");

    }

    /**

     * A javah calling method.

     */

    public static int javah(JavaToolArgs params)

            throws CommandExecutionException, IOException {

        if (params.hasMinParams()) {

            return genericJavaCMD(JavaCMD.JAVAH, params);

        }

        throw new AssertionError("javah command has been invoked with less parameters than needed");

    }

    /**

     * A enum class for langtools commands.

     */

    enum JavaCMD {

        JAVAC {

            @Override

            int run(JavaToolArgs params, PrintWriter pw) {

                return com.sun.tools.javac.Main.compile(params.optionsArr, pw);

            }

        },

        JAVAC_API {

            @Override

            int run(JavaToolArgs params, PrintWriter pw) {

                JavacTask ct = (JavacTask)comp.getTask(pw, null, null,

                        params.options, null, params.sources);

                return ((JavacTaskImpl)ct).doCall().exitCode;

            }

            @Override

            String getName() {

                return "javac";

            }

            @Override

            List<String> getExceptionMsgContent(JavaToolArgs params) {

                List<String> result = super.getExceptionMsgContent(params);

                for (JavaFileObject source : params.sources) {

                    if (source instanceof JavaSource) {

                        result.add(((JavaSource)source).name);

                    }

                }

                return result;

            }

        },

        JAVAH {

            @Override

            int run(JavaToolArgs params, PrintWriter pw) {

                return com.sun.tools.javah.Main.run(params.optionsArr, pw);

            }

        },

        JAVAP {

            @Override

            int run(JavaToolArgs params, PrintWriter pw) {

                return com.sun.tools.javap.Main.run(params.optionsArr, pw);

            }

        };

        abstract int run(JavaToolArgs params, PrintWriter pw);

        String getName() {

            return this.name().toLowerCase();

        }

        List<String> getExceptionMsgContent(JavaToolArgs params) {

            List<String> result = new ArrayList<>();

            result.add(getName());

            result.addAll(params.optionsArr != null ?

                    Arrays.asList(params.optionsArr) :

                    params.options);

            return result;

        }

    }

    /**

     * A helper method for executing langtools commands.

     */

    private static int genericJavaCMD(

            JavaCMD cmd,

            JavaToolArgs params)

            throws CommandExecutionException, IOException {

        int rc = 0;

        StringWriter sw = null;

        try (PrintWriter pw = (params.errOutput == null) ?

                null : new PrintWriter(sw = new StringWriter())) {

            rc = cmd.run(params, pw);

        }

        String out = (sw == null) ? null : sw.toString();

        if (params.errOutput != null && (out != null) && !out.isEmpty()) {

            params.errOutput.addAll(splitLines(out));

        }

        if ( (rc == 0 && params.whatToExpect == Expect.SUCCESS) ||

             (rc != 0 && params.whatToExpect == Expect.FAIL) ) {

            return rc;

        }

        throw new CommandExecutionException(cmd.getExceptionMsgContent(params),

                params.whatToExpect);

    }

    /**

     * A jar calling method.

     */

    public static boolean jar(String... params) throws CommandExecutionException {

        Main jarGenerator = new Main(System.out, System.err, "jar");

        boolean result = jarGenerator.run(params);