/*
 * Copyright (c) 2015, 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.IOException;
import java.io.OutputStream;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;
import java.util.StringJoiner;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.lang.module.ModuleDescriptor;
import jdk.testlibrary.OutputAnalyzer;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import jdk.internal.module.ModuleInfoWriter;
import static java.lang.module.ModuleDescriptor.Builder;

/**
 * Base class need to be extended by modular test for security.
 */
public abstract class ModularTest {

    /**
     * Enum represents all supported module types supported in JDK9. i.e.
     * EXPLICIT - Modules have module descriptor(module-info.java)
     * defining the module.
     * AUTO - Are regular jar files but provided in MODULE_PATH instead
     * of CLASS_PATH.
     * UNNAMED - Are regular jar but provided through CLASS_PATH.
     */
    public enum MODULE_TYPE {

        EXPLICIT, AUTO, UNNAMED;
    }

    public static final String SPACE = " ";
    public static final Path SRC = Paths.get(System.getProperty("test.src"));
    public static final String DESCRIPTOR = "MetaService";
    public static final String MODULAR = "Modular";
    public static final String AUTO = "AutoServiceType";
    public static final String JAR_EXTN = ".jar";

    /**
     * Setup test data for the test.
     */
    @DataProvider(name = "TestParams")
    public Object[][] setUpTestData() {
        return getTestInput();
    }

    /**
     * Test method for TestNG.
     */
    @Test(dataProvider = "TestParams")
    public void runTest(MODULE_TYPE cModuleType, MODULE_TYPE sModuletype,
            boolean addMetaDesc, String failureMsgExpected, String[] args)
            throws Exception {

        String testName = new StringJoiner("_").add(cModuleType.toString())
                .add(sModuletype.toString()).add(
                        (addMetaDesc) ? "WITH_SERVICE" : "NO_SERVICE")
                .toString();

        System.out.format("%nStarting Test case: '%s'", testName);
        Path cJarPath = findJarPath(false, cModuleType, false,
                (sModuletype == MODULE_TYPE.EXPLICIT));
        Path sJarPath = findJarPath(true, sModuletype, addMetaDesc, false);
        System.out.format("%nClient jar path : %s ", cJarPath);
        System.out.format("%nService jar path : %s ", sJarPath);
        OutputAnalyzer output = executeTestClient(cModuleType, cJarPath,
                sModuletype, sJarPath, args);

        if (output.getExitValue() != 0) {
            if (failureMsgExpected != null
                    && output.getOutput().contains(failureMsgExpected)) {
                System.out.println("PASS: Test is expected to fail here.");
            } else {
                System.out.format("%nUnexpected failure occured with exit code"
                        + " '%s'.", output.getExitValue());
                throw new RuntimeException("Unexpected failure occured.");
            }
        }
    }

    /**
     * Abstract method need to be implemented by each Test type to provide
     * test parameters.
     */
    public abstract Object[][] getTestInput();

    /**
     * Execute the test client to access required service.
     */
    public abstract OutputAnalyzer executeTestClient(MODULE_TYPE cModuleType,
            Path cJarPath, MODULE_TYPE sModuletype, Path sJarPath,
            String... args) throws Exception;

    /**
     * Find the Jar for service/client based on module type and if service
     * descriptor required.
     */
    public abstract Path findJarPath(boolean service, MODULE_TYPE moduleType,
            boolean addMetaDesc, boolean dependsOnServiceModule);

    /**
     * Constructs a Java Command line string based on modular structure followed
     * by modular client and service.
     */
    public String[] getJavaCommand(Path modulePath, String classPath,
            String clientModuleName, String mainClass,
            Map<String, String> vmArgs, String... options) throws IOException {

        final StringJoiner command = new StringJoiner(SPACE, SPACE, SPACE);
        vmArgs.forEach((key, value) -> command.add(key + value));
        if (modulePath != null) {
            command.add("--module-path").add(modulePath.toFile().getCanonicalPath());
        }
        if (classPath != null && classPath.length() > 0) {
            command.add("-cp").add(classPath);
        }
        if (clientModuleName != null && clientModuleName.length() > 0) {
            command.add("-m").add(clientModuleName + "/" + mainClass);
        } else {
            command.add(mainClass);
        }
        command.add(Arrays.stream(options).collect(Collectors.joining(SPACE)));
        return command.toString().trim().split("[\\s]+");
    }

