/*

 * Copyright (c) 1997, 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 jdk.javadoc.internal.doclets.toolkit;

import java.io.*;

import java.lang.ref.*;

import java.util.*;

import javax.lang.model.element.Element;

import javax.lang.model.element.ModuleElement;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.util.SimpleElementVisitor9;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import com.sun.source.util.DocTreePath;

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

import com.sun.tools.javac.util.DefinedBy.Api;

import jdk.javadoc.doclet.Doclet;

import jdk.javadoc.doclet.DocletEnvironment;

import jdk.javadoc.doclet.Reporter;

import jdk.javadoc.internal.doclets.toolkit.builders.BuilderFactory;

import jdk.javadoc.internal.doclets.toolkit.taglets.TagletManager;

import jdk.javadoc.internal.doclets.toolkit.util.DocFile;

import jdk.javadoc.internal.doclets.toolkit.util.DocFileFactory;

import jdk.javadoc.internal.doclets.toolkit.util.DocFileIOException;

import jdk.javadoc.internal.doclets.toolkit.util.DocletConstants;

import jdk.javadoc.internal.doclets.toolkit.util.Extern;

import jdk.javadoc.internal.doclets.toolkit.util.Group;

import jdk.javadoc.internal.doclets.toolkit.util.MetaKeywords;

import jdk.javadoc.internal.doclets.toolkit.util.SimpleDocletException;

import jdk.javadoc.internal.doclets.toolkit.util.TypeElementCatalog;

import jdk.javadoc.internal.doclets.toolkit.util.Utils;

import jdk.javadoc.internal.doclets.toolkit.util.Utils.Pair;

import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap;

import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap.GetterSetter;

import jdk.javadoc.internal.doclets.toolkit.util.VisibleMemberMap.Kind;

import static javax.tools.Diagnostic.Kind.*;

/**

 * Configure the output based on the options. Doclets should sub-class

 * BaseConfiguration, to configure and add their own options. This class contains

 * all user options which are supported by the 1.1 doclet and the standard

 * doclet.

 * <p>

 * <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 Atul Dambalkar.

 * @author Jamie Ho

 */

public abstract class BaseConfiguration {

    /**

     * The doclet that created this configuration.

     */

    public final Doclet doclet;

    /**

     * The factory for builders.

     */

    protected BuilderFactory builderFactory;

    /**

     * The taglet manager.

     */

    public TagletManager tagletManager;

    /**

     * The path to the builder XML input file.

     */

    public String builderXMLPath;

    /**

     * The default path to the builder XML.

     */

    public static final String DEFAULT_BUILDER_XML = "resources/doclet.xml";

    /**

     * The path to Taglets

     */

    public String tagletpath = null;

    /**

     * This is true if option "-serialwarn" is used. Defualt value is false to

     * suppress excessive warnings about serial tag.

     */

    public boolean serialwarn = false;

    /**

     * The specified amount of space between tab stops.

     */

    public int sourcetab;

    public String tabSpaces;

    /**

     * True if we should generate browsable sources.

     */

    public boolean linksource = false;

    /**

     * True if command line option "-nosince" is used. Default value is

     * false.

     */

    public boolean nosince = false;

    /**

     * True if we should recursively copy the doc-file subdirectories

     */

    public boolean copydocfilesubdirs = false;

    /**

     * Maintain backward compatibility with previous javadoc version

     */

    public boolean backwardCompatibility = true;

    /**

     * True if user wants to add member names as meta keywords.

     * Set to false because meta keywords are ignored in general

     * by most Internet search engines.

     */

    public boolean keywords = false;

    /**

     * The meta tag keywords instance.

     */

    public final MetaKeywords metakeywords;

    /**

     * The set of doc-file subdirectories to exclude

     */

    protected Set<String> excludedDocFileDirs;

    /**

     * The set of qualifiers to exclude

     */

    protected Set<String> excludedQualifiers;

    /**

     * The doclet environment.

     */

    public DocletEnvironment docEnv;

    /**

     * An utility class for commonly used helpers

     */

    public Utils utils;

    /**

     * All the temporary accessors to javac internals.

     */

    public WorkArounds workArounds;

    /**

     * Destination directory name, in which doclet will generate the entire

     * documentation. Default is current directory.

     */

    public String destDirName = "";

    /**

     * Destination directory name, in which doclet will copy the doc-files to.

     */

    public String docFileDestDirName = "";

