/*
 * @(#)VisibleMemberMap.java	1.4 00/02/02
 *
 * Copyright 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * This software is the proprietary information of Sun Microsystems, Inc.  
 * Use is subject to license terms.
 * 
 */

package com.sun.tools.doclets;  

import com.sun.javadoc.*;
import java.lang.*;
import java.util.*;
import java.io.*;

/**
 * Algorithm:
 *
 * @author Atul M Dambalkar
 */
public class VisibleMemberMap {
    
    public static final int INNERCLASSES = 0;
    public static final int FIELDS = 1;
    public static final int CONSTRUCTORS = 2;
    public static final int METHODS = 3;

    public static final String STARTLEVEL = "start";

    /**
     * List of ClassDoc objects for which ClassMembers objects are built.
     */
    private final List visibleClasses = new ArrayList();

    /**
     * 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.
     */
    private final Map memberNameMap = new HashMap();

    /**
     * Map of class and it's ClassMembers object.
     */
    private final Map classMap = new HashMap();

    /**
     * Class whose visible members are requested.
     */
    private final ClassDoc classdoc;

    /**
     * Member kind: InnerClasses/Fields/Methods?
     */
    private final int kind; 

    /**
     * Deprected members should be excluded or not?
     */
    private final boolean nodepr;

    public VisibleMemberMap(ClassDoc classdoc, int kind, boolean nodepr) {
        this.classdoc = classdoc;
        this.nodepr = nodepr;
        this.kind = kind;
        new ClassMembers(classdoc, STARTLEVEL).build();
    }

    public List getVisibleClassesList() {
        sort(visibleClasses);
        return visibleClasses;
    }

    public List getMembersFor(ClassDoc cd) {
        ClassMembers clmembers = (ClassMembers)(classMap.get(cd));
        if (clmembers == null) {
            return new ArrayList();
        }
        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.
     */
    private void sort(List list) {               
        List classes = new ArrayList();
        List interfaces = new ArrayList();
  	for (int i = 0; i < list.size(); i++) {
            ClassDoc cd = (ClassDoc)list.get(i);
  	    if (cd.isClass()) {
                classes.add(cd);
	    } else {
                interfaces.add(cd);
            }
        }
        list.clear();
        list.addAll(classes);
        list.addAll(interfaces);
    }

    private void fillMemberLevelMap(List list, String level) {
	for (int i = 0; i < list.size(); i++) {
            ProgramElementDoc member = ((ProgramElementDoc)list.get(i));
            String membername = getDocName(member);
            Map memberLevelMap = (Map)(memberNameMap.get(membername));
            if (memberLevelMap == null) {
                memberLevelMap = new HashMap();
                memberNameMap.put(membername, memberLevelMap);
            } 
            memberLevelMap.put(member, level);
        }
    }

    /**
     * Return the name for each doc item. For example,
     * if the doc item is of type PackageDoc for "java.lang" return string 
     * "java.lang", if the doc item is ClassDoc for "java.lang.Object" return
     * string "java.lang.Object", if the doc item is MethodDoc for method
     * "wait()" in java.lang.Object class, then return string wait()". 
     *
     * @param  doc    Doc Item for which name to be returned.
     * @return String name string as described above.
     */
    protected static String getDocName(ProgramElementDoc doc) {
        if (doc.isMethod() || doc.isConstructor()) {
            return doc.name() + ((ExecutableMemberDoc)doc).signature();
        } else if (doc.isField()) {
            return doc.name();
        } else { // it's a class or interface
            return "clint" + doc.name();
        }
    }

    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.
         */
        private List members = new ArrayList();

        /**
         * Level/Depth of inheritance.
         */
        private String level;

        /**
         * Return list of inherited members from mapping class.
         *
         * @return List Inherited members.
         */
        public List getMembers() {
            return members;
        }

        private ClassMembers(ClassDoc mappingClass, String level) {
            this.mappingClass = mappingClass;
            this.level = level;
            if (!classMap.containsKey(mappingClass) && 
                   checkAccess(mappingClass)) { 
                classMap.put(mappingClass, this); 
                visibleClasses.add(mappingClass); 
	    }
	    /*if (kind == CONSTRUCTORS) {
		addMembers(mappingClass);
	    } else {
                mapClass(this);
            } */         
        } 

        private void build() {
            if (kind == CONSTRUCTORS) {
		addMembers(mappingClass);
	    } else {
                mapClass(this); 
            }          
        }

        private void mapClass(ClassMembers clmembers) {
  	    if (checkAccess(mappingClass)) {
                clmembers = this;
            }
            clmembers.addMembers(mappingClass);
            ClassDoc[] interfaces = mappingClass.interfaces();
            for (int i = 0; i < interfaces.length; i++) {
                String locallevel = level + (i + 1);
                ClassMembers cm = new ClassMembers(interfaces[i], locallevel);
                cm.mapClass(clmembers);             
            }
            if (mappingClass.isClass()) {
                ClassDoc superclass = mappingClass.superclass();
                if (superclass != null) {
                    ClassMembers cm = new ClassMembers(superclass, 
                                                       level + "c"); 
                    cm.mapClass(clmembers);
                }
            }
        }

        private boolean checkAccess(ClassDoc cd) {
            return cd.isPublic() || 
                   cd.isProtected() || 
                   (cd.isIncluded() && cd.isPackagePrivate());
        }

        /**
         * 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) {
            List cdmembers = getClassMembers(fromClass); 
            List incllist = new ArrayList();
            for (int i = 0; i < cdmembers.size(); i++) {
                ProgramElementDoc pgmelem =
                                  (ProgramElementDoc)(cdmembers.get(i));
                if (!found(members, pgmelem) &&
   	                isVisible(pgmelem) && 
                        !isOverridden(pgmelem, level)) {
                    incllist.add(pgmelem);
                }
            }
            members.addAll(incllist);
            fillMemberLevelMap(members, 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 isVisible(ProgramElementDoc pgmdoc) {
	     if (pgmdoc.containingClass() == mappingClass) {
                 return true;
             } else if (pgmdoc.isPrivate()) { 
                 return false; 
             } else if (pgmdoc.isPackagePrivate()) { 
                 return pgmdoc.containingClass().containingPackage() == 
                                             mappingClass.containingPackage(); 
             }  
             return true; 
         }

        /**
         * Return all available class members.
         */
        private List getClassMembers(ClassDoc cd) {
            ProgramElementDoc[] members = null;
            switch (kind) {
                case INNERCLASSES:                
                    members = cd.innerClasses();
                    break;
                case FIELDS:
                    members = cd.fields();
                    break;
                case CONSTRUCTORS:
                    members = cd.constructors();
                    break;
	        case METHODS:
                    members = cd.methods();
                    break;
	        default:
                    members = new ProgramElementDoc[0];
            }
	    if (nodepr) {
                return Util.excludeDeprecatedMembersAsList(members);
            }                
            return Util.asList(members);
        }

        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(getDocName(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)) { 
                   return true; 
                }   
            }
            return false; 
        } 
    }        
}