/*

 * Copyright (c) 2000, 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 jdk.javadoc.internal.tool;

import java.lang.reflect.Modifier;

import java.util.*;

import javax.lang.model.element.Element;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.util.Elements;

import javax.lang.model.util.SimpleElementVisitor9;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import com.sun.source.util.DocTrees;

import com.sun.source.util.TreePath;

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

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

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

import com.sun.tools.javac.code.Kinds.Kind;

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

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

import com.sun.tools.javac.code.Symbol.ClassSymbol;

import com.sun.tools.javac.code.Symbol.CompletionFailure;

import com.sun.tools.javac.code.Symbol.MethodSymbol;

import com.sun.tools.javac.code.Symbol.ModuleSymbol;

import com.sun.tools.javac.code.Symbol.PackageSymbol;

import com.sun.tools.javac.code.Symbol.VarSymbol;

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

import com.sun.tools.javac.comp.AttrContext;

import com.sun.tools.javac.comp.Check;

import com.sun.tools.javac.comp.Enter;

import com.sun.tools.javac.comp.Env;

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

import com.sun.tools.javac.model.JavacElements;

import com.sun.tools.javac.model.JavacTypes;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.tree.JCTree.JCClassDecl;

import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;

import com.sun.tools.javac.tree.JCTree.JCPackageDecl;

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

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

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

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

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

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

import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;

/**

 * Holds the environment for a run of javadoc.

 * Holds only the information needed throughout the

 * run and not the compiler info that could be GC'ed

 * or ported.

 *

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

 * @author Scott Seligman (generics)

 */

        if (instance == null)

        return instance;

    }

    private final Messager messager;

    /** Predefined symbols known to the compiler. */

    public final Symtab syms;

    /** Referenced directly in RootDocImpl. */

    private final ClassFinder finder;

    /** Javadoc's own version of the compiler's enter phase. */

    final Enter enter;

    /** The name table. */

    private Names names;

    /** The encoding name. */

    private String encoding;

    final Symbol externalizableSym;

    /** Access filter (public, protected, ...).  */

    protected ModifierFilter filter;

    /**

     * True if we do not want to print any notifications at all.

     */

    boolean quiet = false;

    Check chk;

    com.sun.tools.javac.code.Types types;

    JavaFileManager fileManager;

    public final Context context;

    WeakHashMap<JCTree, TreePath> treePaths = new WeakHashMap<>();

    public final HashMap<PackageElement, JavaFileObject> pkgToJavaFOMap = new HashMap<>();

    /** Allow documenting from class files? */

    boolean docClasses = false;

    /**

     * The source language version.

     */

    public final Source source;

    public final Elements elements;

    public final JavacTypes typeutils;

    public final DocTrees docTrees;

    public final Map<Element, TreePath> elementToTreePath;

    /**

     * Constructor

     *

     * @param context      Context for this javadoc instance.

     */

        this.context = context;

        messager = Messager.instance0(context);

        syms = Symtab.instance(context);

        finder = JavadocClassFinder.instance(context);

        enter = JavadocEnter.instance(context);

        names = Names.instance(context);

        externalizableSym = syms.enterClass(syms.java_base, names.fromString("java.io.Externalizable"));

        chk = Check.instance(context);

        types = com.sun.tools.javac.code.Types.instance(context);

        fileManager = context.get(JavaFileManager.class);

        if (fileManager instanceof JavacFileManager) {

            ((JavacFileManager)fileManager).setSymbolFileEnabled(false);

        }

        docTrees = JavacTrees.instance(context);

        source = Source.instance(context);

        elements =  JavacElements.instance(context);

        typeutils = JavacTypes.instance(context);

        elementToTreePath = new HashMap<>();

    }

    public void intialize(String encoding,

            String showAccess,

            String overviewpath,

            List<String> javaNames,

            Iterable<? extends JavaFileObject> fileObjects,

            List<String> subPackages,

            List<String> excludedPackages,

            boolean docClasses,

            boolean quiet) {

        this.filter = ModifierFilter.getModifierFilter(showAccess);

        this.quiet = quiet;

        this.setEncoding(encoding);

        this.docClasses = docClasses;

    }

    /**

     * Load a class by qualified name.

     */

    public TypeElement loadClass(String name) {

        try {

            Name nameImpl = names.fromString(name);

            ModuleSymbol mod = syms.inferModule(Convert.packagePart(nameImpl));

            ClassSymbol c = finder.loadClass(mod != null ? mod : syms.errModule, nameImpl);

            return c;

        } catch (CompletionFailure ex) {

            chk.completionError(null, ex);

            return null;

        }

    }

    private boolean isSynthetic(long flags) {

        return (flags & Flags.SYNTHETIC) != 0;

    }

    private boolean isSynthetic(Symbol sym) {

        return isSynthetic(sym.flags_field);

    }

    SimpleElementVisitor9<Boolean, Void> shouldDocumentVisitor = null;

    public boolean shouldDocument(Element e) {

        if (shouldDocumentVisitor == null) {

            shouldDocumentVisitor = new SimpleElementVisitor9<Boolean, Void>() {

            @Override @DefinedBy(Api.LANGUAGE_MODEL)

            public Boolean visitType(TypeElement e, Void p) {

                return shouldDocument((ClassSymbol)e);

            }

            @Override @DefinedBy(Api.LANGUAGE_MODEL)

            public Boolean visitVariable(VariableElement e, Void p) {

                return shouldDocument((VarSymbol)e);

            }

            @Override @DefinedBy(Api.LANGUAGE_MODEL)

            public Boolean visitExecutable(ExecutableElement e, Void p) {

                return shouldDocument((MethodSymbol)e);

            }

        };

        }

        return shouldDocumentVisitor.visit(e);

    }

    /** Check whether this member should be documented. */

    public boolean shouldDocument(VarSymbol sym) {

        long mod = sym.flags();

        if (isSynthetic(mod)) {

            return false;

        }

        return filter.checkModifier(translateModifiers(mod));

    }

    /** Check whether this member should be documented. */

    public boolean shouldDocument(MethodSymbol sym) {

        long mod = sym.flags();

        if (isSynthetic(mod)) {

            return false;

        }

        return filter.checkModifier(translateModifiers(mod));

    }

    void setElementToTreePath(Element e, TreePath tree) {

        if (e == null || tree == null)

            return;

        elementToTreePath.put(e, tree);

    }

    private boolean hasLeaf(ClassSymbol sym) {

        TreePath path = elementToTreePath.get(sym);

        if (path == null)

            return false;

        return path.getLeaf() != null;

    }

    /** check whether this class should be documented. */

    public boolean shouldDocument(ClassSymbol sym) {

        return

            !isSynthetic(sym.flags_field) && // no synthetics

            (docClasses || hasLeaf(sym)) &&

            isVisible(sym);

    }

    //### Comment below is inaccurate wrt modifier filter testing

    /**

     * Check the visibility if this is an nested class.

     * if this is not a nested class, return true.

     * if this is an static visible nested class,

     *    return true.

     * if this is an visible nested class

     *    if the outer class is visible return true.

     *    else return false.

     * IMPORTANT: This also allows, static nested classes

     * to be defined inside an nested class, which is not

     * allowed by the compiler. So such an test case will

     * not reach upto this method itself, but if compiler

     * allows it, then that will go through.

     */

    public boolean isVisible(ClassSymbol sym) {

        long mod = sym.flags_field;

        if (!filter.checkModifier(translateModifiers(mod))) {

            return false;

        }

        ClassSymbol encl = sym.owner.enclClass();

        return (encl == null || (mod & Flags.STATIC) != 0 || isVisible(encl));

    }

    //---------------- print forwarders ----------------//

    // ERRORS

    /**

     * Print error message, increment error count.

     *

     * @param msg message to print.

     */

    public void printError(String msg) {

        messager.printError(msg);

    }

