/*

 * Copyright (c) 1998, 2014, 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.doclets.internal.toolkit.util;

import java.util.*;

import com.sun.javadoc.*;

import com.sun.tools.doclets.formats.html.ConfigurationImpl;

/**

 * Map all class uses for a given class.

 *

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

 *

 * @since 1.2

 * @author Robert G. Field

 */

public class ClassUseMapper {

    private final ClassTree classtree;

    /**

     * Mapping of ClassDocs to set of PackageDoc used by that class.

     * Entries may be null.

     */

    public Map<String,Set<PackageDoc>> classToPackage = new HashMap<>();

    /**

     * Mapping of Annotations to set of PackageDoc that use the annotation.

     */

    public Map<String,List<PackageDoc>> classToPackageAnnotations = new HashMap<>();

    /**

     * Mapping of ClassDocs to set of ClassDoc used by that class.

     * Entries may be null.

     */

    public Map<String,Set<ClassDoc>> classToClass = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of ClassDoc which are direct or

     * indirect subclasses of that class.

     * Entries may be null.

     */

    public Map<String,List<ClassDoc>> classToSubclass = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of ClassDoc which are direct or

     * indirect subinterfaces of that interface.

     * Entries may be null.

     */

    public Map<String,List<ClassDoc>> classToSubinterface = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of ClassDoc which implement

     * this interface.

     * Entries may be null.

     */

    public Map<String,List<ClassDoc>> classToImplementingClass = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of FieldDoc declared as that class.

     * Entries may be null.

     */

    public Map<String,List<FieldDoc>> classToField = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of MethodDoc returning that class.

     * Entries may be null.

     */

    public Map<String,List<MethodDoc>> classToMethodReturn = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of MethodDoc having that class

     * as an arg.

     * Entries may be null.

     */

    public Map<String,List<ExecutableMemberDoc>> classToMethodArgs = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of MethodDoc which throws that class.

     * Entries may be null.

     */

    public Map<String,List<ExecutableMemberDoc>> classToMethodThrows = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of ConstructorDoc having that class

     * as an arg.

     * Entries may be null.

     */

    public Map<String,List<ExecutableMemberDoc>> classToConstructorArgs = new HashMap<>();

    /**

     * Mapping of ClassDocs to list of ConstructorDoc which throws that class.

     * Entries may be null.

     */

    public Map<String,List<ExecutableMemberDoc>> classToConstructorThrows = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to constructors that use them.

     */

    public Map<String,List<ConstructorDoc>> classToConstructorAnnotations = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to Constructor parameters that use them.

     */

    public Map<String,List<ExecutableMemberDoc>> classToConstructorParamAnnotation = new HashMap<>();

    /**

     * The mapping of ClassDocs to Constructor arguments that use them as type parameters.

     */

    public Map<String,List<ExecutableMemberDoc>> classToConstructorDocArgTypeParam = new HashMap<>();

    /**

     * The mapping of ClassDocs to ClassDocs that use them as type parameters.

     */

    public Map<String,List<ClassDoc>> classToClassTypeParam = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to ClassDocs that use them.

     */

    public Map<String,List<ClassDoc>> classToClassAnnotations = new HashMap<>();

    /**

     * The mapping of ClassDocs to ExecutableMemberDocs that use them as type parameters.

     */

    public Map<String,List<MethodDoc>> classToExecMemberDocTypeParam = new HashMap<>();

    /**

     * The mapping of ClassDocs to ExecutableMemberDocs arguments that use them as type parameters.

     */

    public Map<String,List<ExecutableMemberDoc>> classToExecMemberDocArgTypeParam = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to ExecutableMemberDocs that use them.

     */

    public Map<String,List<MethodDoc>> classToExecMemberDocAnnotations = new HashMap<>();

    /**

     * The mapping of ClassDocs to ExecutableMemberDocs that have return type

     * with type parameters of that class.

     */

