/*

 * Copyright (c) 2013, 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.

 *

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

 */

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import javax.lang.model.element.Name;

import javax.lang.model.element.TypeElement;

import javax.tools.FileObject;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

import com.sun.source.util.JavacTask;

import com.sun.source.util.TaskEvent;

import com.sun.source.util.TaskListener;

import com.sun.source.util.Trees;

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

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

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

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

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

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

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

import com.sun.tools.javac.code.Scope.CompoundScope;

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

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

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

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

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

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

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

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

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

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

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

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

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

/**

 * Debug printer for javac internals, for when toString() just isn't enough.

 *

 * <p>

 * The printer provides an API to generate structured views of javac objects,

 * such as AST nodes, symbol, types and annotations. Various aspects of the

 * output can be configured, such as whether to show nulls, empty lists, or

 * a compressed representation of the source code. Visitors are used to walk

 * object hierarchies, and can be replaced with custom visitors if the default

 * visitors are not flexible enough.

 *

 * <p>

 * In general, nodes are printed with an initial line identifying the node

 * followed by indented lines for the child nodes. Currently, graphs are

 * represented by printing a spanning subtree.

 *

 * <p>

 * The printer can be accessed via a simple command-line utility,

 * which makes it easy to see the internal representation of source code,

 * such as simple test programs, during the compilation pipeline.

 *

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

 */

public class DPrinter {

    protected final PrintWriter out;

    protected final Trees trees;

    protected Printer printer;

    protected boolean showEmptyItems = true;

    protected boolean showNulls = true;

    protected boolean showPositions = false;

    protected boolean showSrc;

    protected boolean showTreeSymbols;

    protected boolean showTreeTypes;

    protected int maxSrcLength = 32;

    protected Locale locale = Locale.getDefault();

    protected static final String NULL = "#null";

    // <editor-fold defaultstate="collapsed" desc="Configuration">

    public static DPrinter instance(Context context) {

        DPrinter dp = context.get(DPrinter.class);

        if (dp == null) {

            dp = new DPrinter(context);

        }

        return dp;

    }

    protected DPrinter(Context context) {

        context.put(DPrinter.class, this);

        out = context.get(Log.outKey);

        trees = JavacTrees.instance(context);

    }

    public DPrinter(PrintWriter out, Trees trees) {

        this.out = out;

        this.trees = trees;

    }

    public DPrinter emptyItems(boolean showEmptyItems) {

        this.showEmptyItems = showEmptyItems;

        return this;

    }

    public DPrinter nulls(boolean showNulls) {

        this.showNulls = showNulls;

        return this;

    }

    public DPrinter positions(boolean showPositions) {

        this.showPositions = showPositions;

        return this;

    }

    public DPrinter source(boolean showSrc) {

        this.showSrc = showSrc;

        return this;

    }

    public DPrinter source(int maxSrcLength) {

        this.showSrc = true;

        this.maxSrcLength = maxSrcLength;

        return this;

    }

    public DPrinter treeSymbols(boolean showTreeSymbols) {

        this.showTreeSymbols = showTreeSymbols;

        return this;

    }

    public DPrinter treeTypes(boolean showTreeTypes) {

        this.showTreeTypes = showTreeTypes;

        return this;

    }

    public DPrinter typeSymbolPrinter(Printer p) {

        printer = p;

        return this;

    }

    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Printing">

    protected enum Details {

        /** A one-line non-recursive summary */

        SUMMARY,

        /** Multi-line, possibly recursive. */

        FULL

    };

    public void printAnnotations(String label, SymbolMetadata annotations) {

        printAnnotations(label, annotations, Details.FULL);

    }

