/*

 * 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.nio.file.Paths;

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 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";

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

    private static Pattern pattern = Pattern.compile(

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

    private DeployParams deployParams = null;

    private int pos = 0;

    private List<String> argList = null;

    private List<CLIOptions> allOptions = null;

    private String input = null;

    private String output = null;

    private boolean hasMainJar = false;

    private boolean hasMainClass = false;

    private boolean hasMainModule = false;

    public boolean userProvidedBuildRoot = false;

    private String buildRoot = null;

    private String mainJarPath = null;

    private static boolean runtimeInstaller = false;

    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) {

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

        for (String arg : args) {

            argList.add(arg);

        }

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

        pos = 0;

        deployParams = new DeployParams();

        allOptions = new ArrayList<>();

        addLaunchers = new ArrayList<>();

        output = Paths.get("").toAbsolutePath().toString();

        deployParams.setOutput(new File(output));

    }

    // CLIOptions is public for DeployParamsTest

    public enum CLIOptions {

        PACKAGE_TYPE("package-type", OptionCategories.PROPERTY, () -> {

            context().deployParams.setTargetFormat(popArg());

        }),

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

            context().input = popArg();

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

        }),

        OUTPUT ("dest", "d", OptionCategories.PROPERTY, () -> {

            context().output = popArg();

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

        }),

        DESCRIPTION ("description", 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();

        }),

        RESOURCE_DIR("resource-dir",

                OptionCategories.PROPERTY, () -> {

            String resourceDir = popArg();

            setOptionValue("resource-dir", resourceDir);

        }),

        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),

        RELEASE ("linux-app-release", OptionCategories.PROPERTY),

        JAVA_OPTIONS ("java-options", OptionCategories.PROPERTY, () -> {

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

            args.forEach(a -> setOptionValue("java-options", a));

        }),

        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, () -> {

            String spec = popArg();

            String name = null;

            String filename = spec;

            if (spec.contains("=")) {

                String[] values = spec.split("=", 2);

                name = values[0];

                filename = values[1];

            }

            context().addLaunchers.add(

                new AddLauncherArguments(name, filename));

        }),

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

            context().buildRoot = popArg();

            context().userProvidedBuildRoot = true;

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

        }),

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

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

        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-package-name", OptionCategories.PLATFORM_MAC),

        MAC_BUNDLE_IDENTIFIER("mac-package-identifier",

                    OptionCategories.PLATFORM_MAC),

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

                    OptionCategories.PLATFORM_MAC),

        MAC_BUNDLE_SIGNING_PREFIX ("mac-package-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_UPGRADE_UUID ("win-upgrade-uuid",

                OptionCategories.PLATFORM_WIN),

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

            setOptionValue("win-console", true);

        }),

        LINUX_BUNDLE_NAME ("linux-package-name",

                OptionCategories.PLATFORM_LINUX),

        LINUX_DEB_MAINTAINER ("linux-deb-maintainer",

                OptionCategories.PLATFORM_LINUX),

        LINUX_CATEGORY ("linux-app-category",

                OptionCategories.PLATFORM_LINUX),

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

                OptionCategories.PLATFORM_LINUX),

        LINUX_PACKAGE_DEPENDENCIES ("linux-package-deps",

                OptionCategories.PLATFORM_LINUX),

        LINUX_SHORTCUT_HINT ("linux-shortcut",

                OptionCategories.PLATFORM_LINUX, () -> {

            setOptionValue("linux-shortcut", true);

        }),

        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() {

            return "--" + this.id;

        }

        String getShortIdWithPrefix() {

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

        }

        void execute() {

            if (action != null) {

                action.execute();

            } else {

                defaultAction();

            }

        }

        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 boolean hasNextArg() {

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

        }

    }

    enum OptionCategories {

        MODULAR,

        PROPERTY,

        PLATFORM_MAC,

        PLATFORM_WIN,

        PLATFORM_LINUX;

    }

    public boolean processArguments() {

        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 (hasMainJar && !hasMainClass) {

                // try to get main-class from manifest

                String mainClass = getMainClassFromManifest();

                if (mainClass != null) {

                    CLIOptions.setOptionValue(

                            CLIOptions.APPCLASS.getId(), mainClass);

                }

            }

            // display error for arguments that are not supported

            // for current configuration.

            validateArguments();

            addResources(deployParams, input, mainJarPath);

            List<Map<String, ? super Object>> launchersAsMap =

                    new ArrayList<>();

            for (AddLauncherArguments sl : addLaunchers) {

                launchersAsMap.add(sl.getLauncherMap());

            }

            deployParams.addBundleArgument(

                    StandardBundlerParam.ADD_LAUNCHERS.getID(),

                    launchersAsMap);

            // at this point deployParams should be already configured

            deployParams.validate();

            BundleParams bp = deployParams.getBundleParams();

            // validate name(s)

            ArrayList<String> usedNames = new ArrayList<String>();

            usedNames.add(bp.getName()); // add main app name

            for (AddLauncherArguments sl : addLaunchers) {

                Map<String, ? super Object> slMap = sl.getLauncherMap();

                String slName =

                        (String) slMap.get(Arguments.CLIOptions.NAME.getId());

                if (slName == null) {

                    throw new PackagerException("ERR_NoAddLauncherName");

                }

                // same rules apply to additional launcher names as app name

                DeployParams.validateName(slName, false);

                for (String usedName : usedNames) {

                    if (slName.equals(usedName)) {

                        throw new PackagerException("ERR_NoUniqueName");