/*

 * 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * 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.internal;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Properties;

import java.util.ResourceBundle;

import java.util.jar.Attributes;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import java.util.stream.Stream;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * Arguments

 *

 * This class encapsulates and processes the command line arguments,

 * in effect, implementing all the work of jpackage tool.

 *

 * The primary entry point, processArguments():

 * Processes and validates command line arguments, constructing DeployParams.

 * Validates the DeployParams, and generate the BundleParams.

 * Generates List of Bundlers from BundleParams valid for this platform.

 * Executes each Bundler in the list.

 */

public class Arguments {

    private static final ResourceBundle I18N = ResourceBundle.getBundle(

            "jdk.jpackage.internal.resources.MainResources");

    private static final String IMAGE_MODE = "image";

    private static final String INSTALLER_MODE = "installer";

    private static final String FA_EXTENSIONS = "extension";

    private static final String FA_CONTENT_TYPE = "mime-type";

    private static final String FA_DESCRIPTION = "description";

    private static final String FA_ICON = "icon";

    public static final BundlerParamInfo<Boolean> CREATE_IMAGE =

            new StandardBundlerParam<>(

                    IMAGE_MODE,

                    Boolean.class,

                    p -> Boolean.FALSE,

                    (s, p) -> (s == null || "null".equalsIgnoreCase(s)) ?

                            true : Boolean.valueOf(s));

    public static final BundlerParamInfo<Boolean> CREATE_INSTALLER =

            new StandardBundlerParam<>(

                    INSTALLER_MODE,

                    Boolean.class,

                    p -> Boolean.FALSE,

                    (s, p) -> (s == null || "null".equalsIgnoreCase(s)) ?

                            true : Boolean.valueOf(s));

    // regexp for parsing args (for example, for additional launchers)

    private static Pattern pattern = Pattern.compile(

          "(?:(?:([\"'])(?:\\\\\\1|.)*?(?:\\1|$))|(?:\\\\[\"'\\s]|[^\\s]))++");

    private DeployParams deployParams = null;

    private BundlerType bundleType = null;

    private int pos = 0;

    private List<String> argList = null;

    private List<CLIOptions> allOptions = null;

    private ArrayList<String> files = null;

    private String input = null;

    private String output = null;

    private boolean hasMainJar = false;

    private boolean hasMainClass = false;

    private boolean hasMainModule = false;

    private boolean hasTargetFormat = false;

    private boolean hasAppImage = false;

    public boolean userProvidedBuildRoot = false;

    private String buildRoot = null;

    private String mainJarPath = null;

    private static boolean runtimeInstaller = false;

    private List<jdk.jpackage.internal.Bundler> platformBundlers = null;

    private List<AddLauncherArguments> addLaunchers = null;

    private static Map<String, CLIOptions> argIds = new HashMap<>();

    private static Map<String, CLIOptions> argShortIds = new HashMap<>();

    static {

        // init maps for parsing arguments

        (EnumSet.allOf(CLIOptions.class)).forEach(option -> {

            argIds.put(option.getIdWithPrefix(), option);

            if (option.getShortIdWithPrefix() != null) {

                argShortIds.put(option.getShortIdWithPrefix(), option);

            }

        });

    }

    public Arguments(String[] args) throws PackagerException {

        argList = new ArrayList<String>(args.length);

        for (String arg : args) {

            argList.add(arg);

        }

        Log.debug ("\njpackage argument list: \n" + argList + "\n");

        pos = 0;

        deployParams = new DeployParams();

        bundleType = BundlerType.NONE;

        allOptions = new ArrayList<>();

        addLaunchers = new ArrayList<>();

    }

    // CLIOptions is public for DeployParamsTest

    public enum CLIOptions {

        CREATE_IMAGE(IMAGE_MODE, OptionCategories.MODE, () -> {

            context().bundleType = BundlerType.IMAGE;

            context().deployParams.setTargetFormat("image");

            setOptionValue(IMAGE_MODE, true);

        }),

        CREATE_INSTALLER(INSTALLER_MODE, OptionCategories.MODE, () -> {

            setOptionValue(INSTALLER_MODE, true);

            context().bundleType = BundlerType.INSTALLER;

            String format = "installer";

            context().deployParams.setTargetFormat(format);

        }),

        INSTALLER_TYPE("installer-type", OptionCategories.PROPERTY, () -> {

            String type = popArg();

            if (BundlerType.INSTALLER.equals(context().bundleType)) {

                context().deployParams.setTargetFormat(type);

                context().hasTargetFormat = true;

            }

            setOptionValue("installer-type", type);

        }),

        INPUT ("input", "i", OptionCategories.PROPERTY, () -> {

            context().input = popArg();

            setOptionValue("input", context().input);

        }),

        OUTPUT ("output", "o", OptionCategories.PROPERTY, () -> {

            context().output = popArg();

            context().deployParams.setOutput(new File(context().output));

        }),

        DESCRIPTION ("description", "d", OptionCategories.PROPERTY),