    protected void printAnnotations(String label, SymbolMetadata annotations, Details details) {

        if (annotations == null) {

            printNull(label);

        } else {

            // no SUMMARY format currently available to use

            // use reflection to get at private fields

            Object DECL_NOT_STARTED = getField(null, SymbolMetadata.class, "DECL_NOT_STARTED");

            Object DECL_IN_PROGRESS = getField(null, SymbolMetadata.class, "DECL_IN_PROGRESS");

            Object attributes = getField(annotations, SymbolMetadata.class, "attributes");

            Object type_attributes = getField(annotations, SymbolMetadata.class, "type_attributes");

            if (!showEmptyItems) {

                if (attributes instanceof List && ((List) attributes).isEmpty()

                        && attributes != DECL_NOT_STARTED

                        && attributes != DECL_IN_PROGRESS

                        && type_attributes instanceof List && ((List) type_attributes).isEmpty())

                    return;

            }

            printString(label, hashString(annotations));

            indent(+1);

            if (attributes == DECL_NOT_STARTED)

                printString("attributes", "DECL_NOT_STARTED");

            else if (attributes == DECL_IN_PROGRESS)

                printString("attributes", "DECL_IN_PROGRESS");

            else if (attributes instanceof List)

                printList("attributes", (List) attributes);

            else

                printObject("attributes", attributes, Details.SUMMARY);

            if (attributes instanceof List)

                printList("type_attributes", (List) type_attributes);

            else

                printObject("type_attributes", type_attributes, Details.SUMMARY);

            indent(-1);

        }

    }

    public void printAttribute(String label, Attribute attr) {

        if (attr == null) {

            printNull(label);

        } else {

            printString(label, attr.getClass().getSimpleName());

            indent(+1);

            attr.accept(attrVisitor);

            indent(-1);

        }

    }

    public void printFileObject(String label, FileObject fo) {

        if (fo == null) {

            printNull(label);

        } else {

            printString(label, fo.getName());

        }

    }

    protected <T> void printImplClass(T item, Class<? extends T> stdImplClass) {

        if (item.getClass() != stdImplClass)

            printString("impl", item.getClass().getName());

    }

    public void printInt(String label, int i) {

        printString(label, String.valueOf(i));

    }

    public void printList(String label, List<?> list) {

        if (list == null) {

             printNull(label);

        } else if (!list.isEmpty() || showEmptyItems) {

            printString(label, "[" + list.size() + "]");

            indent(+1);

            int i = 0;

            for (Object item: list) {

                printObject(String.valueOf(i++), item, Details.FULL);

            }

            indent(-1);

        }

    }

    public void printName(String label, Name name) {

        if (name == null) {

            printNull(label);

        } else {

            printString(label, name.toString());

        }

    }

    public void printNull(String label) {

        if (showNulls)

            printString(label, NULL);

    }

    protected void printObject(String label, Object item, Details details) {

        if (item == null) {

            printNull(label);

        } else if (item instanceof Attribute) {

            printAttribute(label, (Attribute) item);

        } else if (item instanceof Symbol) {

            printSymbol(label, (Symbol) item, details);

        } else if (item instanceof Type) {

            printType(label, (Type) item, details);

        } else if (item instanceof JCTree) {

            printTree(label, (JCTree) item);

        } else if (item instanceof List) {

            printList(label, (List) item);

        } else if (item instanceof Name) {

            printName(label, (Name) item);

        } else {

            printString(label, String.valueOf(item));

        }

    }

    public void printScope(String label, Scope scope) {

        printScope(label, scope, Details.FULL);

    }

    public void printScope(String label, Scope scope, Details details) {

        if (scope == null) {

            printNull(label);

        } else {

            switch (details) {

                case SUMMARY: {

                    indent();

                    out.print(label);

                    out.print(": [");

                    String sep = "";

                    for (Symbol sym: scope.getElements()) {

                        out.print(sep);

                        out.print(sym.name);

                        sep = ",";

                    }

                    out.println("]");

                    break;

                }

                case FULL: {

                    indent();

                    out.println(label);

                    indent(+1);

                    printImplClass(scope, Scope.class);

                    printSymbol("owner", scope.owner, Details.SUMMARY);

                    printScope("next", scope.next, Details.SUMMARY);

                    printObject("shared", getField(scope, Scope.class, "shared"), Details.SUMMARY);

                    if (scope instanceof CompoundScope) {

                        printObject("subScopes",

                                getField(scope, CompoundScope.class, "subScopes"),

                                Details.FULL);

                    } else {

                        for (Symbol sym : scope.getElements()) {

                            printSymbol(sym.name.toString(), sym, Details.SUMMARY);

                        }

                    }

                    indent(-1);

                    break;

                }

            }

        }

    }

    public void printSource(String label, JCTree tree) {

        printString(label, Pretty.toSimpleString(tree, maxSrcLength));

    }

