/*

 * 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.Collections;

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 Path javaBinary = Paths.get(jdkUnderTest, "bin", "java");

    public static final Path javacBinary = Paths.get(jdkUnderTest, "bin", "javac");

    public static final List<String> testVMOpts = readOptions("test.vm.opts");

    public static final List<String> testToolVMOpts = readOptions("test.tool.vm.opts");

    public static final List<String> testJavaOpts = readOptions("test.java.opts");

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

    static final JavaCompiler comp = ToolProvider.getSystemJavaCompiler();

    private static List<String> readOptions(String property) {

        String options = System.getProperty(property, "");

        return options.length() > 0 ? Arrays.asList(options.split("\\s+")) : Collections.<String>emptyList();

    }

    /**

     * 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> args = new ArrayList<>();

        protected String[] argsArr;

        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.argsArr = args;

            return (T) this;

        }

        public T appendArgs(String... args) {

            appendArgs(Arrays.asList(args));

            return (T)this;

        }

        public T appendArgs(Path... args) {

            if (args != null) {

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

                for (int i = 0; i < args.length; i++) {

                    if (args[i] != null) {

                        list.add(args[i].toString());

                    }

                }

                appendArgs(list);

            }

            return (T)this;

        }

        public T appendArgs(List<String> args) {

            if (args != null && args.size() > 0) {

                currentParams.add(AcceptedParams.OPTIONS);

                for (int i = 0; i < args.size(); i++) {

                    if (args.get(i) != null) {

                        this.args.add(args.get(i));

                    }

                }

            }

            return (T)this;

        }

        public T setOptions(List<String> options) {

            currentParams.add(AcceptedParams.OPTIONS);

            this.args = options;

            return (T)this;

        }

        public T setOptions(String... options) {

            currentParams.add(AcceptedParams.OPTIONS);

            this.args = 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(List<String> res1, List<String> res2) {

            super(createMessage(res1, res2));

        }

        public ResourcesNotEqualException(String line1, String line2) {

            super(createMessage(line1, line2));

        }

        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();

        }

        private static String createMessage(String line1, String line2) {

            return new StringBuilder()

                    .append("The resources provided for comparison are different at lines: \n")

                    .append(line1).append(" and \n")

                    .append(line2).toString();

        }

        private static String createMessage(List<String> res1, List<String> res2) {

            return new StringBuilder()

                    .append("The resources provided for comparison are different: \n")

                    .append("Resource 1 is: ").append(res1).append("\n and \n")

                    .append("Resource 2 is: ").append(res2).append("\n").toString();

        }

    }

    /**

     * A javac compiler caller method.

     */

    public static int javac(JavaToolArgs params)

            throws CommandExecutionException, IOException {

        if (params.hasMinParams()) {

            if (params.argsArr != 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");

    }