//    /**

//     * Print error message, increment error count.

//     *

//     * @param key selects message from resource

//     */

//    public void error(Element element, String key) {

//        if (element == null)

//            messager.error(key);

//        else

//            messager.error(element, key);

//    }

//

//    public void error(String prefix, String key) {

//        printError(prefix + ":" + messager.getText(key));

//    }

//

//    /**

//     * Print error message, increment error count.

//     *

//     * @param path the path to the source

//     * @param key selects message from resource

//     */

//    public void error(DocTreePath path, String key) {

//        messager.error(path, key);

//    }

//

//    /**

//     * Print error message, increment error count.

//     *

//     * @param path the path to the source

//     * @param msg message to print.

//     */

//    public void printError(DocTreePath path, String msg) {

//        messager.printError(path, msg);

//    }

//

//    /**

//     * Print error message, increment error count.

//     * @param e the target element

//     * @param msg message to print.

//     */

//    public void printError(Element e, String msg) {

//        messager.printError(e, msg);

//    }

    /**

     * Print error message, increment error count.

     *

     * @param element the source element

     * @param key selects message from resource

     * @param args replacement arguments

     */

    public void error(Element element, String key, String... args) {

        if (element == null)

            messager.error(key, (Object[]) args);

        else

            messager.error(element, key, (Object[]) args);

    }

    // WARNINGS

