/*

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

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.nio.file.Path;

import java.text.BreakIterator;

import java.text.Collator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import com.sun.tools.javac.api.JavacTrees;

import com.sun.tools.javac.file.BaseFileManager;

import com.sun.tools.javac.file.JavacFileManager;

import com.sun.tools.javac.main.Arguments;

import com.sun.tools.javac.main.CommandLine;

import com.sun.tools.javac.main.OptionHelper;

import com.sun.tools.javac.main.OptionHelper.GrumpyHelper;

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

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

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

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

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

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

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

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

import jdk.javadoc.doclet.Doclet;

import jdk.javadoc.doclet.Doclet.Option;

import jdk.javadoc.doclet.DocletEnvironment;

import jdk.javadoc.internal.tool.Main.Result;

import static javax.tools.DocumentationTool.Location.*;

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

import static jdk.javadoc.internal.tool.Main.Result.*;

/**

 * Main program of Javadoc.

 * Previously named "Main".

 *

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

 *

 * @author Robert Field

 * @author Neal Gafter (rewrite)

 */

public class Start extends ToolOption.Helper {

    @SuppressWarnings("deprecation")

    private static final Class<?> OldStdDoclet =

            com.sun.tools.doclets.standard.Standard.class;

    private static final Class<?> StdDoclet =

            jdk.javadoc.doclets.StandardDoclet.class;

    /** Context for this invocation. */

    private final Context context;

    private static final String ProgramName = "javadoc";

    private Messager messager;

    private final String docletName;

    private final ClassLoader classLoader;

    private Class<?> docletClass;

    private Doclet doclet;

    // used to determine the locale for the messager

    private Locale locale;

    /**

     * In API mode, exceptions thrown while calling the doclet are

     * propagated using ClientCodeException.

     */

    private boolean apiMode;

    private JavaFileManager fileManager;

    Start() {

        this(null, null, null, null, null, null);

    }

    Start(PrintWriter outWriter, PrintWriter errWriter) {

        this(null, null, outWriter, errWriter, null, null);

    }

    Start(Context context, String programName,

            PrintWriter outWriter, PrintWriter errWriter,

            String docletName, ClassLoader classLoader) {

        this.context = context == null ? new Context() : context;

        String pname = programName == null ? ProgramName : programName;

        this.messager = (outWriter == null && errWriter == null)

                ? new Messager(this.context, pname)

                : new Messager(this.context, pname, outWriter, errWriter);

        this.docletName = docletName;

        this.classLoader = classLoader;

        this.docletClass = null;

        this.locale = Locale.getDefault();

    }

    public Start(Context context) {

        this.docletClass = null;

        this.context = Objects.requireNonNull(context);

        this.apiMode = true;

        this.docletName = null;

        this.classLoader = null;

        this.locale = Locale.getDefault();

    }

    void initMessager() {

        if (!apiMode)

            return;

        if (messager == null) {

            Log log = context.get(Log.logKey);

            if (log instanceof Messager) {

                messager = (Messager) log;

            } else {

                PrintWriter out = context.get(Log.errKey);

                messager = (out == null)

                        ? new Messager(context, ProgramName)

                        : new Messager(context, ProgramName, out, out);

            }

        }

    }

    /**

     * Usage

     */

    @Override

    void usage() {

        usage("main.usage", OptionKind.STANDARD, "main.usage.foot");

    }

    @Override

    void Xusage() {

        usage("main.Xusage", OptionKind.EXTENDED, "main.Xusage.foot");

    }

    private void usage(String headerKey, OptionKind kind, String footerKey) {

        messager.notice(headerKey);

        showToolOptions(kind);

        // let doclet print usage information

        if (docletClass != null) {

            String name = doclet.getName();

            messager.notice("main.doclet.usage.header", name);

            showDocletOptions(kind == OptionKind.EXTENDED

                    ? Option.Kind.EXTENDED

                    : Option.Kind.STANDARD);

        }

        if (footerKey != null)

            messager.notice(footerKey);

    }

    void showToolOptions(OptionKind kind) {

        Comparator<ToolOption> comp = new Comparator<ToolOption>() {

            final Collator collator = Collator.getInstance(Locale.US);

            { collator.setStrength(Collator.PRIMARY); }

            @Override

            public int compare(ToolOption o1, ToolOption o2) {

                return collator.compare(o1.primaryName, o2.primaryName);

            }

        };

        Stream.of(ToolOption.values())

                    .filter(opt -> opt.kind == kind)

                    .sorted(comp)

                    .forEach(this::showToolOption);

    }

