/*
 * Copyright (c) 2018, 2024, 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.util.stream.Stream;
import java.util.stream.Collectors;
import java.util.function.Consumer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import jdk.jpackage.test.TKit;
import jdk.jpackage.test.JPackageCommand;
import jdk.jpackage.test.LauncherIconVerifier;
import jdk.jpackage.test.PackageTest;
import jdk.jpackage.test.Executor;
import jdk.jpackage.test.LinuxHelper;
import jdk.jpackage.test.AdditionalLauncher;
import jdk.jpackage.internal.util.function.ThrowingConsumer;
import jdk.jpackage.internal.util.function.ThrowingBiConsumer;
import jdk.jpackage.test.Annotations.Parameters;
import jdk.jpackage.test.Annotations.Test;

/*
 * @test
 * @summary jpackage create image and package with custom icons for the main and additional launcher
 * @library /test/jdk/tools/jpackage/helpers
 * @build jdk.jpackage.test.*
 * @compile IconTest.java
 * @run main/othervm/timeout=540 -Xmx512m
 *  jdk.jpackage.test.Main
 *  --jpt-run=IconTest
 */

public class IconTest {

    enum IconType {
        /**
         * Icon not specified.
         */
        DefaultIcon,

        /**
         * Explicit no icon.
         */
        NoIcon,

        /**
         * Custom icon on command line.
         */
        CustomIcon,

        /**
         * Custom icon in resource dir.
         */
        ResourceDirIcon,

        /**
         * Custom icon on command line and in resource dir.
         */
        CustomWithResourceDirIcon
    }

    enum BundleType { AppImage, Package }

    public IconTest(BundleType bundleType, IconType mainLauncherIconType,
            IconType additionalLauncherIconType, String[] extraJPackageArgs) {
        this.appImage = (bundleType == BundleType.AppImage);
        this.extraJPackageArgs = extraJPackageArgs;
        config = Map.of(
                Launcher.Main, mainLauncherIconType,
                Launcher.Additional, additionalLauncherIconType);
    }

    public IconTest(BundleType bundleType, IconType mainLauncherIconType,
            IconType additionalLauncherIconType) {
        this.appImage = (bundleType == BundleType.AppImage);
        this.extraJPackageArgs = new String[0];
        config = Map.of(
                Launcher.Main, mainLauncherIconType,
                Launcher.Additional, additionalLauncherIconType);
    }

    public IconTest(BundleType bundleType, IconType mainLauncherIconType) {
        this.appImage = (bundleType == BundleType.AppImage);
        this.extraJPackageArgs = new String[0];
        config = Map.of(Launcher.Main, mainLauncherIconType);
    }

    @Parameters
    public static Collection data() {
        List<Object[]> data = new ArrayList<>();

        var withLinuxShortcut = Set.of(IconType.DefaultIcon, IconType.NoIcon);

        for (var bundleType : BundleType.values()) {
            if (TKit.isWindows() && bundleType == BundleType.Package) {
                // On Windows icons are embedded in launcher executables in
                // application image. Nothing is changed when app image is
                // packed in msi/exe package bundle, so skip testing of package
                // bundle.
                continue;
            }
            for (var mainLauncherIconType : IconType.values()) {
                if (mainLauncherIconType == IconType.NoIcon) {
                    // `No icon` setting is not applicable for the main launcher.
                    continue;
                }

                if (TKit.isOSX()) {
                    // Custom icons not supported for additional launchers on Mac.
                    data.add(new Object[]{bundleType, mainLauncherIconType});
                    continue;
                }

                for (var additionalLauncherIconType : IconType.values()) {
                    data.add(new Object[]{bundleType, mainLauncherIconType,
                        additionalLauncherIconType});

                    if (TKit.isLinux() && bundleType == BundleType.Package
                            && withLinuxShortcut.contains(mainLauncherIconType)
                            && withLinuxShortcut.contains(
                                    additionalLauncherIconType)) {
                        data.add(new Object[]{bundleType, mainLauncherIconType,
                            additionalLauncherIconType, new String[]{
                            "--linux-shortcut"}});
                    }
                }
            }
        }
        return data;
    }

    @Test
    public void test() throws IOException {
        if (appImage) {
            JPackageCommand cmd = initAppImageTest();
            var result = cmd.executeAndAssertImageCreated();
            ThrowingConsumer.toConsumer(createInstallVerifier()).accept(cmd);
            ThrowingBiConsumer.toBiConsumer(createBundleVerifier()).accept(cmd, result);
        } else {
            PackageTest test = initPackageTest();
            test.addInstallVerifier(createInstallVerifier());
            test.addBundleVerifier(createBundleVerifier());

            test.addBundleDesktopIntegrationVerifier(config.values().stream()
                    .anyMatch(this::isWithDesktopIntegration));

            test.run(PackageTest.Action.CREATE_AND_UNPACK);
        }
    }

