/*

 * Copyright (c) 2006, 2016, 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.util.Collections;

import java.util.EnumSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.ServiceLoader;

import java.util.Set;

import java.util.TreeSet;

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

/**

 * {@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 boolean process(OptionHelper helper, String option) {

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

            return false;

        }

    },

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

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

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

        @Override

            log.printRawLines(WriterKind.STDOUT,

                              String.format(LINT_KEY_FORMAT,

                                            "all",

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

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

                if (lc.hidden) continue;

                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(

        }

        @Override

        public boolean process(OptionHelper helper, String option) {

            String prev = helper.get(XDOCLINT_CUSTOM);

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

            return false;

        }

    },

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

        @Override

        public boolean matches(String option) {

            return DocLint.isValidOption(

        }

        @Override

        public boolean process(OptionHelper helper, String option) {

            String prev = helper.get(XDOCLINT_PACKAGE);

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

            return false;

        }

    },

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

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

        @Override

        public boolean process(OptionHelper helper, String option) {

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

            return false;

        }

    },

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

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

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

        @Override

        public boolean process(OptionHelper helper, String option) {

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

            return false;

        }

    },

        @Override

        public boolean process(OptionHelper helper, String option, String arg) {

        }

    },

        @Override

        public boolean process(OptionHelper helper, String option, String arg) {

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

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

            return 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 boolean process(OptionHelper helper, String option, String arg) {

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

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

            return 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 boolean process(OptionHelper helper, String option, String 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 boolean process(OptionHelper helper, String option, String arg) {

        }

    },

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

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

    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 boolean process(OptionHelper helper, String option, String operand) {

            Source source = Source.lookup(operand);

            if (source == null) {

                helper.error("err.invalid.source", operand);

                return true;

            }

            return super.process(helper, option, operand);

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option, String operand) {

            Target target = Target.lookup(operand);

            if (target == null) {

                helper.error("err.invalid.target", operand);

                return true;

            }

            return super.process(helper, option, operand);

        }

    },

        @Override

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

            }

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option, String operand) {

            Profile profile = Profile.lookup(operand);

            if (profile == null) {

                helper.error("err.invalid.profile", operand);

                return true;

            }

            return super.process(helper, option, operand);

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option) {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

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

            return super.process(helper, option);

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option) {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

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

            return super.process(helper, option);

        }

    },

        @Override

        public boolean process(OptionHelper helper, String option) {

            Log log = helper.getLog();

            String ownName = helper.getOwnName();

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

            log.printNewline(WriterKind.STDOUT);

            return super.process(helper, option);

        }

    },

        @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 boolean process(OptionHelper helper, String option) {

            int argLength = option.length();

            if (argLength == 2) {

                helper.error("err.empty.A.argument");

                return true;

            }

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

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

            if (!JavacProcessingEnvironment.isValidOptionName(key)) {

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

                return true;

            }

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option) {

            Log log = helper.getLog();

            log.printNewline(WriterKind.STDOUT);

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

            return super.process(helper, option);

        }

    },

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

    // It's actually implemented by the launcher.

        @Override

        public boolean process(OptionHelper helper, String option) {

            throw new AssertionError

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

        }

    },

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

        @Override

        public boolean process(OptionHelper helper, String option) {

            Type.moreInfo = true;

            return 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 boolean process(OptionHelper helper, String option) {

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

            return false;

        }

    },

    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 boolean process(OptionHelper helper, String option, String arg) {

            try {

                Log log = helper.getLog();

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

            } catch (java.io.IOException e) {

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

                return true;

            }

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

    XXUSERPATHSFIRST("-XXuserPathsFirst", "opt.userpathsfirst", HIDDEN, BASIC),

    // see enum PkgInfo

    XPKGINFO("-Xpkginfo:", "opt.pkginfo", EXTENDED, BASIC, ONEOF, "always", "legacy", "nonempty"),

    /* -O is a no-op, accepted for backward compatibility. */

    O("-O", null, HIDDEN, BASIC),

    /* -Xjcov produces tables to support the code coverage tool jcov. */

    XJCOV("-Xjcov", null, HIDDEN, BASIC),

    PLUGIN("-Xplugin:", "opt.arg.plugin", "opt.plugin", EXTENDED, BASIC) {

        @Override

        public boolean process(OptionHelper helper, String option) {

            String p = option.substring(option.indexOf(':') + 1).trim();

            String prev = helper.get(PLUGIN);

            return false;

        }