/*

 * Copyright 1999-2005 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.tools.doclets.internal.toolkit.util;

import com.sun.javadoc.*;

import com.sun.tools.doclets.internal.toolkit.*;

import java.util.*;

/**

 * A data structure that encapsulates the visible members of a particular

 * type for a given class tree.  To use this data structor, you must specify

 * the type of member you are interested in (nested class, field, constructor

 * or method) and the leaf of the class tree.  The data structure will map

 * all visible members in the leaf and classes above the leaf in the tree.

 *

 * This code is not part of an API.

 * It is implementation that is subject to change.

 * Do not use it as an API

 *

 * @author Atul M Dambalkar

 * @author Jamie Ho (rewrite)

 */

public class VisibleMemberMap {

    private boolean noVisibleMembers = true;

    public static final int INNERCLASSES    = 0;

    public static final int ENUM_CONSTANTS  = 1;

    public static final int FIELDS          = 2;

    public static final int CONSTRUCTORS    = 3;

    public static final int METHODS         = 4;

    public static final int ANNOTATION_TYPE_MEMBER_OPTIONAL = 5;

    public static final int ANNOTATION_TYPE_MEMBER_REQUIRED = 6;

    /**

     * The total number of member types is {@value}.

     */

    public static final int NUM_MEMBER_TYPES = 7;

    public static final String STARTLEVEL = "start";

    /**

     * List of ClassDoc objects for which ClassMembers objects are built.

     */

    /**

     * Map for each member name on to a map which contains members with same

     * name-signature. The mapped map will contain mapping for each MemberDoc

     * onto it's respecive level string.

     */

    /**

     * Map of class and it's ClassMembers object.

     */

    /**

     * Type whose visible members are requested.  This is the leaf of

     * the class tree being mapped.

     */

    private final ClassDoc classdoc;

    /**

     * Member kind: InnerClasses/Fields/Methods?

     */

    private final int kind;

    /**

     * Deprected members should be excluded or not?

     */

    private final boolean nodepr;

    /**

     * Construct a VisibleMemberMap of the given type for the given

     * class.  If nodepr is true, exclude the deprecated members from

     * the map.

     *

     * @param classdoc the class whose members are being mapped.

     * @param kind the kind of member that is being mapped.

     * @param nodepr if true, exclude the deprecated members from the map.

     */

    public VisibleMemberMap(ClassDoc classdoc, int kind, boolean nodepr) {

        this.classdoc = classdoc;

        this.nodepr = nodepr;

        this.kind = kind;

        new ClassMembers(classdoc, STARTLEVEL).build();

    }

    /**

     * Return the list of visible classes in this map.

     *

     * @return the list of visible classes in this map.

     */

    public List getVisibleClassesList() {

        sort(visibleClasses);

        return visibleClasses;

    }

    /**

     * Return the package private members inherited by the class.  Only return

     * if parent is package private and not documented.

     *

     * @param configuation the current configuration of the doclet.

     * @return the package private members inherited by the class.

     */

        for (Iterator iter = visibleClasses.iterator(); iter.hasNext(); ) {

            ClassDoc currentClass = (ClassDoc) iter.next();

            if (currentClass != classdoc &&

                currentClass.isPackagePrivate() &&

                !Util.isLinkable(currentClass, configuration)) {

                // Document these members in the child class because

                // the parent is inaccessible.

                results.addAll(getMembersFor(currentClass));

            }

        }