    /**

     * Encoding for this document. Default is default encoding for this

     * platform.

     */

    public String docencoding = null;

    /**

     * True if user wants to suppress descriptions and tags.

     */

    public boolean nocomment = false;

    /**

     * Encoding for this document. Default is default encoding for this

     * platform.

     */

    public String encoding = null;

    /**

     * Generate author specific information for all the classes if @author

     * tag is used in the doc comment and if -author option is used.

     * <code>showauthor</code> is set to true if -author option is used.

     * Default is don't show author information.

     */

    public boolean showauthor = false;

    /**

     * Generate documentation for JavaFX getters and setters automatically

     * by copying it from the appropriate property definition.

     */

    public boolean javafx = false;

    /**

     * Generate version specific information for the all the classes

     * if @version tag is used in the doc comment and if -version option is

     * used. <code>showversion</code> is set to true if -version option is

     * used.Default is don't show version information.

     */

    public boolean showversion = false;

    /**

     * Allow JavaScript in doc comments.

     */

    private boolean allowScriptInComments = false;

    /**

     * Sourcepath from where to read the source files. Default is classpath.

     */

    public String sourcepath = "";

    /**

     * Generate modules documentation if more than one module is present.

     */

    public boolean showModules = false;

    /**

     * Don't generate deprecated API information at all, if -nodeprecated

     * option is used. <code>nodepracted</code> is set to true if

     * -nodeprecated option is used. Default is generate deprected API

     * information.

     */

    public boolean nodeprecated = false;

    /**

     * The catalog of classes specified on the command-line

     */

    public TypeElementCatalog typeElementCatalog;

    /**

     * True if user wants to suppress time stamp in output.

     * Default is false.

     */

    public boolean notimestamp = false;

    /**

     * The package grouping instance.

     */

    public final Group group = new Group(this);

    /**

     * The tracker of external package links.

     */

    public final Extern extern = new Extern(this);

    public Reporter reporter;

    public Locale locale;

    /**

     * Suppress all messages

     */

    public boolean quiet = false;

    // A list containing urls

    private final List<String> linkList = new ArrayList<>();

     // A list of pairs containing urls and package list

    private final List<Pair<String, String>> linkOfflineList = new ArrayList<>();

    public boolean dumpOnError = false;

    private List<Pair<String, String>> groupPairs;

    private final Map<TypeElement, EnumMap<Kind, Reference<VisibleMemberMap>>> typeElementMemberCache;

    public abstract Messages getMessages();

    public abstract Resources getResources();

    /**

     * Return the build date for the doclet.

     *

     * @return the build date

     */

    public abstract String getDocletSpecificBuildDate();

    /**

     * This method should be defined in all those doclets (configurations),

     * which want to derive themselves from this BaseConfiguration. This method

     * can be used to finish up the options setup.

     *

     * @return true if successful and false otherwise

     */

    public abstract boolean finishOptionSettings();

    public CommentUtils cmtUtils;

    /**

     * A sorted set of included packages.

     */

    public SortedSet<PackageElement> packages = null;

    public OverviewElement overviewElement;

    // The following three fields provide caches for use by all instances of VisibleMemberMap.

    public final Map<TypeElement, List<Element>> propertiesCache = new HashMap<>();

    public final Map<Element, Element> classPropertiesMap = new HashMap<>();

    public final Map<Element, GetterSetter> getterSetterMap = new HashMap<>();

    public DocFileFactory docFileFactory;

    /**

     * A sorted map, giving the (specified|included|other) packages for each module.

     */

    public SortedMap<ModuleElement, Set<PackageElement>> modulePackages;

    /**

     * The list of known modules, that should be documented.

     */

    public SortedSet<ModuleElement> modules;

    protected static final String sharedResourceBundleName =

            "jdk.javadoc.internal.doclets.toolkit.resources.doclets";

    /**

     * Constructs the configurations needed by the doclet.

     *

     * @param doclet the doclet that created this configuration

     */

    public BaseConfiguration(Doclet doclet) {

        this.doclet = doclet;

        excludedDocFileDirs = new HashSet<>();

        excludedQualifiers = new HashSet<>();

        setTabWidth(DocletConstants.DEFAULT_TAB_STOP_LENGTH);

        metakeywords = new MetaKeywords(this);

        groupPairs = new ArrayList<>(0);

        typeElementMemberCache = new HashMap<>();

    }