//    /**

//     * Print warning message, increment warning count.

//     *

//     * @param msg message to print.

//     */

//    public void printWarning(String msg) {

//        messager.printWarning(msg);

//    }

//

//    public void warning(String key) {

//        warning((Element)null, key);

//    }

    public void warning(String key, String... args) {

        warning((Element)null, key, args);

    }

//    /**

//     * Print warning message, increment warning count.

//     *

//     * @param element the source element

//     * @param key selects message from resource

//     */

//    public void warning(Element element, String key) {

//        if (element == null)

//            messager.warning(key);

//        else

//            messager.warning(element, key);

//    }

//

//    /**

//     * Print warning message, increment warning count.

//     *

//     * @param path the path to the source

//     * @param msg message to print.

//     */

//    public void printWarning(DocTreePath path, String msg) {

//        messager.printWarning(path, msg);

//    }

//

//    /**

//     * Print warning message, increment warning count.

//     *

//     * @param e  the source element

//     * @param msg message to print.

//     */

//    public void printWarning(Element e, String msg) {

//        messager.printWarning(e, msg);

//    }

    /**

     * Print warning message, increment warning count.

     *

     * @param e    the source element

     * @param key  selects message from resource

     * @param args the replace arguments

     */

    public void warning(Element e, String key, String... args) {

        if (e == null)

            messager.warning(key, (Object[]) args);

        else

            messager.warning(e, key, (Object[]) args);

    }

//    Note: no longer required

//    /**

//     * Print a message.

//     *

//     * @param msg message to print.

//     */

//    public void printNotice(String msg) {

//        if (quiet) {

//            return;

//        }

//        messager.printNotice(msg);

//    }

//  Note: no longer required

//    /**

//     * Print a message.

//     *

//     * @param e the source element

//     * @param msg message to print.

//     */

//    public void printNotice(Element e, String msg) {

//        if (quiet) {

//            return;

//        }

//        messager.printNotice(e, msg);

//    }

    //  NOTICES

    /**

     * Print a message.

     *

     * @param key selects message from resource

     */

    public void notice(String key) {

        if (quiet) {

            return;

        }

        messager.notice(key);

    }

//    Note: not used anymore

//    /**

//     * Print a message.

//     *

//     * @param path the path to the source

//     * @param msg message to print.

//     */

//    public void printNotice(DocTreePath path, String msg) {

//        if (quiet) {

//            return;

//        }