        VENDOR ("vendor", OptionCategories.PROPERTY),

        APPCLASS ("main-class", OptionCategories.PROPERTY, () -> {

            context().hasMainClass = true;

            setOptionValue("main-class", popArg());

        }),

        NAME ("name", "n", OptionCategories.PROPERTY),

        IDENTIFIER ("identifier", OptionCategories.PROPERTY),

        VERBOSE ("verbose", OptionCategories.PROPERTY, () -> {

            setOptionValue("verbose", true);

            Log.setVerbose(true);

        }),

        RESOURCE_DIR("resource-dir",

                OptionCategories.PROPERTY, () -> {

            String resourceDir = popArg();

            setOptionValue("resource-dir", resourceDir);

        }),

        FILES ("files", "f", OptionCategories.PROPERTY, () -> {

              context().files = new ArrayList<>();

              String files = popArg();

              context().files.addAll(

                      Arrays.asList(files.split(File.pathSeparator)));

        }),

        ARGUMENTS ("arguments", OptionCategories.PROPERTY, () -> {

            List<String> arguments = getArgumentList(popArg());

            setOptionValue("arguments", arguments);

        }),

        ICON ("icon", OptionCategories.PROPERTY),

        COPYRIGHT ("copyright", OptionCategories.PROPERTY),

        LICENSE_FILE ("license-file", OptionCategories.PROPERTY),

        VERSION ("app-version", OptionCategories.PROPERTY),