    private boolean initialized = false;

    protected void initConfiguration(DocletEnvironment docEnv) {

        if (initialized) {

            throw new IllegalStateException("configuration previously initialized");

        }

        initialized = true;

        this.docEnv = docEnv;

        overviewElement = new OverviewElement(docEnv);

        Splitter specifiedSplitter = new Splitter(docEnv, false);

        specifiedModuleElements = Collections.unmodifiableSet(specifiedSplitter.mset);

        specifiedPackageElements = Collections.unmodifiableSet(specifiedSplitter.pset);

        specifiedTypeElements = Collections.unmodifiableSet(specifiedSplitter.tset);

        Splitter includedSplitter = new Splitter(docEnv, true);

        includedModuleElements = Collections.unmodifiableSet(includedSplitter.mset);

        includedPackageElements = Collections.unmodifiableSet(includedSplitter.pset);

        includedTypeElements = Collections.unmodifiableSet(includedSplitter.tset);

    }

    /**

     * Return the builder factory for this doclet.

     *

     * @return the builder factory for this doclet.

     */

    public BuilderFactory getBuilderFactory() {

        if (builderFactory == null) {

            builderFactory = new BuilderFactory(this);

        }

        return builderFactory;

    }

    public Reporter getReporter() {

        return this.reporter;

    }

    private Set<ModuleElement> specifiedModuleElements;

    public Set<ModuleElement> getSpecifiedModuleElements() {

        return specifiedModuleElements;

    }

    private Set<PackageElement> specifiedPackageElements;

    public Set<PackageElement> getSpecifiedPackageElements() {

        return specifiedPackageElements;

    }

    private Set<TypeElement> specifiedTypeElements;

    public Set<TypeElement> getSpecifiedTypeElements() {

        return specifiedTypeElements;

    }

    private Set<ModuleElement> includedModuleElements;

    public Set<ModuleElement> getIncludedModuleElements() {

        return includedModuleElements;

    }

    private Set<PackageElement> includedPackageElements;

    public Set<PackageElement> getIncludedPackageElements() {

        return includedPackageElements;

    }

    private Set<TypeElement> includedTypeElements;

    public Set<TypeElement> getIncludedTypeElements() {

        return includedTypeElements;

    }

    private void initModules() {

        // Build the modules structure used by the doclet

        modules = new TreeSet<>(utils.makeModuleComparator());

        modules.addAll(getSpecifiedModuleElements());

        modulePackages = new TreeMap<>(utils.makeModuleComparator());

        for (PackageElement p : packages) {

            ModuleElement mdle = docEnv.getElementUtils().getModuleOf(p);

            if (mdle != null && !mdle.isUnnamed()) {

                Set<PackageElement> s = modulePackages

                        .computeIfAbsent(mdle, m -> new TreeSet<>(utils.makePackageComparator()));

                s.add(p);

            }

        }

        for (PackageElement p : getIncludedPackageElements()) {

            ModuleElement mdle = docEnv.getElementUtils().getModuleOf(p);

            if (mdle != null && !mdle.isUnnamed()) {

                Set<PackageElement> s = modulePackages

                        .computeIfAbsent(mdle, m -> new TreeSet<>(utils.makePackageComparator()));

                s.add(p);

            }

        }

        // add entries for modules which may not have exported packages

        modules.forEach((ModuleElement mdle) -> {

            modulePackages.computeIfAbsent(mdle, m -> Collections.emptySet());

        });

        modules.addAll(modulePackages.keySet());

        showModules = !modules.isEmpty();

        for (Set<PackageElement> pkgs : modulePackages.values()) {

            packages.addAll(pkgs);

        }

    }

    private void initPackages() {

        packages = new TreeSet<>(utils.makePackageComparator());

        // add all the included packages

        packages.addAll(includedPackageElements);

    }

    public Set<Doclet.Option> getSupportedOptions() {

        Resources resources = getResources();

        Doclet.Option[] options = {

                new Option(resources, "-author") {

                    @Override

                    public boolean process(String opt, List<String> args) {

                        showauthor = true;

                        return true;

                    }

                },

                new Option(resources, "-d", 1) {

                    @Override

                    public boolean process(String opt, List<String> args) {

                        destDirName = addTrailingFileSep(args.get(0));

                        return true;

                    }

                },

                new Option(resources, "-docencoding", 1) {

                    @Override

                    public boolean process(String opt, List<String> args) {