import java.util.Arrays;

import java.util.Collection;

import java.util.stream.Stream;

        verifyMutable();

    public boolean hasArgument(String argName) {

        return args.contains(argName);

    }

            Function<JPackageCommand, T> defaultValueSupplier,

            return defaultValueSupplier.apply(this);

            Function<JPackageCommand, String> defaultValueSupplier) {

        return getArgumentValue(argName, defaultValueSupplier, v -> v);

    }

    public <T> T getArgumentValue(String argName,

            Supplier<T> defaultValueSupplier,

            Function<String, T> stringConverter) {

        return getArgumentValue(argName, (unused) -> defaultValueSupplier.get(),

                stringConverter);

    }

    public String getArgumentValue(String argName,

        return getArgumentValue(argName, defaultValueSupplier, v -> v);

    }

    public String getArgumentValue(String argName) {

        return getArgumentValue(argName, (Supplier<String>)null);

    }

    public String[] getAllArgumentValues(String argName) {

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

        String prevArg = null;

        for (String arg : args) {

            if (prevArg != null && prevArg.equals(argName)) {

                values.add(arg);

            }

            prevArg = arg;

        }

        return values.toArray(String[]::new);

        return getArgumentValue("--output", () -> Test.defaultOutputDir(), Path::of);

        return getArgumentValue("--input", () -> Test.defaultInputDir(),Path::of);

        return getArgumentValue("--app-version", () -> "1.0");

        return getArgumentValue("--name", () -> getArgumentValue("--main-class"));

    }

    public boolean isRuntime() {

        return getArgumentValue("--runtime-image", () -> false, v -> true);

    JPackageCommand addAction(Runnable action) {

        actions.add(action);

    public static JPackageCommand helloAppImage() {

        JPackageCommand cmd = new JPackageCommand();

        cmd.setDefaultInputOutput().setDefaultAppName();

        HelloApp.addTo(cmd);

        return cmd;

    }

    JPackageCommand setDefaultAppName() {

        StackTraceElement st[] = Thread.currentThread().getStackTrace();

        for (StackTraceElement ste : st) {

            if ("main".equals(ste.getMethodName())) {

                String name = ste.getClassName();

                name = Stream.of(name.split("[.$]")).reduce((f, l) -> l).get();

                addArguments("--name", name);

                break;

            }

        }

        return this;

    }

        final PackageType type = packageType();

        if (PackageType.IMAGE == type) {

            return null;

        }

        String bundleName = null;

        if (PackageType.LINUX.contains(type)) {

            bundleName = LinuxHelper.getBundleName(this);

        } else if (PackageType.WINDOWS.contains(type)) {

            bundleName = WindowsHelper.getBundleName(this);

        } else if (PackageType.MAC.contains(type)) {

            bundleName = MacHelper.getBundleName(this);

        return outputDir().resolve(bundleName);

    }

    /**

     * Returns path to directory where application will be installed.

     *

     * E.g. on Linux for app named Foo default the function will return

     * `/opt/foo`

     */

    public Path appInstallationDirectory() {

        final PackageType type = packageType();

        if (PackageType.IMAGE == type) {

            return null;

        }

        if (PackageType.LINUX.contains(type)) {

            // Launcher is in "bin" subfolder of the installation directory.

            return launcherInstallationPath().getParent().getParent();

        }

        if (PackageType.WINDOWS.contains(type)) {

            return WindowsHelper.getInstallationDirectory(this);

        }

        if (PackageType.MAC.contains(type)) {

            return MacHelper.getInstallationDirectory(this);

        }

        throw new IllegalArgumentException("Unexpected package type");

    /**

     * Returns path where application launcher will be installed.

     * If the command will package Java run-time only, still returns path to

     * application launcher.

     *

     * E.g. on Linux for app named Foo default the function will return

     * `/opt/foo/bin/Foo`

     */

        final PackageType type = packageType();

        if (PackageType.IMAGE == type) {

            return null;

        }

        if (PackageType.LINUX.contains(type)) {

            return outputDir().resolve(LinuxHelper.getLauncherPath(this));

        }

        if (PackageType.WINDOWS.contains(type)) {

            return appInstallationDirectory().resolve(name() + ".exe");

        }

        if (PackageType.MAC.contains(type)) {

            return appInstallationDirectory().resolve(Path.of("Contents", "MacOS", name()));

        throw new IllegalArgumentException("Unexpected package type");

    }

    /**

     * Returns path to application image directory.

     *

     * E.g. if --output is set to `foo` and --name is set to `bar` the function

     * will return `foo/bar` path.

     *

     * @throws IllegalArgumentException is command is doing platform packaging

     */

    public Path appImage() {

        final PackageType type = packageType();

        if (PackageType.IMAGE != type) {

            throw new IllegalArgumentException("Unexpected package type");

        }

        return outputDir().resolve(name());

    }

    /**

     * Returns path to application launcher relative to image directory.

     *

     * E.g. if --name is set to `Foo` the function will return `bin/Foo` path on

     * Linux, and `Foo.exe` on Windows.

     *

     * @throws IllegalArgumentException is command is doing platform packaging

     */

    public Path launcherPathInAppImage() {

        final PackageType type = packageType();

        if (PackageType.IMAGE != type) {

            throw new IllegalArgumentException("Unexpected package type");

        }

        if (Test.isLinux()) {

            return Path.of("bin", name());

        }

        if (Test.isOSX()) {

            return Path.of("Contents", "MacOS", name());

        }

        if (Test.isWindows()) {

            return Path.of(name() + ".exe");

        }

        throw new IllegalArgumentException("Unexpected package type");

    String getPrintableCommandLine() {

        return new Executor()

                .setExecutable(JavaTool.JPACKAGE)

                .addArguments(args)

                .getPrintableCommandLine();

    }

    void verifyIsOfType(Collection<PackageType> types) {

        verifyIsOfType(types.toArray(PackageType[]::new));

    }

    void verifyIsOfType(PackageType ... types) {

        if (!Arrays.asList(types).contains(packageType())) {

            throw new IllegalArgumentException("Unexpected package type");

        }

                    for (PackageType type : PackageType.NATIVE) {