/*

 * Copyright (c) 2006, 2017, 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 com.sun.tools.javac.main;

import java.io.FileWriter;

import java.io.PrintWriter;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.text.Collator;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.EnumSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Locale;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.TreeSet;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.StreamSupport;

import javax.lang.model.SourceVersion;

import com.sun.tools.doclint.DocLint;

import com.sun.tools.javac.code.Lint;

import com.sun.tools.javac.code.Lint.LintCategory;

import com.sun.tools.javac.code.Source;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.jvm.Profile;

import com.sun.tools.javac.jvm.Target;

import com.sun.tools.javac.platform.PlatformProvider;

import com.sun.tools.javac.processing.JavacProcessingEnvironment;

import com.sun.tools.javac.util.Assert;

import com.sun.tools.javac.util.JDK9Wrappers;

import com.sun.tools.javac.util.Log;

import com.sun.tools.javac.util.Log.PrefixKind;

import com.sun.tools.javac.util.Log.WriterKind;

import com.sun.tools.javac.util.Options;

import com.sun.tools.javac.util.StringUtils;

import static com.sun.tools.javac.main.Option.ChoiceKind.*;

import static com.sun.tools.javac.main.Option.OptionGroup.*;

import static com.sun.tools.javac.main.Option.OptionKind.*;

/**

 * Options for javac.

 * The specific Option to handle a command-line option can be found by calling

 * {@link #lookup}, which search some or all of the members of this enum in order,

 * looking for the first {@link #matches match}.

 * The action for an Option is performed {@link #handleOption}, which determines

 * whether an argument is needed and where to find it;

 * {@code handleOption} then calls {@link #process process} providing a suitable

 * {@link OptionHelper} to provide access the compiler state.

 *

 * <p><b>This is NOT part of any supported API.

 * If you write code that depends on this, you do so at your own

 * risk.  This code and its internal interfaces are subject to change

 * or deletion without notice.</b></p>

 */

public enum Option {

    G("-g", "opt.g", STANDARD, BASIC),