    void showToolOption(ToolOption option) {

        List<String> names = option.getNames();

        String parameters;

        if (option.hasArg || option.primaryName.endsWith(":")) {

            String sep = (option == ToolOption.J) || option.primaryName.endsWith(":") ? "" : " ";

            parameters = sep + option.getParameters(messager);

        } else {

            parameters = "";

        }

        String description = option.getDescription(messager);

        showUsage(names, parameters, description);

    }

    void showDocletOptions(Option.Kind kind) {

        Comparator<Doclet.Option> comp = new Comparator<Doclet.Option>() {

            final Collator collator = Collator.getInstance(Locale.US);

            { collator.setStrength(Collator.PRIMARY); }

            @Override

            public int compare(Doclet.Option o1, Doclet.Option o2) {

                return collator.compare(o1.getNames().get(0), o2.getNames().get(0));

            }

        };

        doclet.getSupportedOptions().stream()

                .filter(opt -> opt.getKind() == kind)

                .sorted(comp)

                .forEach(this::showDocletOption);

    }

    void showDocletOption(Doclet.Option option) {

        List<String> names = option.getNames();

        String parameters;

        String optname = names.get(0);

        if (option.getArgumentCount() > 0 || optname.endsWith(":")) {

            String sep = optname.endsWith(":") ? "" : " ";

            parameters = sep + option.getParameters();

        } else {

            parameters = "";

        }

        String description = option.getDescription();

        showUsage(names, parameters, description);

    }

    // The following constants are intended to format the output to

    // be similar to that of the java launcher: i.e. "java -help".

    /** The indent for the option synopsis. */

    private static final String SMALL_INDENT = "    ";

    /** The automatic indent for the description. */

    private static final String LARGE_INDENT = "                  ";

    /** The space allowed for the synopsis, if the description is to be shown on the same line. */

    private static final int DEFAULT_SYNOPSIS_WIDTH = 13;

    /** The nominal maximum line length, when seeing if text will fit on a line. */

    private static final int DEFAULT_MAX_LINE_LENGTH = 80;

    /** The format for a single-line help entry. */

    private static final String COMPACT_FORMAT = SMALL_INDENT + "%-" + DEFAULT_SYNOPSIS_WIDTH + "s %s";

    void showUsage(List<String> names, String parameters, String description) {

        String synopses = names.stream()

                .map(s -> s + parameters)

                .collect(Collectors.joining(", "));

        // If option synopses and description fit on a single line of reasonable length,

        // display using COMPACT_FORMAT

        if (synopses.length() < DEFAULT_SYNOPSIS_WIDTH

                && !description.contains("\n")

                && (SMALL_INDENT.length() + DEFAULT_SYNOPSIS_WIDTH + 1 + description.length() <= DEFAULT_MAX_LINE_LENGTH)) {

            messager.printNotice(String.format(COMPACT_FORMAT, synopses, description));

            return;

        }

        // If option synopses fit on a single line of reasonable length, show that;

        // otherwise, show 1 per line

        if (synopses.length() <= DEFAULT_MAX_LINE_LENGTH) {

            messager.printNotice(SMALL_INDENT + synopses);

        } else {

            for (String name: names) {

                messager.printNotice(SMALL_INDENT + name + parameters);

            }

        }

        // Finally, show the description

        messager.printNotice(LARGE_INDENT + description.replace("\n", "\n" + LARGE_INDENT));

    }

    /**

     * Main program - external wrapper. In order to maintain backward

     * CLI  compatibility, we dispatch to the old tool or the old doclet's

     * Start mechanism, based on the options present on the command line

     * with the following precedence:

     *   1. presence of -Xold, dispatch to old tool

     *   2. doclet variant, if old, dispatch to old Start

     *   3. taglet variant, if old, dispatch to old Start

     *

     * Thus the presence of -Xold switches the tool, soon after command files

     * if any, are expanded, this is performed here, noting that the messager

     * is available at this point in time.

     * The doclet/taglet tests are performed in the begin method, further on,

     * this is to minimize argument processing and most importantly the impact

     * of class loader creation, needed to detect the doclet/taglet class variants.

     */

    @SuppressWarnings("deprecation")

    Result begin(String... argv) {

        // Preprocess @file arguments

        try {

            argv = CommandLine.parse(argv);

        } catch (IOException e) {

            error("main.cant.read", e.getMessage());

            return ERROR;

        }

        if (argv.length > 0 && "-Xold".equals(argv[0])) {

            warn("main.legacy_api");

            String[] nargv = Arrays.copyOfRange(argv, 1, argv.length);

            int rc = com.sun.tools.javadoc.Main.execute(

                    messager.programName,

                    messager.getWriter(WriterKind.ERROR),

                    messager.getWriter(WriterKind.WARNING),

                    messager.getWriter(WriterKind.NOTICE),

                    "com.sun.tools.doclets.standard.Standard",

                    nargv);

            return (rc == 0) ? OK : ERROR;

        }

        return begin(Arrays.asList(argv), Collections.emptySet());

    }