    public void printString(String label, String text) {

        indent();

        out.print(label);

        out.print(": ");

        out.print(text);

        out.println();

    }

    public void printSymbol(String label, Symbol symbol) {

        printSymbol(label, symbol, Details.FULL);

    }

    protected void printSymbol(String label, Symbol sym, Details details) {

        if (sym == null) {

            printNull(label);

        } else {

            switch (details) {

            case SUMMARY:

                printString(label, toString(sym));

                break;

            case FULL:

                indent();

                out.print(label);

                out.println(": " +

                        info(sym.getClass(),

                            String.format("0x%x--%s", sym.kind, Kinds.kindName(sym)),

                            sym.getKind())

                        + " " + sym.name

                        + " " + hashString(sym));

                indent(+1);

                if (showSrc) {

                    JCTree tree = (JCTree) trees.getTree(sym);

                    if (tree != null)

                        printSource("src", tree);

                }

                printString("flags", String.format("0x%x--%s",

                        sym.flags_field, Flags.toString(sym.flags_field)));

                printObject("completer", sym.completer, Details.SUMMARY); // what if too long?

                printSymbol("owner", sym.owner, Details.SUMMARY);

                printType("type", sym.type, Details.SUMMARY);

                printType("erasure", sym.erasure_field, Details.SUMMARY);

                sym.accept(symVisitor, null);

                indent(-1);

            }

        }

    }

    protected String toString(Symbol sym) {

        return (printer != null) ? printer.visit(sym, locale) : String.valueOf(sym);

    }

    protected void printTree(String label, JCTree tree) {

        if (tree == null) {

            printNull(label);

        } else {

            indent();

            String ext;

            try {

                ext = tree.getKind().name();

            } catch (Throwable t) {

                ext = "n/a";

            }

            out.print(label + ": " + info(tree.getClass(), tree.getTag(), ext));

            if (showPositions) {

                // We can always get start position, but to get end position

                // and/or line+offset, we would need a JCCompilationUnit

                out.print(" pos:" + tree.pos);

            }

            if (showTreeTypes && tree.type != null)

                out.print(" type:" + toString(tree.type));

            Symbol sym;

            if (showTreeSymbols && (sym = TreeInfo.symbolFor(tree)) != null)

                out.print(" sym:" + toString(sym));

            out.println();

            indent(+1);

            if (showSrc) {

                indent();

                out.println("src: " + Pretty.toSimpleString(tree, maxSrcLength));

            }

            tree.accept(treeVisitor);

            indent(-1);

        }

    }

    public void printType(String label, Type type) {

        printType(label, type, Details.FULL);

    }

    protected void printType(String label, Type type, Details details) {

        if (type == null)

            printNull(label);

        else {

            switch (details) {

                case SUMMARY:

                    printString(label, toString(type));

                    break;

                case FULL:

                    indent();

                    out.print(label);

                    out.println(": " + info(type.getClass(), type.getTag(), type.getKind())

                            + " " + hashString(type));

                    indent(+1);

                    printSymbol("tsym", type.tsym, Details.SUMMARY);

                    printObject("constValue", type.constValue(), Details.SUMMARY);

                    printObject("annotations", type.getAnnotationMirrors(), Details.SUMMARY);

                    type.accept(typeVisitor, null);

                    indent(-1);

            }

        }

    }

    protected String toString(Type type) {

        return (printer != null) ? printer.visit(type, locale) : String.valueOf(type);

    }

    protected String hashString(Object obj) {

        return String.format("#%x", obj.hashCode());

    }

    protected String info(Class<?> clazz, Object internal, Object external) {

        return String.format("%s,%s,%s", clazz.getSimpleName(), internal, external);

    }

    private int indent = 0;

    protected void indent() {

        for (int i = 0; i < indent; i++) {

            out.print("  ");

        }

    }

    protected void indent(int n) {

        indent += n;

    }

    protected Object getField(Object o, Class<?> clazz, String name) {

        try {

            Field f = clazz.getDeclaredField(name);

            boolean prev = f.isAccessible();

            f.setAccessible(true);

            try {

                return f.get(o);

            } finally {

                f.setAccessible(prev);

            }

        } catch (ReflectiveOperationException e) {

            return e;

        } catch (SecurityException e) {

            return e;

        }

    }