            List<String> args = getArgumentList(popArg());

        }),

        FILE_ASSOCIATIONS ("file-associations",

                OptionCategories.PROPERTY, () -> {

            Map<String, ? super Object> args = new HashMap<>();

            // load .properties file

            Map<String, String> initialMap = getPropertiesFromFile(popArg());

            String ext = initialMap.get(FA_EXTENSIONS);

            if (ext != null) {

                args.put(StandardBundlerParam.FA_EXTENSIONS.getID(), ext);

            }

            String type = initialMap.get(FA_CONTENT_TYPE);

            if (type != null) {

                args.put(StandardBundlerParam.FA_CONTENT_TYPE.getID(), type);

            }

            String desc = initialMap.get(FA_DESCRIPTION);

            if (desc != null) {

                args.put(StandardBundlerParam.FA_DESCRIPTION.getID(), desc);

            }

            String icon = initialMap.get(FA_ICON);

            if (icon != null) {

                args.put(StandardBundlerParam.FA_ICON.getID(), icon);

            }

            ArrayList<Map<String, ? super Object>> associationList =

                new ArrayList<Map<String, ? super Object>>();

            associationList.add(args);

            // check that we really add _another_ value to the list

            setOptionValue("file-associations", associationList);

        }),

        ADD_LAUNCHER ("add-launcher",

                    OptionCategories.PROPERTY, () -> {

            context().addLaunchers.add(

                new AddLauncherArguments(popArg()));

        }),

        TEMP_ROOT ("temp-root", OptionCategories.PROPERTY, () -> {

            context().buildRoot = popArg();

            context().userProvidedBuildRoot = true;

            setOptionValue("temp-root", context().buildRoot);

        }),

        INSTALL_DIR ("install-dir", OptionCategories.PROPERTY),

        PREDEFINED_APP_IMAGE ("app-image", OptionCategories.PROPERTY, ()-> {

            setOptionValue("app-image", popArg());

            context().hasAppImage = true;

        }),

        PREDEFINED_RUNTIME_IMAGE ("runtime-image", OptionCategories.PROPERTY),

        MAIN_JAR ("main-jar",  OptionCategories.PROPERTY, () -> {

            context().mainJarPath = popArg();

            context().hasMainJar = true;

            setOptionValue("main-jar", context().mainJarPath);

        }),

        MODULE ("module", "m", OptionCategories.MODULAR, () -> {

            context().hasMainModule = true;

            setOptionValue("module", popArg());

        }),

        ADD_MODULES ("add-modules", OptionCategories.MODULAR),

        MODULE_PATH ("module-path", "p", OptionCategories.MODULAR),

        MAC_SIGN ("mac-sign", "s", OptionCategories.PLATFORM_MAC, () -> {

            setOptionValue("mac-sign", true);

        }),

        MAC_BUNDLE_NAME ("mac-bundle-name", OptionCategories.PLATFORM_MAC),

        MAC_BUNDLE_IDENTIFIER("mac-bundle-identifier",

                    OptionCategories.PLATFORM_MAC),

        MAC_APP_STORE_CATEGORY ("mac-app-store-category",

                    OptionCategories.PLATFORM_MAC),

        MAC_BUNDLE_SIGNING_PREFIX ("mac-bundle-signing-prefix",

                    OptionCategories.PLATFORM_MAC),

        MAC_SIGNING_KEY_NAME ("mac-signing-key-user-name",

                    OptionCategories.PLATFORM_MAC),

        MAC_SIGNING_KEYCHAIN ("mac-signing-keychain",

                    OptionCategories.PLATFORM_MAC),

        MAC_APP_STORE_ENTITLEMENTS ("mac-app-store-entitlements",

                    OptionCategories.PLATFORM_MAC),

        WIN_MENU_HINT ("win-menu", OptionCategories.PLATFORM_WIN, () -> {

            setOptionValue("win-menu", true);

        }),

        WIN_MENU_GROUP ("win-menu-group", OptionCategories.PLATFORM_WIN),

        WIN_SHORTCUT_HINT ("win-shortcut",

                OptionCategories.PLATFORM_WIN, () -> {

            setOptionValue("win-shortcut", true);

        }),

        WIN_PER_USER_INSTALLATION ("win-per-user-install",

                OptionCategories.PLATFORM_WIN, () -> {

            setOptionValue("win-per-user-install", false);

        }),

        WIN_DIR_CHOOSER ("win-dir-chooser",

                OptionCategories.PLATFORM_WIN, () -> {

            setOptionValue("win-dir-chooser", true);

        }),

        WIN_REGISTRY_NAME ("win-registry-name", OptionCategories.PLATFORM_WIN),

        WIN_UPGRADE_UUID ("win-upgrade-uuid",

                OptionCategories.PLATFORM_WIN),

        WIN_CONSOLE_HINT ("win-console", OptionCategories.PLATFORM_WIN, () -> {

            setOptionValue("win-console", true);

        }),

        LINUX_BUNDLE_NAME ("linux-bundle-name",

                OptionCategories.PLATFORM_LINUX),

        LINUX_DEB_MAINTAINER ("linux-deb-maintainer",

                OptionCategories.PLATFORM_LINUX),

        LINUX_RPM_LICENSE_TYPE ("linux-rpm-license-type",

                OptionCategories.PLATFORM_LINUX),

        LINUX_PACKAGE_DEPENDENCIES ("linux-package-deps",

                OptionCategories.PLATFORM_LINUX),

        LINUX_MENU_GROUP ("linux-menu-group", OptionCategories.PLATFORM_LINUX);

        private final String id;

        private final String shortId;

        private final OptionCategories category;

        private final ArgAction action;

        private static Arguments argContext;

        private CLIOptions(String id, OptionCategories category) {

            this(id, null, category, null);

        }

        private CLIOptions(String id, String shortId,

                           OptionCategories category) {

            this(id, shortId, category, null);

        }

        private CLIOptions(String id,

                OptionCategories category, ArgAction action) {

            this(id, null, category, action);

        }

        private CLIOptions(String id, String shortId,

                           OptionCategories category, ArgAction action) {

            this.id = id;

            this.shortId = shortId;

            this.action = action;

            this.category = category;

        }

        static void setContext(Arguments context) {

            argContext = context;

        }

        public static Arguments context() {

            if (argContext != null) {

                return argContext;

            } else {

                throw new RuntimeException("Argument context is not set.");

            }

        }

        public String getId() {

            return this.id;

        }

        String getIdWithPrefix() {

            String prefix = isMode() ? "create-" : "--";

            return prefix + this.id;

        }

        String getShortIdWithPrefix() {

            return this.shortId == null ? null : "-" + this.shortId;

        }

        void execute() {

            if (action != null) {

                action.execute();

            } else {

                defaultAction();

            }

        }

        boolean isMode() {

            return category == OptionCategories.MODE;

        }

        OptionCategories getCategory() {

            return category;

        }

        private void defaultAction() {

            context().deployParams.addBundleArgument(id, popArg());

        }

        private static void setOptionValue(String option, Object value) {

            context().deployParams.addBundleArgument(option, value);

        }

        private static String popArg() {

            nextArg();

            return (context().pos >= context().argList.size()) ?

                            "" : context().argList.get(context().pos);

        }

        private static String getArg() {

            return (context().pos >= context().argList.size()) ?

                        "" : context().argList.get(context().pos);

        }

        private static void nextArg() {

            context().pos++;

        }

        private static void prevArg() {

            context().pos--;

        }

        private static boolean hasNextArg() {

            return context().pos < context().argList.size();

        }

    }

    enum OptionCategories {

        MODE,

        MODULAR,

        PROPERTY,

        PLATFORM_MAC,

        PLATFORM_WIN,

        PLATFORM_LINUX;

    }

    public boolean processArguments() throws Exception {

        try {

            // init context of arguments

            CLIOptions.setContext(this);

            // parse cmd line

            String arg;

            CLIOptions option;

            for (; CLIOptions.hasNextArg(); CLIOptions.nextArg()) {

                arg = CLIOptions.getArg();

                if ((option = toCLIOption(arg)) != null) {

                    // found a CLI option

                    allOptions.add(option);

                    option.execute();

                } else {

                    throw new PackagerException("ERR_InvalidOption", arg);

                }

            }

            if (allOptions.isEmpty() || !allOptions.get(0).isMode()) {

                // first argument should always be a mode.

                throw new PackagerException("ERR_MissingMode");

            }