/*

 * Copyright (c) 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.jpackage.test;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.PrintStream;

import java.lang.reflect.InvocationTargetException;

import java.nio.file.*;

import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;

import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;

import java.util.*;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.function.BiPredicate;

import java.util.function.Consumer;

import java.util.function.Predicate;

import java.util.function.Supplier;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.jpackage.test.Functional.ExceptionBox;

import jdk.jpackage.test.Functional.ThrowingConsumer;

import jdk.jpackage.test.Functional.ThrowingRunnable;

import jdk.jpackage.test.Functional.ThrowingSupplier;

final public class TKit {

    public static final Path TEST_SRC_ROOT = Functional.identity(() -> {

        Path root = Path.of(System.getProperty("test.src"));

        for (int i = 0; i != 10; ++i) {

            if (root.resolve("apps").toFile().isDirectory()) {

                return root.toAbsolutePath();

            }

            root = root.resolve("..");

        }

        throw new RuntimeException("Failed to locate apps directory");

    }).get();

    public static void run(String args[], ThrowingRunnable testBody) {

        if (currentTest != null) {

            throw new IllegalStateException(

                    "Unexpeced nested or concurrent Test.run() call");

        }

        TestInstance test = new TestInstance(testBody);

        ThrowingRunnable.toRunnable(() -> runTests(List.of(test))).run();

        test.rethrowIfSkipped();

        if (!test.passed()) {

            throw new RuntimeException();

        }

    }

    static void withExtraLogStream(ThrowingRunnable action) {

        if (extraLogStream != null) {

            ThrowingRunnable.toRunnable(action).run();

        } else {

            try (PrintStream logStream = openLogStream()) {

                extraLogStream = logStream;

                ThrowingRunnable.toRunnable(action).run();

            } finally {

                extraLogStream = null;

            }

        }

    }

    static void runTests(List<TestInstance> tests) {

        if (currentTest != null) {

            throw new IllegalStateException(

                    "Unexpeced nested or concurrent Test.run() call");

        }

        withExtraLogStream(() -> {

            tests.stream().forEach(test -> {

                currentTest = test;

                try {

                    ignoreExceptions(test).run();

                } finally {

                    currentTest = null;

                    if (extraLogStream != null) {

                        extraLogStream.flush();

                    }

                }

            });

        });

    }

    static Runnable ignoreExceptions(ThrowingRunnable action) {

        return () -> {

            try {

                try {

                    action.run();

                } catch (Throwable ex) {

                    unbox(ex);

                }

            } catch (Throwable throwable) {

                printStackTrace(throwable);

            }

        };

    }

    static void unbox(Throwable throwable) throws Throwable {

        try {

            throw throwable;

        } catch (ExceptionBox | InvocationTargetException ex) {

            unbox(ex.getCause());

        }

    }

    public static Path workDir() {

        return currentTest.workDir();

    }

    static Path defaultInputDir() {

        return workDir().resolve("input");

    }

    static Path defaultOutputDir() {

        return workDir().resolve("output");

    }

    static String getCurrentDefaultAppName() {

        // Construct app name from swapping and joining test base name

        // and test function name.

        // Say the test name is `FooTest.testBasic`. Then app name would be `BasicFooTest`.

        String appNamePrefix = currentTest.functionName();

        if (appNamePrefix != null && appNamePrefix.startsWith("test")) {

            appNamePrefix = appNamePrefix.substring("test".length());

        }

        return Stream.of(appNamePrefix, currentTest.baseName()).filter(

                v -> v != null && !v.isEmpty()).collect(Collectors.joining());

    }

    public static boolean isWindows() {

        return (OS.contains("win"));

    }

    public static boolean isOSX() {

        return (OS.contains("mac"));

    }

    public static boolean isLinux() {

        return ((OS.contains("nix") || OS.contains("nux")));

    }

    static void log(String v) {

        System.out.println(v);

        if (extraLogStream != null) {

            extraLogStream.println(v);

        }

    }

    public static void createTextFile(Path propsFilename, Collection<String> lines) {

        createTextFile(propsFilename, lines.stream());

    }

    public static void createTextFile(Path propsFilename, Stream<String> lines) {

        trace(String.format("Create [%s] text file...",

                propsFilename.toAbsolutePath().normalize()));

        ThrowingRunnable.toRunnable(() -> Files.write(propsFilename,

                lines.peek(TKit::trace).collect(Collectors.toList()))).run();

        trace("Done");

    }

    public static void createPropertiesFile(Path propsFilename,

            Collection<Map.Entry<String, String>> props) {

        trace(String.format("Create [%s] properties file...",

                propsFilename.toAbsolutePath().normalize()));

        ThrowingRunnable.toRunnable(() -> Files.write(propsFilename,

                props.stream().map(e -> String.join("=", e.getKey(),

                e.getValue())).peek(TKit::trace).collect(Collectors.toList()))).run();

        trace("Done");

    }

    public static void createPropertiesFile(Path propsFilename,

            Map.Entry<String, String>... props) {

        createPropertiesFile(propsFilename, List.of(props));

    }

    public static void createPropertiesFile(Path propsFilename,

            Map<String, String> props) {

        createPropertiesFile(propsFilename, props.entrySet());

    }

    public static void trace(String v) {

        if (TRACE) {

            log("TRACE: " + v);

        }

    }

    private static void traceAssert(String v) {

        if (TRACE_ASSERTS) {

            log("TRACE: " + v);

        }

    }

    public static void error(String v) {

        log("ERROR: " + v);

        throw new AssertionError(v);

    }

    private final static String TEMP_FILE_PREFIX = null;

    private static Path createUniqueFileName(String defaultName) {

        final String[] nameComponents;

        int separatorIdx = defaultName.lastIndexOf('.');

        final String baseName;

        if (separatorIdx == -1) {

            baseName = defaultName;

            nameComponents = new String[]{baseName};

        } else {

            baseName = defaultName.substring(0, separatorIdx);

            nameComponents = new String[]{baseName, defaultName.substring(

                separatorIdx + 1)};

        }

        final Path basedir = workDir();

        int i = 0;

        for (; i < 100; ++i) {

            Path path = basedir.resolve(String.join(".", nameComponents));

            if (!path.toFile().exists()) {

                return path;

            }

            nameComponents[0] = String.format("%s.%d", baseName, i);

        }

        throw new IllegalStateException(String.format(

                "Failed to create unique file name from [%s] basename after %d attempts",

                baseName, i));

    }

    public static Path createTempDirectory(String role) throws IOException {

        if (role == null) {

            return Files.createTempDirectory(workDir(), TEMP_FILE_PREFIX);

        }

        return Files.createDirectory(createUniqueFileName(role));

    }

    public static Path createTempFile(String role, String suffix) throws

            IOException {

        if (role == null) {

            return Files.createTempFile(workDir(), TEMP_FILE_PREFIX, suffix);

        }

        return Files.createFile(createUniqueFileName(role));

    }

    public static Path withTempFile(String role, String suffix,

            ThrowingConsumer<Path> action) {

        final Path tempFile = ThrowingSupplier.toSupplier(() -> createTempFile(

                role, suffix)).get();

        boolean keepIt = true;

        try {

            ThrowingConsumer.toConsumer(action).accept(tempFile);

            keepIt = false;

            return tempFile;

        } finally {

            if (tempFile != null && !keepIt) {

                ThrowingRunnable.toRunnable(() -> Files.deleteIfExists(tempFile)).run();

            }

        }

    }

    public static Path withTempDirectory(String role,

            ThrowingConsumer<Path> action) {

        final Path tempDir = ThrowingSupplier.toSupplier(

                () -> createTempDirectory(role)).get();

        boolean keepIt = true;

        try {

            ThrowingConsumer.toConsumer(action).accept(tempDir);

            keepIt = false;

            return tempDir;

        } finally {

            if (tempDir != null && tempDir.toFile().isDirectory() && !keepIt) {

                deleteDirectoryRecursive(tempDir, "");

            }

        }

    }

    private static class DirectoryCleaner implements Consumer<Path> {

        DirectoryCleaner traceMessage(String v) {

            msg = v;

            return this;

        }

        DirectoryCleaner contentsOnly(boolean v) {

            contentsOnly = v;

            return this;

        }

        @Override

        public void accept(Path root) {

            if (msg == null) {

                if (contentsOnly) {

                    msg = String.format("Cleaning [%s] directory recursively",

                            root);

                } else {

                    msg = String.format("Deleting [%s] directory recursively",

                            root);

                }

            }

            if (!msg.isEmpty()) {

                trace(msg);

            }

            List<Throwable> errors = new ArrayList<>();

            try {

                final List<Path> paths;

                if (contentsOnly) {

                    try (var pathStream = Files.walk(root, 0)) {

                        paths = pathStream.collect(Collectors.toList());

                    }

                } else {

                    paths = List.of(root);

                }

                for (var path : paths) {

                    try (var pathStream = Files.walk(path)) {

                        pathStream

                        .sorted(Comparator.reverseOrder())

                        .sequential()

                        .forEachOrdered(file -> {

                            try {

                                if (isWindows()) {

                                    Files.setAttribute(file, "dos:readonly", false);

                                }

                                Files.delete(file);

                            } catch (IOException ex) {

                                errors.add(ex);

                            }

                        });

                    }

                }

            } catch (IOException ex) {

                errors.add(ex);

            }

            errors.forEach(error -> trace(error.toString()));

        }

        private String msg;

        private boolean contentsOnly;

    }

    /**

     * Deletes contents of the given directory recursively. Shortcut for

     * <code>deleteDirectoryContentsRecursive(path, null)</code>

     *

     * @param path path to directory to clean

     */

    public static void deleteDirectoryContentsRecursive(Path path) {

        deleteDirectoryContentsRecursive(path, null);

    }

    /**

     * Deletes contents of the given directory recursively. If <code>path<code> is not a

     * directory, request is silently ignored.

     *

     * @param path path to directory to clean

     * @param msg log message. If null, the default log message is used. If

     * empty string, no log message will be saved.

     */

    public static void deleteDirectoryContentsRecursive(Path path, String msg) {

        if (path.toFile().isDirectory()) {

            new DirectoryCleaner().contentsOnly(true).traceMessage(msg).accept(

                    path);

        }

    }

    /**

     * Deletes the given directory recursively. Shortcut for

     * <code>deleteDirectoryRecursive(path, null)</code>

     *

     * @param path path to directory to delete

     */

    public static void deleteDirectoryRecursive(Path path) {

        deleteDirectoryRecursive(path, null);

    }

    /**

     * Deletes the given directory recursively. If <code>path<code> is not a

     * directory, request is silently ignored.

     *

     * @param path path to directory to delete

     * @param msg log message. If null, the default log message is used. If

     * empty string, no log message will be saved.

     */

    public static void deleteDirectoryRecursive(Path path, String msg) {

        if (path.toFile().isDirectory()) {

            new DirectoryCleaner().traceMessage(msg).accept(path);

        }

    }

    public static RuntimeException throwUnknownPlatformError() {

        if (isWindows() || isLinux() || isOSX()) {

            throw new IllegalStateException(

                    "Platform is known. throwUnknownPlatformError() called by mistake");

        }

        throw new IllegalStateException("Unknown platform");

    }

    public static RuntimeException throwSkippedException(String reason) {

        trace("Skip the test: " + reason);

        RuntimeException ex = ThrowingSupplier.toSupplier(

                () -> (RuntimeException) Class.forName("jtreg.SkippedException").getConstructor(

                        String.class).newInstance(reason)).get();

        currentTest.notifySkipped(ex);

        throw ex;

    }

    public static Path createRelativePathCopy(final Path file) {

        Path fileCopy = workDir().resolve(file.getFileName()).toAbsolutePath().normalize();

        ThrowingRunnable.toRunnable(() -> Files.copy(file, fileCopy,

                StandardCopyOption.REPLACE_EXISTING)).run();

        final Path basePath = Path.of(".").toAbsolutePath().normalize();

        try {

            return basePath.relativize(fileCopy);

        } catch (IllegalArgumentException ex) {

            // May happen on Windows: java.lang.IllegalArgumentException: 'other' has different root

            trace(String.format("Failed to relativize [%s] at [%s]", fileCopy,

                    basePath));

            printStackTrace(ex);

        }

        return file;

    }

    static void waitForFileCreated(Path fileToWaitFor,

            long timeoutSeconds) throws IOException {

        trace(String.format("Wait for file [%s] to be available", fileToWaitFor));

        WatchService ws = FileSystems.getDefault().newWatchService();

        Path watchDirectory = fileToWaitFor.toAbsolutePath().getParent();

        watchDirectory.register(ws, ENTRY_CREATE, ENTRY_MODIFY);

        long waitUntil = System.currentTimeMillis() + timeoutSeconds * 1000;

        for (;;) {

            long timeout = waitUntil - System.currentTimeMillis();

            assertTrue(timeout > 0, String.format(

                    "Check timeout value %d is positive", timeout));

            WatchKey key = ThrowingSupplier.toSupplier(() -> ws.poll(timeout,

                    TimeUnit.MILLISECONDS)).get();

            if (key == null) {

                if (fileToWaitFor.toFile().exists()) {

                    trace(String.format(

                            "File [%s] is available after poll timeout expired",

                            fileToWaitFor));

                    return;

                }

                assertUnexpected(String.format("Timeout expired", timeout));

            }

            for (WatchEvent<?> event : key.pollEvents()) {

                if (event.kind() == StandardWatchEventKinds.OVERFLOW) {

                    continue;

                }

                Path contextPath = (Path) event.context();

                if (Files.isSameFile(watchDirectory.resolve(contextPath),

                        fileToWaitFor)) {

                    trace(String.format("File [%s] is available", fileToWaitFor));

                    return;

                }

            }

            if (!key.reset()) {

                assertUnexpected("Watch key invalidated");

            }

        }

    }

    static void printStackTrace(Throwable throwable) {

        if (extraLogStream != null) {