    /**
     * Generate ModuleDescriptor object for explicit/auto based client/Service
     * modules type.
     */
    public ModuleDescriptor generateModuleDescriptor(boolean isService,
            MODULE_TYPE moduleType, String moduleName, String pkg,
            String serviceInterface, String serviceImpl,
            String serviceModuleName, List<String> requiredModules,
            boolean depends) {

        final Builder builder;
        if (moduleType == MODULE_TYPE.EXPLICIT) {
            System.out.format(" %nGenerating ModuleDescriptor object");
            builder = new Builder(moduleName).exports(pkg);
            if (isService && serviceInterface != null && serviceImpl != null) {
                builder.provides(serviceInterface, serviceImpl);
            } else {
                if (serviceInterface != null) {
                    builder.uses(serviceInterface);
                }
                if (depends) {
                    builder.requires(serviceModuleName);
                }
            }
        } else {
            System.out.format(" %nModuleDescriptor object not required.");
            return null;
        }
        requiredModules.stream().forEach(reqMod -> builder.requires(reqMod));
        return builder.build();
    }

    /**
     * Generates service descriptor inside META-INF folder.
     */
    public boolean createMetaInfServiceDescriptor(
            Path serviceDescriptorFile, String serviceImpl) {
        boolean created = true;
        System.out.format("%nCreating META-INF service descriptor for '%s' "
                + "at path '%s'", serviceImpl, serviceDescriptorFile);
        try {
            Path parent = serviceDescriptorFile.getParent();
            if (parent != null) {
                Files.createDirectories(parent);
            }
            Files.write(serviceDescriptorFile, serviceImpl.getBytes("UTF-8"));
            System.out.println(
                    "META-INF service descriptor generated successfully");
        } catch (IOException e) {
            e.printStackTrace(System.out);
            created = false;
        }
        return created;
    }

    /**
     * Generate modular/regular jar file.
     */
    public void generateJar(ModuleDescriptor mDescriptor, Path jar,
            Path compilePath) throws IOException {
        System.out.format("%nCreating jar file '%s'", jar);
        JarUtils.createJarFile(jar, compilePath);
        if (mDescriptor != null) {
            Path dir = Files.createTempDirectory("tmp");
            Path mi = dir.resolve("module-info.class");
            try (OutputStream out = Files.newOutputStream(mi)) {
                ModuleInfoWriter.write(mDescriptor, out);
            }
            System.out.format("%nAdding 'module-info.class' to jar '%s'", jar);
            JarUtils.updateJarFile(jar, dir);
        }
    }

    /**
     * Copy pre-generated jar files to the module base path.
     */
    public void copyJarsToModuleBase(MODULE_TYPE moduleType, Path jar,
            Path mBasePath) throws IOException {
        if (mBasePath != null) {
            Files.createDirectories(mBasePath);
        }
        if (moduleType != MODULE_TYPE.UNNAMED) {
            Path artifactName = mBasePath.resolve(jar.getFileName());
            System.out.format("%nCopy jar path: '%s' to module base path: %s",
                    jar, artifactName);
            Files.copy(jar, artifactName);
        }
    }

    /**
     * Construct class path string.
     */
    public String buildClassPath(MODULE_TYPE cModuleType,
            Path cJarPath, MODULE_TYPE sModuletype,
            Path sJarPath) throws IOException {
        StringJoiner classPath = new StringJoiner(File.pathSeparator);
        classPath.add((cModuleType == MODULE_TYPE.UNNAMED)
                ? cJarPath.toFile().getCanonicalPath() : "");
        classPath.add((sModuletype == MODULE_TYPE.UNNAMED)
                ? sJarPath.toFile().getCanonicalPath() : "");
        return classPath.toString();
    }

    /**
     * Construct executable module name for java. It is fixed for explicit
     * module type while it is same as jar file name for automated module type.
     */
    public String getModuleName(MODULE_TYPE moduleType,
            Path jarPath, String mName) {
        String jarName = jarPath.toFile().getName();
        return (moduleType == MODULE_TYPE.EXPLICIT) ? mName
                : ((moduleType == MODULE_TYPE.AUTO) ? jarName.substring(0,
                                jarName.indexOf(JAR_EXTN)) : null);
    }

    /**
     * Delete all the files inside the base module path.
     */
    public void cleanModuleBasePath(Path mBasePath) {
        Arrays.asList(mBasePath.toFile().listFiles()).forEach(f -> {
            System.out.println("delete: " + f);
            f.delete();
        });
    }

}