    boolean isWithDesktopIntegration(IconType iconType) {
        if (appImage) {
            return false;
        }
        boolean withDesktopFile = !Set.of(
                IconType.NoIcon,
                IconType.DefaultIcon).contains(iconType);
        withDesktopFile |= List.of(extraJPackageArgs).contains("--linux-shortcut");
        return withDesktopFile;
    }

    private ThrowingBiConsumer<JPackageCommand, Executor.Result> createBundleVerifier() {
        return (cmd, result) -> {
            var verifier = createConsoleOutputVerifier(cmd.name(), config.get(
                    Launcher.Main), null);
            if (verifier != null) {
                verifier.apply(result.getOutput().stream());
            }

            if (config.containsKey(Launcher.Additional)) {
                verifier = createConsoleOutputVerifier(
                        Launcher.Additional.launcherName, config.get(
                                Launcher.Additional), config.get(Launcher.Main));
                if (verifier != null) {
                    verifier.apply(result.getOutput().stream());
                }
            }
        };
    }

    private TKit.TextStreamVerifier createConsoleOutputVerifier(
            String launcherName, IconType iconType, IconType mainIconType) {
        if (iconType == IconType.DefaultIcon && mainIconType != null) {
            iconType = mainIconType;
        }
        return createConsoleOutputVerifier(launcherName, iconType);
    }

    private static TKit.TextStreamVerifier createConsoleOutputVerifier(
            String launcherName, IconType iconType) {
        String lookupString = null;
        switch (iconType) {
            case DefaultIcon:
                lookupString = String.format(
                        "Using default package resource %s [icon] (add %s%s to the resource-dir to customize)",
                        "JavaApp" + TKit.ICON_SUFFIX,
                        launcherName, TKit.ICON_SUFFIX);
                break;

            case ResourceDirIcon:
                lookupString = String.format(
                        "Using custom package resource [icon] (loaded from %s%s)",
                        launcherName, TKit.ICON_SUFFIX);
                break;

            case CustomIcon:
            case CustomWithResourceDirIcon:
                lookupString = "Using custom package resource [icon] (loaded from file";
                break;

            default:
                return null;
        }

        return TKit.assertTextStream(lookupString);
    }

    private ThrowingConsumer<JPackageCommand> createInstallVerifier() {
        LauncherIconVerifier verifier = new LauncherIconVerifier();
        switch (config.get(Launcher.Main)) {
            case NoIcon:
                verifier.setExpectedIcon(null);
                break;

            case DefaultIcon:
                verifier.setExpectedDefaultIcon();
                break;

            case CustomIcon:
                verifier.setExpectedIcon(Launcher.Main.cmdlineIcon);
                break;

            case ResourceDirIcon:
                verifier.setExpectedIcon(Launcher.Main.resourceDirIcon);
                break;

            case CustomWithResourceDirIcon:
                verifier.setExpectedIcon(Launcher.Main2.cmdlineIcon);
                break;
        }

        return cmd -> {
            verifier.applyTo(cmd);
            if (TKit.isLinux() && !cmd.isImagePackageType()) {
                Path desktopFile = LinuxHelper.getDesktopFile(cmd);
                if (isWithDesktopIntegration(config.get(Launcher.Main))) {
                    TKit.assertFileExists(desktopFile);
                } else {
                    TKit.assertPathExists(desktopFile, false);
                }
            }
        };
    }

    private void initTest(JPackageCommand cmd, PackageTest test) {
        config.entrySet().forEach(ThrowingConsumer.toConsumer(entry -> {
            initTest(entry.getKey(), entry.getValue(), cmd, test);
        }));

        ThrowingConsumer<JPackageCommand> initializer = testCmd -> {
            testCmd.saveConsoleOutput(true);
            testCmd.setFakeRuntime();
            testCmd.addArguments(extraJPackageArgs);
        };

        if (test != null) {
            test.addInitializer(initializer);
        } else {
            ThrowingConsumer.toConsumer(initializer).accept(cmd);
        }
    }