    // Called by 199 API.

    public boolean begin(Class<?> docletClass,

            Iterable<String> options,

            Iterable<? extends JavaFileObject> fileObjects) {

        this.docletClass = docletClass;

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

        for (String opt: options)

            opts.add(opt);

        return begin(opts, fileObjects).isOK();

    }

    @SuppressWarnings("deprecation")

    private Result begin(List<String> options, Iterable<? extends JavaFileObject> fileObjects) {

        fileManager = context.get(JavaFileManager.class);

        if (fileManager == null) {

            JavacFileManager.preRegister(context);

            fileManager = context.get(JavaFileManager.class);

            if (fileManager instanceof BaseFileManager) {

                ((BaseFileManager) fileManager).autoClose = true;

            }

        }

        // locale, doclet and maybe taglet, needs to be determined first

        try {

            docletClass = preprocess(fileManager, options);

        } catch (ToolException te) {

            if (!te.result.isOK()) {

                if (te.message != null) {

                    messager.printError(te.message);

                }

                Throwable t = te.getCause();

                dumpStack(t == null ? te : t);

            }

            return te.result;

        } catch (OptionException oe) {

            if (oe.message != null) {

                messager.printError(oe.message);

            }

            oe.m.run();

            Throwable t = oe.getCause();

            dumpStack(t == null ? oe : t);

            return oe.result;

        }

        if (jdk.javadoc.doclet.Doclet.class.isAssignableFrom(docletClass)) {

            // no need to dispatch to old, safe to init now

            initMessager();

            messager.setLocale(locale);

            try {

                Object o = docletClass.getConstructor().newInstance();

                doclet = (Doclet) o;

            } catch (ReflectiveOperationException exc) {

                if (apiMode) {

                    throw new ClientCodeException(exc);

                }

                error("main.could_not_instantiate_class", docletClass);

                return ERROR;

            }

        } else {

            if (apiMode) {

                com.sun.tools.javadoc.main.Start ostart

                        = new com.sun.tools.javadoc.main.Start(context);

                return ostart.begin(docletClass, options, fileObjects)

                        ? OK

                        : ERROR;

            }

            warn("main.legacy_api");

            String[] array = options.toArray(new String[options.size()]);

            int rc = com.sun.tools.javadoc.Main.execute(

                    messager.programName,

                    messager.getWriter(WriterKind.ERROR),

                    messager.getWriter(WriterKind.WARNING),

                    messager.getWriter(WriterKind.NOTICE),

                    "com.sun.tools.doclets.standard.Standard",

                    array);

            return (rc == 0) ? OK : ERROR;

        }

        Result result = OK;

        try {

        } catch (com.sun.tools.javac.main.Option.InvalidValueException e) {

            messager.printError(e.getMessage());

            Throwable t = e.getCause();

            dumpStack(t == null ? e : t);

            return ERROR;

        } catch (OptionException toe) {

            if (toe.message != null)

                messager.printError(toe.message);

            toe.m.run();

            Throwable t = toe.getCause();

            dumpStack(t == null ? toe : t);

            return toe.result;

        } catch (ToolException exc) {

            if (exc.message != null) {

                messager.printError(exc.message);

            }

            Throwable t = exc.getCause();

            if (result == ABNORMAL) {

                reportInternalError(t == null ? exc : t);

            } else {

                dumpStack(t == null ? exc : t);

            }

            return exc.result;

        } catch (OutOfMemoryError ee) {

            error("main.out.of.memory");

            result = SYSERR;

            dumpStack(ee);

        } catch (ClientCodeException e) {

            // simply rethrow these exceptions, to be caught and handled by JavadocTaskImpl

            throw e;

        } catch (Error | Exception ee) {

            error("main.fatal.error", ee);

            reportInternalError(ee);

            result = ABNORMAL;

        } finally {

            if (fileManager != null

                    && fileManager instanceof BaseFileManager

                    && ((BaseFileManager) fileManager).autoClose) {

                try {

                    fileManager.close();

                } catch (IOException ignore) {}

            }

            boolean haveErrorWarnings = messager.hasErrors()

                    || (rejectWarnings && messager.hasWarnings());

            if (!result.isOK() && !haveErrorWarnings) {

                // the doclet failed, but nothing reported, flag it!.

                error("main.unknown.error");

            }

            if (haveErrorWarnings && result.isOK()) {

                result = ERROR;

            }

            messager.printErrorWarningCounts();

            messager.flush();

        }

        return result;

    }

    private void reportInternalError(Throwable t) {

        messager.printErrorUsingKey("doclet.internal.report.bug");

        dumpStack(true, t);

    }

    private void dumpStack(Throwable t) {