    public Map<String,List<MethodDoc>> classToExecMemberDocReturnTypeParam = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to MethodDoc parameters that use them.

     */

    public Map<String,List<ExecutableMemberDoc>> classToExecMemberDocParamAnnotation = new HashMap<>();

    /**

     * The mapping of ClassDocs to FieldDocs that use them as type parameters.

     */

    public Map<String,List<FieldDoc>> classToFieldDocTypeParam = new HashMap<>();

    /**

     * The mapping of AnnotationTypeDocs to FieldDocs that use them.

     */

    public Map<String,List<FieldDoc>> annotationToFieldDoc = new HashMap<>();

    private final Utils utils;

    public ClassUseMapper(ConfigurationImpl configuration, ClassTree classtree) {

        RootDoc root = configuration.root;

        this.classtree = classtree;

        utils = configuration.utils;

        // Map subclassing, subinterfacing implementing, ...

        for (ClassDoc doc : classtree.baseclasses()) {

            subclasses(doc);

        }

        for (ClassDoc doc : classtree.baseinterfaces()) {

            // does subinterfacing as side-effect

            implementingClasses(doc);

        }

        // Map methods, fields, constructors using a class.

        ClassDoc[] classes = root.classes();

        for (ClassDoc aClass : classes) {

            PackageDoc pkg = aClass.containingPackage();

            mapAnnotations(classToPackageAnnotations, pkg, pkg);

            ClassDoc cd = aClass;

            mapTypeParameters(classToClassTypeParam, cd, cd);

            mapAnnotations(classToClassAnnotations, cd, cd);

            FieldDoc[] fields = cd.fields();

            for (FieldDoc fd : fields) {

                mapTypeParameters(classToFieldDocTypeParam, fd, fd);

                mapAnnotations(annotationToFieldDoc, fd, fd);

                if (!fd.type().isPrimitive()) {

                    add(classToField, fd.type().asClassDoc(), fd);

                }

            }

            ConstructorDoc[] cons = cd.constructors();

            for (ConstructorDoc con : cons) {

                mapAnnotations(classToConstructorAnnotations, con, con);

                mapExecutable(con);

            }

            MethodDoc[] meths = cd.methods();

            for (MethodDoc md : meths) {

                mapExecutable(md);

                mapTypeParameters(classToExecMemberDocTypeParam, md, md);

                mapAnnotations(classToExecMemberDocAnnotations, md, md);

                if (!(md.returnType().isPrimitive() || md.returnType() instanceof TypeVariable)) {

                    mapTypeParameters(classToExecMemberDocReturnTypeParam,

                                      md.returnType(), md);

                    add(classToMethodReturn, md.returnType().asClassDoc(), md);

                }

            }

        }

    }

    /**

     * Return all subclasses of a class AND fill-in classToSubclass map.

     */

    private Collection<ClassDoc> subclasses(ClassDoc cd) {

        Collection<ClassDoc> ret = classToSubclass.get(cd.qualifiedName());

        if (ret == null) {

            ret = new TreeSet<>(utils.makeComparatorForClassUse());

            SortedSet<ClassDoc> subs = classtree.subclasses(cd);

            if (subs != null) {

                ret.addAll(subs);

                for (ClassDoc sub : subs) {

                    ret.addAll(subclasses(sub));

                }

            }

            addAll(classToSubclass, cd, ret);

        }

        return ret;

    }

    /**

     * Return all subinterfaces of an interface AND fill-in classToSubinterface map.

     */

    private Collection<ClassDoc> subinterfaces(ClassDoc cd) {

        Collection<ClassDoc> ret = classToSubinterface.get(cd.qualifiedName());

        if (ret == null) {

            ret = new TreeSet<>(utils.makeComparatorForClassUse());

            SortedSet<ClassDoc> subs = classtree.subinterfaces(cd);

            if (subs != null) {

                ret.addAll(subs);

                for (ClassDoc sub : subs) {

                    ret.addAll(subinterfaces(sub));

                }

            }

            addAll(classToSubinterface, cd, ret);

        }

        return ret;

    }