    G_NONE("-g:none", "opt.g.none", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option) {

            helper.put("-g:", "none");

        }

    },

    G_CUSTOM("-g:",  "opt.g.lines.vars.source",

            STANDARD, BASIC, ANYOF, "lines", "vars", "source"),

    XLINT("-Xlint", "opt.Xlint", EXTENDED, BASIC),

    XLINT_CUSTOM("-Xlint:", "opt.arg.Xlint", "opt.Xlint.custom", EXTENDED, BASIC, ANYOF, getXLintChoices()) {

        private final String LINT_KEY_FORMAT = LARGE_INDENT + "  %-" +

                (DEFAULT_SYNOPSIS_WIDTH + SMALL_INDENT.length() - LARGE_INDENT.length() - 2) + "s %s";

        @Override

        protected void help(Log log) {

            super.help(log);

            log.printRawLines(WriterKind.STDOUT,

                              String.format(LINT_KEY_FORMAT,

                                            "all",

                                            log.localize(PrefixKind.JAVAC, "opt.Xlint.all")));

            for (LintCategory lc : LintCategory.values()) {

                log.printRawLines(WriterKind.STDOUT,

                                  String.format(LINT_KEY_FORMAT,

                                                lc.option,

                                                log.localize(PrefixKind.JAVAC,

                                                             "opt.Xlint.desc." + lc.option)));

            }

            log.printRawLines(WriterKind.STDOUT,

                              String.format(LINT_KEY_FORMAT,

                                            "none",

                                            log.localize(PrefixKind.JAVAC, "opt.Xlint.none")));

        }

    },

    XDOCLINT("-Xdoclint", "opt.Xdoclint", EXTENDED, BASIC),

    XDOCLINT_CUSTOM("-Xdoclint:", "opt.Xdoclint.subopts", "opt.Xdoclint.custom", EXTENDED, BASIC) {

        @Override

        public boolean matches(String option) {

            return DocLint.isValidOption(

                    option.replace(XDOCLINT_CUSTOM.primaryName, DocLint.XMSGS_CUSTOM_PREFIX));

        }

        @Override

        public void process(OptionHelper helper, String option) {

            String prev = helper.get(XDOCLINT_CUSTOM);

            String next = (prev == null) ? option : (prev + " " + option);

            helper.put(XDOCLINT_CUSTOM.primaryName, next);

        }

    },

    XDOCLINT_PACKAGE("-Xdoclint/package:", "opt.Xdoclint.package.args", "opt.Xdoclint.package.desc", EXTENDED, BASIC) {

        @Override

        public boolean matches(String option) {

            return DocLint.isValidOption(

                    option.replace(XDOCLINT_PACKAGE.primaryName, DocLint.XCHECK_PACKAGE));

        }

        @Override

        public void process(OptionHelper helper, String option) {

            String prev = helper.get(XDOCLINT_PACKAGE);

            String next = (prev == null) ? option : (prev + " " + option);

            helper.put(XDOCLINT_PACKAGE.primaryName, next);

        }

    },

    DOCLINT_FORMAT("--doclint-format", "opt.doclint.format", EXTENDED, BASIC, ONEOF, "html4", "html5"),

    // -nowarn is retained for command-line backward compatibility

    NOWARN("-nowarn", "opt.nowarn", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option) {

            helper.put("-Xlint:none", option);

        }

    },

    VERBOSE("-verbose", "opt.verbose", STANDARD, BASIC),

    // -deprecation is retained for command-line backward compatibility

    DEPRECATION("-deprecation", "opt.deprecation", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option) {

            helper.put("-Xlint:deprecation", option);

        }

    },

    CLASS_PATH("--class-path -classpath -cp", "opt.arg.path", "opt.classpath", STANDARD, FILEMANAGER),

    SOURCE_PATH("--source-path -sourcepath", "opt.arg.path", "opt.sourcepath", STANDARD, FILEMANAGER),

    MODULE_SOURCE_PATH("--module-source-path", "opt.arg.mspath", "opt.modulesourcepath", STANDARD, FILEMANAGER),

    MODULE_PATH("--module-path -p", "opt.arg.path", "opt.modulepath", STANDARD, FILEMANAGER),

    UPGRADE_MODULE_PATH("--upgrade-module-path", "opt.arg.path", "opt.upgrademodulepath", STANDARD, FILEMANAGER),

    SYSTEM("--system", "opt.arg.jdk", "opt.system", STANDARD, FILEMANAGER),

    PATCH_MODULE("--patch-module", "opt.arg.patch", "opt.patch", EXTENDED, FILEMANAGER) {

        // The deferred filemanager diagnostics mechanism assumes a single value per option,

        // but --patch-module can be used multiple times, once per module. Therefore we compose

        // a value for the option containing the last value specified for each module, and separate

        // the the module=path pairs by an invalid path character, NULL.

        // The standard file manager code knows to split apart the NULL-separated components.

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            if (arg.isEmpty()) {

                throw helper.newInvalidValueException("err.no.value.for.option", option);

            } else if (getPattern().matcher(arg).matches()) {

                String prev = helper.get(PATCH_MODULE);

                if (prev == null) {

                    super.process(helper, option, arg);

                } else {

                    String argModulePackage = arg.substring(0, arg.indexOf('='));

                    boolean isRepeated = Arrays.stream(prev.split("\0"))

                            .map(s -> s.substring(0, s.indexOf('=')))

                            .collect(Collectors.toSet())

                            .contains(argModulePackage);

                    if (isRepeated) {

                        throw helper.newInvalidValueException("err.repeated.value.for.patch.module", argModulePackage);

                    } else {

                        super.process(helper, option, prev + '\0' + arg);

                    }

                }

            } else {

                throw helper.newInvalidValueException("err.bad.value.for.option", option, arg);

            }

        }

        @Override

        public Pattern getPattern() {

            return Pattern.compile("([^/]+)=(,*[^,].*)");

        }

    },

    BOOT_CLASS_PATH("--boot-class-path -bootclasspath", "opt.arg.path", "opt.bootclasspath", STANDARD, FILEMANAGER) {

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            helper.remove("-Xbootclasspath/p:");

            helper.remove("-Xbootclasspath/a:");

            super.process(helper, option, arg);

        }

    },

    XBOOTCLASSPATH_PREPEND("-Xbootclasspath/p:", "opt.arg.path", "opt.Xbootclasspath.p", EXTENDED, FILEMANAGER),

    XBOOTCLASSPATH_APPEND("-Xbootclasspath/a:", "opt.arg.path", "opt.Xbootclasspath.a", EXTENDED, FILEMANAGER),

    XBOOTCLASSPATH("-Xbootclasspath:", "opt.arg.path", "opt.bootclasspath", EXTENDED, FILEMANAGER) {

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            helper.remove("-Xbootclasspath/p:");

            helper.remove("-Xbootclasspath/a:");

            super.process(helper, "-bootclasspath", arg);

        }

    },

    EXTDIRS("-extdirs", "opt.arg.dirs", "opt.extdirs", STANDARD, FILEMANAGER),

    DJAVA_EXT_DIRS("-Djava.ext.dirs=", "opt.arg.dirs", "opt.extdirs", EXTENDED, FILEMANAGER) {

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            EXTDIRS.process(helper, "-extdirs", arg);

        }

    },

    ENDORSEDDIRS("-endorseddirs", "opt.arg.dirs", "opt.endorseddirs", STANDARD, FILEMANAGER),

    DJAVA_ENDORSED_DIRS("-Djava.endorsed.dirs=", "opt.arg.dirs", "opt.endorseddirs", EXTENDED, FILEMANAGER) {

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            ENDORSEDDIRS.process(helper, "-endorseddirs", arg);

        }

    },

    PROC("-proc:", "opt.proc.none.only", STANDARD, BASIC,  ONEOF, "none", "only"),

    PROCESSOR("-processor", "opt.arg.class.list", "opt.processor", STANDARD, BASIC),

    PROCESSOR_PATH("--processor-path -processorpath", "opt.arg.path", "opt.processorpath", STANDARD, FILEMANAGER),

    PROCESSOR_MODULE_PATH("--processor-module-path", "opt.arg.path", "opt.processormodulepath", STANDARD, FILEMANAGER),

    PARAMETERS("-parameters","opt.parameters", STANDARD, BASIC),

    D("-d", "opt.arg.directory", "opt.d", STANDARD, FILEMANAGER),

    S("-s", "opt.arg.directory", "opt.sourceDest", STANDARD, FILEMANAGER),

    H("-h", "opt.arg.directory", "opt.headerDest", STANDARD, FILEMANAGER),

    IMPLICIT("-implicit:", "opt.implicit", STANDARD, BASIC, ONEOF, "none", "class"),

    ENCODING("-encoding", "opt.arg.encoding", "opt.encoding", STANDARD, FILEMANAGER),

    SOURCE("-source", "opt.arg.release", "opt.source", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option, String operand) throws InvalidValueException {

            Source source = Source.lookup(operand);

            if (source == null) {

                throw helper.newInvalidValueException("err.invalid.source", operand);

            }

            super.process(helper, option, operand);

        }

    },

    TARGET("-target", "opt.arg.release", "opt.target", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option, String operand) throws InvalidValueException {

            Target target = Target.lookup(operand);

            if (target == null) {

                throw helper.newInvalidValueException("err.invalid.target", operand);

            }

            super.process(helper, option, operand);

        }

    },

    RELEASE("--release", "opt.arg.release", "opt.release", STANDARD, BASIC) {

        @Override

        protected void help(Log log) {

            Iterable<PlatformProvider> providers =

                    ServiceLoader.load(PlatformProvider.class, Arguments.class.getClassLoader());

            Set<String> platforms = StreamSupport.stream(providers.spliterator(), false)

                                                 .flatMap(provider -> StreamSupport.stream(provider.getSupportedPlatformNames()

                                                                                                   .spliterator(),

                                                                                           false))

                                                 .collect(Collectors.toCollection(TreeSet :: new));

            StringBuilder targets = new StringBuilder();

            String delim = "";

            for (String platform : platforms) {

                targets.append(delim);

                targets.append(platform);

                delim = ", ";

            }

            super.help(log, log.localize(PrefixKind.JAVAC, descrKey, targets.toString()));

        }

    },

    PROFILE("-profile", "opt.arg.profile", "opt.profile", STANDARD, BASIC) {

        @Override

        public void process(OptionHelper helper, String option, String operand) throws InvalidValueException {

            Profile profile = Profile.lookup(operand);

            if (profile == null) {

                throw helper.newInvalidValueException("err.invalid.profile", operand);

            }

            super.process(helper, option, operand);

        }

    },

    VERSION("--version -version", "opt.version", STANDARD, INFO) {

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

            log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "version", ownName,  JavaCompiler.version());

            super.process(helper, option);

        }

    },

    FULLVERSION("--full-version -fullversion", null, HIDDEN, INFO) {

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

            log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "fullVersion", ownName,  JavaCompiler.fullVersion());

            super.process(helper, option);

        }

    },

    // Note: -h is already taken for "native header output directory".

    HELP("--help -help", "opt.help", STANDARD, INFO) {

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

            log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "msg.usage.header", ownName);

            showHelp(log, OptionKind.STANDARD);

            log.printNewline(WriterKind.STDOUT);

            super.process(helper, option);

        }

    },

    A("-A", "opt.arg.key.equals.value", "opt.A", STANDARD, BASIC, ArgKind.ADJACENT) {

        @Override

        public boolean matches(String arg) {

            return arg.startsWith("-A");

        }

        @Override

        public boolean hasArg() {

            return false;

        }

        // Mapping for processor options created in

        // JavacProcessingEnvironment

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            int argLength = option.length();

            if (argLength == 2) {

                throw helper.newInvalidValueException("err.empty.A.argument");

            }

            int sepIndex = option.indexOf('=');

            String key = option.substring(2, (sepIndex != -1 ? sepIndex : argLength) );

            if (!JavacProcessingEnvironment.isValidOptionName(key)) {

                throw helper.newInvalidValueException("err.invalid.A.key", option);

            }

            helper.put(option, option);

        }

    },

    X("--help-extra -X", "opt.X", STANDARD, INFO) {

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            Log log = helper.getLog();

            showHelp(log, OptionKind.EXTENDED);

            log.printNewline(WriterKind.STDOUT);

            log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "msg.usage.nonstandard.footer");

            super.process(helper, option);

        }

    },

    // This option exists only for the purpose of documenting itself.

    // It's actually implemented by the launcher.

    J("-J", "opt.arg.flag", "opt.J", STANDARD, INFO, ArgKind.ADJACENT) {

        @Override

        public void process(OptionHelper helper, String option) {

            throw new AssertionError("the -J flag should be caught by the launcher.");

        }

    },

    MOREINFO("-moreinfo", null, HIDDEN, BASIC) {

        @Override

        public void process(OptionHelper helper, String option) throws InvalidValueException {

            Type.moreInfo = true;

            super.process(helper, option);

        }

    },

    // treat warnings as errors

    WERROR("-Werror", "opt.Werror", STANDARD, BASIC),

    // prompt after each error

    // new Option("-prompt",                                        "opt.prompt"),

    PROMPT("-prompt", null, HIDDEN, BASIC),

    // dump stack on error

    DOE("-doe", null, HIDDEN, BASIC),

    // output source after type erasure

    PRINTSOURCE("-printsource", null, HIDDEN, BASIC),

    // display warnings for generic unchecked operations

    WARNUNCHECKED("-warnunchecked", null, HIDDEN, BASIC) {

        @Override

        public void process(OptionHelper helper, String option) {

            helper.put("-Xlint:unchecked", option);

        }

    },

    XMAXERRS("-Xmaxerrs", "opt.arg.number", "opt.maxerrs", EXTENDED, BASIC),

    XMAXWARNS("-Xmaxwarns", "opt.arg.number", "opt.maxwarns", EXTENDED, BASIC),

    XSTDOUT("-Xstdout", "opt.arg.file", "opt.Xstdout", EXTENDED, INFO) {

        @Override

        public void process(OptionHelper helper, String option, String arg) throws InvalidValueException {

            try {

                Log log = helper.getLog();

                log.setWriters(new PrintWriter(new FileWriter(arg), true));

            } catch (java.io.IOException e) {

                throw helper.newInvalidValueException("err.error.writing.file", arg, e);

            }

            super.process(helper, option, arg);

        }

    },

    XPRINT("-Xprint", "opt.print", EXTENDED, BASIC),

    XPRINTROUNDS("-XprintRounds", "opt.printRounds", EXTENDED, BASIC),

    XPRINTPROCESSORINFO("-XprintProcessorInfo", "opt.printProcessorInfo", EXTENDED, BASIC),

    XPREFER("-Xprefer:", "opt.prefer", EXTENDED, BASIC, ONEOF, "source", "newer"),