    private static void initTest(Launcher cfg, IconType iconType,
            JPackageCommand cmd, PackageTest test) throws IOException {
        Consumer<AdditionalLauncher> addLauncher = v -> {
            if (test != null) {
                v.applyTo(test);
            } else {
                v.applyTo(cmd);
            }
        };

        switch (iconType) {
            case DefaultIcon:
                if (cfg.launcherName != null) {
                    addLauncher.accept(new AdditionalLauncher(cfg.launcherName));
                }
                break;

            case NoIcon:
                if (cfg.launcherName != null) {
                    addLauncher.accept(
                            new AdditionalLauncher(cfg.launcherName).setNoIcon());
                }
                break;

            case CustomIcon:
                if (test != null) {
                    addCustomIcon(null, test, cfg.launcherName, cfg.cmdlineIcon);
                } else {
                    addCustomIcon(cmd, null, cfg.launcherName, cfg.cmdlineIcon);
                }
                break;

            case ResourceDirIcon:
                if (Launcher.PRIMARY.contains(cfg) && cfg.launcherName != null) {
                    addLauncher.accept(new AdditionalLauncher(cfg.launcherName));
                }
                if (test != null) {
                    test.addInitializer(testCmd -> {
                        addResourceDirIcon(testCmd, cfg.launcherName,
                                cfg.resourceDirIcon);
                    });
                } else {
                    addResourceDirIcon(cmd, cfg.launcherName, cfg.resourceDirIcon);
                }
                break;

            case CustomWithResourceDirIcon:
                switch (cfg) {
                    case Main:
                        initTest(Launcher.Main2, IconType.CustomIcon, cmd, test);
                        initTest(Launcher.Main2, IconType.ResourceDirIcon, cmd, test);
                        break;

                    case Additional:
                        initTest(Launcher.Additional2, IconType.CustomIcon, cmd, test);
                        initTest(Launcher.Additional2, IconType.ResourceDirIcon, cmd, test);
                        break;

                    default:
                        throw new IllegalArgumentException();
                }
                break;
        }
    }

    private JPackageCommand initAppImageTest() {
        JPackageCommand cmd = JPackageCommand.helloAppImage();
        initTest(cmd, null);
        return cmd;
    }

    private PackageTest initPackageTest() {
        PackageTest test = new PackageTest().configureHelloApp();
        initTest(null, test);
        return test;
    }

    private static void addResourceDirIcon(JPackageCommand cmd,
            String launcherName, Path iconPath) throws IOException {
        Path resourceDir = cmd.getArgumentValue("--resource-dir", () -> null,
                Path::of);
        if (resourceDir == null) {
            resourceDir = TKit.createTempDirectory("resources");
            cmd.addArguments("--resource-dir", resourceDir);
        }

        String dstIconFileName = Optional.ofNullable(launcherName).orElseGet(
                () -> cmd.name()) + TKit.ICON_SUFFIX;

        TKit.trace(String.format("Resource file: [%s] <- [%s]",
                resourceDir.resolve(dstIconFileName), iconPath));
        Files.copy(iconPath, resourceDir.resolve(dstIconFileName),
                StandardCopyOption.REPLACE_EXISTING);
    }

    private static void addCustomIcon(JPackageCommand cmd, PackageTest test,
            String launcherName, Path iconPath) throws IOException {

        if (launcherName != null) {
            AdditionalLauncher al = new AdditionalLauncher(launcherName).setIcon(
                    iconPath);
            if (test != null) {
                al.applyTo(test);
            } else {
                al.applyTo(cmd);
            }
        } else if (test != null) {
            test.addInitializer(testCmd -> {
                testCmd.addArguments("--icon", iconPath);
            });
        } else {
            cmd.addArguments("--icon", iconPath);
        }
    }

    private enum Launcher {
        Main(null, ICONS[0], ICONS[1]),
        Main2(null, ICONS[1], ICONS[0]),
        Additional("x", ICONS[2], ICONS[3]),
        Additional2("x", ICONS[3], ICONS[2]);

        Launcher(String name, Path cmdlineIcon, Path resourceDirIcon) {
            this.launcherName = name;
            this.cmdlineIcon = cmdlineIcon;
            this.resourceDirIcon = resourceDirIcon;
        }

        private final String launcherName;
        private final Path cmdlineIcon;
        private final Path resourceDirIcon;

        private static final Set<Launcher> PRIMARY = Set.of(Main, Additional);
    }

    private final boolean appImage;
    private final Map<Launcher, IconType> config;
    private final String[] extraJPackageArgs;

    private static Path iconPath(String name) {
        return TKit.TEST_SRC_ROOT.resolve(Path.of("resources", name
                + TKit.ICON_SUFFIX));
    }

    private static final Path[] ICONS = Stream.of("icon", "icon2", "icon3",
            "icon4")
            .map(IconTest::iconPath)
            .collect(Collectors.toList()).toArray(Path[]::new);
}