    /**

     * Return all implementing classes of an interface (including

     * all subclasses of implementing classes and all classes

     * implementing subinterfaces) AND fill-in both classToImplementingClass

     * and classToSubinterface maps.

     */

    private Collection<ClassDoc> implementingClasses(ClassDoc cd) {

        Collection<ClassDoc> ret = classToImplementingClass.get(cd.qualifiedName());

        if (ret == null) {

            ret = new TreeSet<>(utils.makeComparatorForClassUse());

            SortedSet<ClassDoc> impl = classtree.implementingclasses(cd);

            if (impl != null) {

                ret.addAll(impl);

                for (ClassDoc anImpl : impl) {

                    ret.addAll(subclasses(anImpl));

                }

            }

            for (ClassDoc doc : subinterfaces(cd)) {

                ret.addAll(implementingClasses(doc));

            }

            addAll(classToImplementingClass, cd, ret);

        }

        return ret;

    }

    /**

     * Determine classes used by a method or constructor, so they can be

     * inverse mapped.

     */

    private void mapExecutable(ExecutableMemberDoc em) {

        boolean isConstructor = em.isConstructor();

        Set<Type> classArgs = new TreeSet<>(utils.makeTypeComparator());

        for (Parameter param : em.parameters()) {

            Type pcd = param.type();

            // ignore primitives and typevars, typevars are handled elsewhere

            if ((!param.type().isPrimitive()) && !(pcd instanceof TypeVariable)) {

                 // avoid dups

                if (classArgs.add(pcd)) {

                    add(isConstructor ? classToConstructorArgs : classToMethodArgs,

                            pcd.asClassDoc(), em);

                    mapTypeParameters(isConstructor

                                ? classToConstructorDocArgTypeParam

                                : classToExecMemberDocArgTypeParam,

                            pcd, em);

                }

            }

            mapAnnotations(isConstructor

                        ? classToConstructorParamAnnotation

                        : classToExecMemberDocParamAnnotation,

                    param, em);

        }

        for (ClassDoc anException : em.thrownExceptions()) {

            add(isConstructor ? classToConstructorThrows : classToMethodThrows,

                anException, em);

        }

    }

    private <T> List<T> refList(Map<String,List<T>> map, ClassDoc cd) {

        List<T> list = map.get(cd.qualifiedName());

        if (list == null) {

            list = new ArrayList<>();

            map.put(cd.qualifiedName(), list);

        }

        return list;

    }

    private Set<PackageDoc> packageSet(ClassDoc cd) {

        Set<PackageDoc> pkgSet = classToPackage.get(cd.qualifiedName());

        if (pkgSet == null) {

            pkgSet = new TreeSet<>();

            classToPackage.put(cd.qualifiedName(), pkgSet);

        }

        return pkgSet;

    }

    private Set<ClassDoc> classSet(ClassDoc cd) {

        Set<ClassDoc> clsSet = classToClass.get(cd.qualifiedName());

        if (clsSet == null) {

            clsSet = new TreeSet<>();

            classToClass.put(cd.qualifiedName(), clsSet);

        }

        return clsSet;

    }

    private <T extends ProgramElementDoc> void add(Map<String,List<T>> map, ClassDoc cd, T ref) {

        // add to specified map

        refList(map, cd).add(ref);

        // add ref's package to package map and class map

        packageSet(cd).add(ref.containingPackage());

        classSet(cd).add(ref instanceof MemberDoc?

                ((MemberDoc)ref).containingClass() :

                    (ClassDoc)ref);

    }

    private void addAll(Map<String,List<ClassDoc>> map, ClassDoc cd, Collection<ClassDoc> refs) {

        if (refs == null) {

            return;

        }

        // add to specified map

        refList(map, cd).addAll(refs);

        Set<PackageDoc> pkgSet = packageSet(cd);

        Set<ClassDoc> clsSet = classSet(cd);

        // add ref's package to package map and class map

        for (ClassDoc cls : refs) {

            pkgSet.add(cls.containingPackage());

            clsSet.add(cls);

        }

    }