        return results;

    }

    /**

     * Return the visible members of the class being mapped.  Also append at the

     * end of the list members that are inherited by inaccessible parents. We

     * document these members in the child because the parent is not documented.

     *

     * @param configuation the current configuration of the doclet.

     */

        result.addAll(getInheritedPackagePrivateMethods(configuration));

        return result;

    }

    /**

     * Retrn the list of members for the given class.

     *

     * @param cd the class to retrieve the list of visible members for.

     *

     * @return the list of members for the given class.

     */

        if (clmembers == null) {

        }

        return clmembers.getMembers();

    }

    /**

     * Sort the given mixed list of classes and interfaces to a list of

     * classes followed by interfaces traversed. Don't sort alphabetically.

     */

        for (int i = 0; i < list.size(); i++) {

            if (cd.isClass()) {

                classes.add(cd);

            } else {

                interfaces.add(cd);

            }

        }

        list.clear();

        list.addAll(classes);

        list.addAll(interfaces);

    }

        for (int i = 0; i < list.size(); i++) {

            if (memberLevelMap == null) {

                memberNameMap.put(key, memberLevelMap);

            }

            memberLevelMap.put(list.get(i), level);

        }

    }

    private void purgeMemberLevelMap(List list, String level) {

        for (int i = 0; i < list.size(); i++) {

            Object key = getMemberKey((ProgramElementDoc)list.get(i));

            Map memberLevelMap = (Map) memberNameMap.get(key);

            if (level.equals(memberLevelMap.get(list.get(i))))

                memberLevelMap.remove(list.get(i));

        }

    }

    /**

     * Represents a class member.  We should be able to just use a

     * ProgramElementDoc instead of this class, but that doesn't take

     * type variables in consideration when comparing.

     */

    private class ClassMember {

        public ClassMember(ProgramElementDoc programElementDoc) {

            members.add(programElementDoc);

        }

        public void addMember(ProgramElementDoc programElementDoc) {

            members.add(programElementDoc);

        }

        public boolean isEqual(MethodDoc member) {

            for (Iterator iter = members.iterator(); iter.hasNext(); ) {

                MethodDoc member2 = (MethodDoc) iter.next();

                if (Util.executableMembersEqual(member, member2)) {

                    members.add(member);

                        return true;

                }

            }

            return false;

        }

    }

    /**

     * A data structure that represents the class members for

     * a visible class.

     */

    private class ClassMembers {

        /**

         * The mapping class, whose inherited members are put in the

         * {@link #members} list.

         */

        private ClassDoc mappingClass;

        /**

         * List of inherited members from the mapping class.

         */

        /**

         * Level/Depth of inheritance.

         */

        private String level;

        /**

         * Return list of inherited members from mapping class.

         *

         * @return List Inherited members.

         */

            return members;

        }

        private ClassMembers(ClassDoc mappingClass, String level) {

            this.mappingClass = mappingClass;

            this.level = level;

            if (classMap.containsKey(mappingClass) &&

                //Remove lower level class so that it can be replaced with

                //same class found at higher level.

                purgeMemberLevelMap(getClassMembers(mappingClass, false),

                classMap.remove(mappingClass);

                visibleClasses.remove(mappingClass);

            }

            if (!classMap.containsKey(mappingClass)) {

                classMap.put(mappingClass, this);

                visibleClasses.add(mappingClass);

            }

        }

        private void build() {

            if (kind == CONSTRUCTORS) {

                addMembers(mappingClass);

            } else {

                mapClass();

            }

        }

        private void mapClass() {

            addMembers(mappingClass);

            ClassDoc[] interfaces = mappingClass.interfaces();

            for (int i = 0; i < interfaces.length; i++) {

                String locallevel = level + 1;

                ClassMembers cm = new ClassMembers(interfaces[i], locallevel);

                cm.mapClass();

            }

            if (mappingClass.isClass()) {

                ClassDoc superclass = mappingClass.superclass();

                if (!(superclass == null || mappingClass.equals(superclass))) {

                    ClassMembers cm = new ClassMembers(superclass,

                                                       level + "c");

                    cm.mapClass();

                }

            }

        }

        /**

         * Get all the valid members from the mapping class. Get the list of

         * members for the class to be included into(ctii), also get the level

         * string for ctii. If mapping class member is not already in the

         * inherited member list and if it is visible in the ctii and not

         * overridden, put such a member in the inherited member list.

         * Adjust member-level-map, class-map.

         */

        private void addMembers(ClassDoc fromClass) {

            for (int i = 0; i < cdmembers.size(); i++) {

                if (!found(members, pgmelem) &&

                    memberIsVisible(pgmelem) &&

                    !isOverridden(pgmelem, level)) {

                    incllist.add(pgmelem);

                }

            }

            if (incllist.size() > 0) {

                noVisibleMembers = false;

            }

            members.addAll(incllist);

            fillMemberLevelMap(getClassMembers(fromClass, false), level);

        }

        /**

         * Is given doc item visible in given classdoc in terms fo inheritance?

         * The given doc item is visible in the given classdoc if it is public

         * or protected and if it is package-private if it's containing class

         * is in the same package as the given classdoc.

         */

        private boolean memberIsVisible(ProgramElementDoc pgmdoc) {

            if (pgmdoc.containingClass().equals(classdoc)) {

                //Member is in class that we are finding visible members for.

                //Of course it is visible.

                return true;

            } else if (pgmdoc.isPrivate()) {

                //Member is in super class or implemented interface.

                //Private, so not inherited.

                return false;

            } else if (pgmdoc.isPackagePrivate()) {

                //Member is package private.  Only return true if its class is in

                //same package.

                return pgmdoc.containingClass().containingPackage().equals(

                    classdoc.containingPackage());

            } else {

                //Public members are always inherited.

                return true;

            }

        }

        /**

         * Return all available class members.

         */

            if (cd.isEnum() && kind == CONSTRUCTORS) {

                //If any of these rules are hit, return empty array because

                //we don't document these members ever.

                return Arrays.asList(new ProgramElementDoc[] {});

            }

            ProgramElementDoc[] members = null;

            switch (kind) {

                case ANNOTATION_TYPE_MEMBER_OPTIONAL:

                    members = cd.isAnnotationType() ?

                        filter((AnnotationTypeDoc) cd, false) :

                        new AnnotationTypeElementDoc[] {};

                    break;

                case ANNOTATION_TYPE_MEMBER_REQUIRED:

                    members = cd.isAnnotationType() ?

                        filter((AnnotationTypeDoc) cd, true) :

                        new AnnotationTypeElementDoc[] {};

                    break;

                case INNERCLASSES:

                    members = cd.innerClasses(filter);

                    break;

                case ENUM_CONSTANTS:

                    members = cd.enumConstants();

                    break;

                case FIELDS:

                    members = cd.fields(filter);

                    break;

                case CONSTRUCTORS:

                    members = cd.constructors();

                    break;

                case METHODS:

                    members = cd.methods(filter);

                    break;

                default:

                    members = new ProgramElementDoc[0];

            }

            if (nodepr) {

                return Util.excludeDeprecatedMembersAsList(members);

            }

            return Arrays.asList(members);

        }

        /**

         * Filter the annotation type members and return either the required

         * members or the optional members, depending on the value of the

         * required parameter.

         *

         * @param doc The annotation type to process.

         * @param required

         * @return the annotation type members and return either the required

         * members or the optional members, depending on the value of the

         * required parameter.

         */

        private AnnotationTypeElementDoc[] filter(AnnotationTypeDoc doc,

            boolean required) {

            for (int i = 0; i < members.length; i++) {

                if ((required && members[i].defaultValue() == null) ||

                     ((!required) && members[i].defaultValue() != null)){

                    targetMembers.add(members[i]);

                }

            }

        }

        private boolean found(List list, ProgramElementDoc elem) {

            for (int i = 0; i < list.size(); i++) {

                ProgramElementDoc pgmelem = (ProgramElementDoc)list.get(i);

                if (Util.matches(pgmelem, elem)) {

                    return true;

                }

            }

            return false;

        }

        /**

         * Is member overridden? The member is overridden if it is found in the

         * same level hierarchy e.g. member at level "11" overrides member at

         * level "111".

         */

        private boolean isOverridden(ProgramElementDoc pgmdoc, String level) {

            Map memberLevelMap = (Map) memberNameMap.get(getMemberKey(pgmdoc));

            if (memberLevelMap == null)

                return false;

            String mappedlevel = null;

            Iterator iterator = memberLevelMap.values().iterator();

            while (iterator.hasNext()) {

                mappedlevel = (String)(iterator.next());

                if (mappedlevel.equals(STARTLEVEL) ||

                    (level.startsWith(mappedlevel) &&

                     !level.equals(mappedlevel))) {

                    return true;

                }

            }

            return false;

        }

    }

    /**

     * Return true if this map has no visible members.

     *

     * @return true if this map has no visible members.

     */

    public boolean noVisibleMembers() {

        return noVisibleMembers;

    }

    private ClassMember getClassMember(MethodDoc member) {

        for (Iterator iter = memberNameMap.keySet().iterator(); iter.hasNext();) {

            Object key = iter.next();

            if (key instanceof String) {

                continue;

            } else if (((ClassMember) key).isEqual(member)) {

                return (ClassMember) key;

            }

        }

        return new ClassMember(member);

    }

    /**

     * Return the key to the member map for the given member.

     */

    private Object getMemberKey(ProgramElementDoc doc) {

        if (doc.isConstructor()) {

            return doc.name() + ((ExecutableMemberDoc)doc).signature();

        } else if (doc.isMethod()) {

            return getClassMember((MethodDoc) doc);

        } else if (doc.isField() || doc.isEnumConstant() || doc.isAnnotationTypeElement()) {

            return doc.name();

        } else { // it's a class or interface

            String classOrIntName = doc.name();

            //Strip off the containing class name because we only want the member name.

            classOrIntName = classOrIntName.indexOf('.') != 0 ? classOrIntName.substring(classOrIntName.lastIndexOf('.'), classOrIntName.length()) : classOrIntName;

            return "clint" + classOrIntName;

        }

    }

}