/*
 * Copyright (c) 2018, 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 compiler.graalunit.common;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.nio.file.*;
import java.util.stream.Collectors;

import jdk.test.lib.process.OutputAnalyzer;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.JDKToolFinder;

/*
 * This is helper class used to run Graal unit tests.
 * It accepts two arguments:
 *  -prefix TEST_PREFIX_TO_DEFINE_SET_OF_TESTS_TO_RUN (Ex: -prefix org.graalvm.compiler.api.test)
 *  -exclude EXCLUDED_TESTS_FILE_NAME
 */
public class GraalUnitTestLauncher {

    static final String MXTOOL_JARFILE = "com.oracle.mxtool.junit.jar";
    static final String GRAAL_UNITTESTS_JARFILE = "jdk.vm.compiler.tests.jar";

    static final String[] GRAAL_EXTRA_JARS = {"junit-4.12.jar", "asm-5.0.4.jar", "asm-tree-5.0.4.jar",
                                              "hamcrest-core-1.3.jar", "java-allocation-instrumenter.jar"};

    static final String GENERATED_TESTCLASSES_FILENAME = "list.testclasses";

    // Library dir used to find Graal specific jar files.
    static String libsDir;
    static {
        libsDir = System.getProperty("graalunit.libs");
        if (libsDir == null || libsDir.isEmpty()) {
            libsDir = System.getenv("TEST_IMAGE_GRAAL_DIR");
        }

        if (libsDir == null || libsDir.isEmpty())
            throw new RuntimeException("ERROR: Graal library directory is not specified, use -Dgraalunit.libs or TEST_IMAGE_GRAAL_DIR environment variable.");

        System.out.println("INFO: graal libs dir is '" + libsDir + "'");
    }

    /*
     * Generates --add-exports <module>/<package>=<target-module> flags and
     * returns them as array list.
     *
     * @param moduleName
     *        Name of the module to update export data
     *
     * @param targetModule
     *        Name of the module to whom to export
     */
    static ArrayList<String> getModuleExports(String moduleName, String targetModule) {
        ArrayList<String> exports = new ArrayList<String>();

        Optional<Module> mod = ModuleLayer.boot().findModule(moduleName);
        Set<String> packages;
        if (mod.isPresent()) {
            packages = mod.get().getPackages();

            for (String pName : packages) {
                exports.add("--add-exports");
                exports.add(moduleName + "/" + pName + "=" + targetModule);
            }
        }

        return exports;
    }

    /*
     * Return list of tests which match specified prefix
     *
     * @param testPrefix
     *        String prefix to select tests
     */
    static ArrayList<String> getListOfTestsByPrefix(String testPrefix, Set<String> excludeTests) throws Exception {
        ArrayList<String> classes = new ArrayList<String>();

        final String testAnnotationName = "@Test";

        // return empty list in case no selection prefix specified
        if (testPrefix == null || testPrefix.isEmpty())
            return classes;

        // replace "." by "\." in test pattern
        testPrefix = testPrefix.replaceAll("\\.", "\\\\.") + ".*";
        System.out.println("INFO: use following pattern to find tests: " + testPrefix);

        String graalUnitTestFilePath = String.join(File.separator, libsDir, GRAAL_UNITTESTS_JARFILE);
        String classPath = String.join(File.pathSeparator, System.getProperty("java.class.path"),
                String.join(File.separator, libsDir, MXTOOL_JARFILE));

        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(false,
                "-cp",  classPath,
                "com.oracle.mxtool.junit.FindClassesByAnnotatedMethods", graalUnitTestFilePath, testAnnotationName);

        System.out.println("INFO: run command " + String.join(" ", pb.command()));

        OutputAnalyzer out = new OutputAnalyzer(pb.start());
        int exitCode = out.getExitValue();
        if (exitCode != 0) {
            throw new Exception("Failed to find tests, VM crashed with exit code " + exitCode);
        }

        String outStr = out.getOutput().trim();
        System.out.println("INFO: command output: [" + outStr + "]");

        String[] lines = outStr.split(" ");
        Arrays.sort(lines);

        if (lines.length > 1) { // first line contains jar file name
            for (int i = 1; i < lines.length; i++) {
                String className = lines[i];

                if (testPrefix.equals(".*") || className.matches(testPrefix)) {
                    // add the test only in case it is not in exclude list
                    if (excludeTests!= null && excludeTests.contains(className)) {
                        System.out.println("INFO: excluded test: " + className);
                    } else {
                        classes.add(className);
                    }
                }
            }
        }

        return classes;
    }

    /*
     * Return set of excluded tests
     *
     * @param excludeFileName
     *        Name of the file to read excluded test list
     */
    static Set loadExcludeList(String excludeFileName) {
        Set<String> excludeTests;

        Path excludeFilePath = Paths.get(excludeFileName);
        try {
            excludeTests = Files.readAllLines(excludeFilePath).stream()
                    .filter(l -> !l.trim().isEmpty())
                    .filter(l -> !l.trim().startsWith("#"))
                    .map(l -> l.split(" ")[0])
                    .collect(Collectors.toSet());

        } catch (IOException ioe) {
            throw new Error("TESTBUG: failed to read " + excludeFilePath);
        }

        return excludeTests;
    }