    /**

     * Map the ClassDocs to the ProgramElementDocs that use them as

     * type parameters.

     *

     * @param map the map the insert the information into.

     * @param doc the doc whose type parameters are being checked.

     * @param holder the holder that owns the type parameters.

     */

    private <T extends ProgramElementDoc> void mapTypeParameters(Map<String,List<T>> map, Object doc,

            T holder) {

        TypeVariable[] typeVariables;

        if (doc instanceof ClassDoc) {

            typeVariables = ((ClassDoc) doc).typeParameters();

        } else if (doc instanceof WildcardType) {

            for (Type extendsBound : ((WildcardType) doc).extendsBounds()) {

                addTypeParameterToMap(map, extendsBound, holder);

            }

            for (Type superBound : ((WildcardType) doc).superBounds()) {

                addTypeParameterToMap(map, superBound, holder);

            }

            return;

        } else if (doc instanceof ParameterizedType) {

            for (Type typeArgument : ((ParameterizedType) doc).typeArguments()) {

                addTypeParameterToMap(map, typeArgument, holder);

            }

            return;

        } else if (doc instanceof ExecutableMemberDoc) {

            typeVariables = ((ExecutableMemberDoc) doc).typeParameters();

        } else if (doc instanceof FieldDoc) {

            Type fieldType = ((FieldDoc) doc).type();

            mapTypeParameters(map, fieldType, holder);

            return;

        } else {

            return;

        }

        for (TypeVariable typeVariable : typeVariables) {

            for (Type bound : typeVariable.bounds()) {

                addTypeParameterToMap(map, bound, holder);

            }

        }

    }

    /**

     * Map the AnnotationType to the ProgramElementDocs that use them as

     * type parameters.

     *

     * @param map the map the insert the information into.

     * @param doc the doc whose type parameters are being checked.

     * @param holder the holder that owns the type parameters.

     */

    private <T extends ProgramElementDoc> void mapAnnotations(Map<String,List<T>> map, Object doc,

            T holder) {

        AnnotationDesc[] annotations;

        boolean isPackage = false;

        if (doc instanceof ProgramElementDoc) {

            annotations = ((ProgramElementDoc) doc).annotations();

        } else if (doc instanceof PackageDoc) {

            annotations = ((PackageDoc) doc).annotations();

            isPackage = true;

        } else if (doc instanceof Parameter) {

            annotations = ((Parameter) doc).annotations();

        } else {

            throw new DocletAbortException("should not happen");

        }

        for (AnnotationDesc annotation : annotations) {

            AnnotationTypeDoc annotationDoc = annotation.annotationType();

            if (isPackage)

                refList(map, annotationDoc).add(holder);

            else

                add(map, annotationDoc, holder);

        }

    }

    /**

     * Map the AnnotationType to the ProgramElementDocs that use them as

     * type parameters.

     *

     * @param map the map the insert the information into.

     * @param doc the doc whose type parameters are being checked.

     * @param holder the holder that owns the type parameters.

     */

    private <T extends PackageDoc> void mapAnnotations(Map<String,List<T>> map, PackageDoc doc,

            T holder) {

        for (AnnotationDesc annotation : doc.annotations()) {

            AnnotationTypeDoc annotationDoc = annotation.annotationType();

            refList(map, annotationDoc).add(holder);

        }

    }

    private <T extends ProgramElementDoc> void addTypeParameterToMap(Map<String,List<T>> map, Type type,

            T holder) {

        if (type instanceof ClassDoc) {

            add(map, (ClassDoc) type, holder);

        } else if (type instanceof ParameterizedType) {

            add(map, ((ParameterizedType) type).asClassDoc(), holder);

        }

        mapTypeParameters(map, type, holder);

    }

}