    static String getUsageString() {
        return "Usage: " + GraalUnitTestLauncher.class.getName() + " " +
                "-prefix (org.graalvm.compiler.api.test) " +
                "-exclude <ExcludedTestsFileName>" + System.lineSeparator();
    }

    public static void main(String... args) throws Exception {

        String testPrefix = null;
        String excludeFileName = null;

        int i=0;
        String arg, val;
        while (i+1 < args.length) {
            arg = args[i++];
            val = args[i++];

            switch (arg) {
                case "-prefix":
                    testPrefix = val;
                    break;

                case "-exclude":
                    excludeFileName = val;
                    break;

                default:
                    System.out.println("WARN: illegal option " + arg);
                    break;
            }
        }

        if (testPrefix == null)
            throw new Error("TESTBUG: no tests to run specified." + System.lineSeparator() + getUsageString());


        Set<String> excludeTests = null;
        if (excludeFileName != null) {
            excludeTests = loadExcludeList(excludeFileName);
        }

        // Find list of tests which match provided predicate and write into GENERATED_TESTCLASSES_FILENAME file
        ArrayList<String> tests = getListOfTestsByPrefix(testPrefix, excludeTests);
        if (tests.size() > 0) {
            Files.write(Paths.get(GENERATED_TESTCLASSES_FILENAME), String.join(System.lineSeparator(), tests).getBytes());
        } else {
            throw new Error("TESTBUG: no tests found for prefix " + testPrefix);
        }

        ArrayList<String> javaFlags = new ArrayList<String>();

        // add modules and exports
        javaFlags.add("--add-modules");
        javaFlags.add("jdk.internal.vm.compiler,jdk.internal.vm.ci");
        javaFlags.add("--add-exports");
        javaFlags.add("java.base/jdk.internal.module=ALL-UNNAMED");
        javaFlags.addAll(getModuleExports("jdk.internal.vm.compiler", "ALL-UNNAMED"));
        javaFlags.addAll(getModuleExports("jdk.internal.vm.ci", "ALL-UNNAMED,jdk.internal.vm.compiler"));


        // add VM flags
        javaFlags.add("-XX:+UnlockExperimentalVMOptions");
        javaFlags.add("-XX:+EnableJVMCI");
        javaFlags.add("-Djava.awt.headless=true");
        javaFlags.add("-esa");
        javaFlags.add("-ea");
        // Make sure exception message is never null
        javaFlags.add("-XX:-OmitStackTraceInFastThrow");
        // set timeout factor based on jtreg harness settings
        javaFlags.add("-Dgraaltest.timeout.factor=" + System.getProperty("test.timeout.factor", "1.0"));

        // generate class path
        ArrayList<String> graalJars = new ArrayList<String>(Arrays.asList(GRAAL_EXTRA_JARS));
        graalJars.add(MXTOOL_JARFILE);
        graalJars.add(GRAAL_UNITTESTS_JARFILE);

        String graalJarsCP = graalJars.stream()
                                      .map(s -> String.join(File.separator, libsDir, s))
                                      .collect(Collectors.joining(File.pathSeparator));

        javaFlags.add("-cp");
        // Existing classpath returned by System.getProperty("java.class.path") may contain another
        // version of junit with which the jtreg tool is built. It may be incompatible with required
        // junit version. So we put graalJarsCP before existing classpath when generating a new one
        // to avoid incompatibility issues.
        javaFlags.add(String.join(File.pathSeparator, graalJarsCP, System.getProperty("java.class.path")));

        //
        javaFlags.add("com.oracle.mxtool.junit.MxJUnitWrapper");
        javaFlags.add("-JUnitVerbose");
        javaFlags.add("-JUnitEagerStackTrace");
        javaFlags.add("-JUnitEnableTiming");

        javaFlags.add("@"+GENERATED_TESTCLASSES_FILENAME);

        ProcessBuilder javaPB = ProcessTools.createJavaProcessBuilder(true,
                javaFlags.toArray(new String[javaFlags.size()]));

        // Some tests rely on MX_SUBPROCESS_COMMAND_FILE env variable which contains
        // name of the file with java executable and java args used to launch the current process.
        Path cmdFile = Files.createTempFile(Path.of(""), "mx_subprocess_", ".cmd");
        Files.write(cmdFile, javaPB.command());
        javaPB.environment().put("MX_SUBPROCESS_COMMAND_FILE", cmdFile.toAbsolutePath().toString());

        System.out.println("INFO: run command: " + String.join(" ", javaPB.command()));

        OutputAnalyzer outputAnalyzer = new OutputAnalyzer(javaPB.start());
        System.out.println("INFO: execution result: " + outputAnalyzer.getOutput());
        outputAnalyzer.shouldHaveExitValue(0);
    }
}