/*

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

 *

 */

package sun.jvm.hotspot.jdi;

import java.io.*;

import com.sun.jdi.*;

import sun.jvm.hotspot.memory.SystemDictionary;

import sun.jvm.hotspot.oops.Instance;

import sun.jvm.hotspot.oops.InstanceKlass;

import sun.jvm.hotspot.oops.ArrayKlass;

import sun.jvm.hotspot.oops.JVMDIClassStatus;

import sun.jvm.hotspot.oops.Klass;

import sun.jvm.hotspot.oops.ObjArray;

import sun.jvm.hotspot.oops.Oop;

import sun.jvm.hotspot.oops.Symbol;

import sun.jvm.hotspot.oops.DefaultHeapVisitor;

import sun.jvm.hotspot.utilities.Assert;

import java.util.*;

import java.lang.ref.SoftReference;

public abstract class ReferenceTypeImpl extends TypeImpl

implements ReferenceType {

    protected Klass       saKlass;          // This can be an InstanceKlass or an ArrayKlass

    protected Symbol      typeNameSymbol;   // This is used in vm.classesByName to speedup search

    private int           modifiers = -1;

    private String        signature = null;

    private SoftReference sdeRef = null;

    private SoftReference fieldsCache;

    private SoftReference allFieldsCache;

    private SoftReference methodsCache;

    private SoftReference allMethodsCache;

    private SoftReference nestedTypesCache;

    private SoftReference methodInvokesCache;

    /* to mark when no info available */

    static final SDE NO_SDE_INFO_MARK = new SDE();

    protected ReferenceTypeImpl(VirtualMachine aVm, sun.jvm.hotspot.oops.Klass klass) {

        super(aVm);

        saKlass = klass;

        typeNameSymbol = saKlass.getName();

        if (Assert.ASSERTS_ENABLED) {

            Assert.that(typeNameSymbol != null, "null type name for a Klass");

        }

    }

    Symbol typeNameAsSymbol() {

        return typeNameSymbol;

    }

    Method getMethodMirror(sun.jvm.hotspot.oops.Method ref) {

        // SA creates new Method objects when they are referenced which means

        // that the incoming object might not be the same object as on our

        // even though it is the same method. So do an address compare by

        // calling equals rather than just reference compare.

        Iterator it = methods().iterator();

        while (it.hasNext()) {

            MethodImpl method = (MethodImpl)it.next();

            if (ref.equals(method.ref())) {

                return method;

            }

        }

        if (ref.getMethodHolder().equals(SystemDictionary.getMethodHandleKlass())) {

          // invoke methods are generated as needed, so make mirrors as needed

          List mis = null;

          if (methodInvokesCache == null) {

            mis = new ArrayList();

            methodInvokesCache = new SoftReference(mis);

          } else {

            mis = (List)methodInvokesCache.get();

          }

          it = mis.iterator();

          while (it.hasNext()) {

            MethodImpl method = (MethodImpl)it.next();

            if (ref.equals(method.ref())) {

              return method;

            }

          }

          MethodImpl method = MethodImpl.createMethodImpl(vm, this, ref);

          mis.add(method);

          return method;

        }

        throw new IllegalArgumentException("Invalid method id: " + ref);

    }

    public boolean equals(Object obj) {

        if ((obj != null) && (obj instanceof ReferenceTypeImpl)) {

            ReferenceTypeImpl other = (ReferenceTypeImpl)obj;

            return (ref().equals(other.ref())) &&

                (vm.equals(other.virtualMachine()));

        } else {

            return false;

        }

    }

    public int hashCode() {

        return saKlass.hashCode();

    }

    public int compareTo(ReferenceType refType) {

        /*

         * Note that it is critical that compareTo() == 0

         * implies that equals() == true. Otherwise, TreeSet

         * will collapse classes.

         *

         * (Classes of the same name loaded by different class loaders

         * or in different VMs must not return 0).

         */

        ReferenceTypeImpl other = (ReferenceTypeImpl)refType;

        int comp = name().compareTo(other.name());

        if (comp == 0) {

            Oop rf1 = ref();

            Oop rf2 = other.ref();

            // optimize for typical case: refs equal and VMs equal

            if (rf1.equals(rf2)) {

                // sequenceNumbers are always positive

                comp = vm.sequenceNumber -

                 ((VirtualMachineImpl)(other.virtualMachine())).sequenceNumber;

            } else {

                comp = rf1.getHandle().minus(rf2.getHandle()) < 0? -1 : 1;

            }

        }

        return comp;

    }

    public String signature() {

        if (signature == null) {

            signature = saKlass.signature();

        }

        return signature;

    }

    // refer to JvmtiEnv::GetClassSignature.

    // null is returned for array klasses.

    public String genericSignature() {

        if (saKlass instanceof ArrayKlass) {

            return null;

        } else {

            Symbol genSig = ((InstanceKlass)saKlass).getGenericSignature();

            return (genSig != null)? genSig.asString() : null;

        }

    }

    public ClassLoaderReference classLoader() {

      Instance xx = (Instance)(((InstanceKlass)saKlass).getClassLoader());

      return (ClassLoaderReferenceImpl)vm.classLoaderMirror(xx);

    }

    public boolean isPublic() {

        return((modifiers() & VMModifiers.PUBLIC) != 0);

    }

    public boolean isProtected() {

        return((modifiers() & VMModifiers.PROTECTED) != 0);

    }

    public boolean isPrivate() {

        return((modifiers() & VMModifiers.PRIVATE) != 0);

    }

    public boolean isPackagePrivate() {

        return !isPublic() && !isPrivate() && !isProtected();

    }

    public boolean isAbstract() {

        return((modifiers() & VMModifiers.ABSTRACT) != 0);

    }

    public boolean isFinal() {

        return((modifiers() & VMModifiers.FINAL) != 0);

    }

    public boolean isStatic() {

        return((modifiers() & VMModifiers.STATIC) != 0);

    }

    public boolean isPrepared() {

        return (saKlass.getClassStatus() & JVMDIClassStatus.PREPARED) != 0;

    }

    final void checkPrepared() throws ClassNotPreparedException {

        if (! isPrepared()) {

            throw new ClassNotPreparedException();

        }

    }

    public boolean isVerified() {

        return (saKlass.getClassStatus() & JVMDIClassStatus.VERIFIED) != 0;

    }

    public boolean isInitialized() {

        return (saKlass.getClassStatus() & JVMDIClassStatus.INITIALIZED) != 0;

    }

    public boolean failedToInitialize() {

        return (saKlass.getClassStatus() & JVMDIClassStatus.ERROR) != 0;

    }

    private boolean isThrowableBacktraceField(sun.jvm.hotspot.oops.Field fld) {

        // refer to JvmtiEnv::GetClassFields in jvmtiEnv.cpp.

        // We want to filter out java.lang.Throwable.backtrace (see 4446677).

        // It contains some methodOops that aren't quite real Objects.

        if (fld.getFieldHolder().getName().equals(vm.javaLangThrowable()) &&

            fld.getID().getName().equals("backtrace")) {

            return true;

        } else {

            return false;

        }

    }

    public final List fields() throws ClassNotPreparedException {

        List fields = (fieldsCache != null)? (List) fieldsCache.get() : null;

        if (fields == null) {

            checkPrepared();

            if (saKlass instanceof ArrayKlass) {

                fields = new ArrayList(0);

            } else {

                // Get a list of the sa Field types

                List saFields = ((InstanceKlass)saKlass).getImmediateFields();

                // Create a list of our Field types

                int len = saFields.size();

                fields = new ArrayList(len);

                for (int ii = 0; ii < len; ii++) {

                    sun.jvm.hotspot.oops.Field curField = (sun.jvm.hotspot.oops.Field)saFields.get(ii);

                    if (! isThrowableBacktraceField(curField)) {

                        fields.add(new FieldImpl(vm, this, curField));

                    }

                }

            }

            fields = Collections.unmodifiableList(fields);

            fieldsCache = new SoftReference(fields);

        }

        return fields;

    }

    public final List allFields() throws ClassNotPreparedException {

        List allFields = (allFieldsCache != null)? (List) allFieldsCache.get() : null;

        if (allFields == null) {

            checkPrepared();

            if (saKlass instanceof ArrayKlass) {

                // is 'length' a field of array klasses? To maintain

                // consistency with JVMDI-JDI we return 0 size.

                allFields = new ArrayList(0);

            } else {

                List saFields;

                // Get a list of the sa Field types

                saFields = ((InstanceKlass)saKlass).getAllFields();

                // Create a list of our Field types

                int len = saFields.size();

                allFields = new ArrayList(len);

                for (int ii = 0; ii < len; ii++) {

                    sun.jvm.hotspot.oops.Field curField = (sun.jvm.hotspot.oops.Field)saFields.get(ii);

                    if (! isThrowableBacktraceField(curField)) {

                        allFields.add(new FieldImpl(vm, vm.referenceType(curField.getFieldHolder()), curField));

                    }

                }

            }

            allFields = Collections.unmodifiableList(allFields);

            allFieldsCache = new SoftReference(allFields);

        }

        return allFields;

    }

    abstract List inheritedTypes();

    void addVisibleFields(List visibleList, Map visibleTable, List ambiguousNames) {

        List list = visibleFields();

        Iterator iter = list.iterator();

        while (iter.hasNext()) {

            Field field = (Field)iter.next();

            String name = field.name();

            if (!ambiguousNames.contains(name)) {

                Field duplicate = (Field)visibleTable.get(name);

                if (duplicate == null) {

                    visibleList.add(field);

                    visibleTable.put(name, field);

                } else if (!field.equals(duplicate)) {

                    ambiguousNames.add(name);

                    visibleTable.remove(name);

                    visibleList.remove(duplicate);

                } else {

                    // identical field from two branches; do nothing

                }

            }

        }

    }

    public final List visibleFields() throws ClassNotPreparedException {

        checkPrepared();

        /*

         * Maintain two different collections of visible fields. The

         * list maintains a reasonable order for return. The

         * hash map provides an efficient way to lookup visible fields

         * by name, important for finding hidden or ambiguous fields.

         */

        List visibleList = new ArrayList();

        Map  visibleTable = new HashMap();

        /* Track fields removed from above collection due to ambiguity */

        List ambiguousNames = new ArrayList();

        /* Add inherited, visible fields */

        List types = inheritedTypes();

        Iterator iter = types.iterator();

        while (iter.hasNext()) {

            /*

             * TO DO: Be defensive and check for cyclic interface inheritance

             */

            ReferenceTypeImpl type = (ReferenceTypeImpl)iter.next();

            type.addVisibleFields(visibleList, visibleTable, ambiguousNames);

        }

        /*

         * Insert fields from this type, removing any inherited fields they

         * hide.

         */

        List retList = new ArrayList(fields());

        iter = retList.iterator();

        while (iter.hasNext()) {

            Field field = (Field)iter.next();

            Field hidden = (Field)visibleTable.get(field.name());

            if (hidden != null) {

                visibleList.remove(hidden);

            }

        }

        retList.addAll(visibleList);

        return retList;

    }

   public final Field fieldByName(String fieldName) throws ClassNotPreparedException {

        java.util.List searchList;

        Field f;

        // visibleFields calls checkPrepared

        searchList = visibleFields();

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

            f = (Field)searchList.get(i);

            if (f.name().equals(fieldName)) {

                return f;

            }

        }

        //throw new NoSuchFieldException("Field '" + fieldName + "' not found in " + name());

        return null;

    }

    public final List methods() throws ClassNotPreparedException {

        List methods = (methodsCache != null)? (List) methodsCache.get() : null;

        if (methods == null) {

            checkPrepared();

            if (saKlass instanceof ArrayKlass) {

                methods = new ArrayList(0);

            } else {

                List saMethods;

                // Get a list of the SA Method types

                saMethods = ((InstanceKlass)saKlass).getImmediateMethods();

                // Create a list of our MethodImpl types

                int len = saMethods.size();

                methods = new ArrayList(len);

                for (int ii = 0; ii < len; ii++) {

                    methods.add(MethodImpl.createMethodImpl(vm, this, (sun.jvm.hotspot.oops.Method)saMethods.get(ii)));

                }

            }

            methods = Collections.unmodifiableList(methods);

            methodsCache = new SoftReference(methods);

        }

        return methods;

    }

    abstract List getAllMethods();

    public final List allMethods() throws ClassNotPreparedException {

        List allMethods = (allMethodsCache != null)? (List) allMethodsCache.get() : null;

        if (allMethods == null) {

            checkPrepared();

            allMethods = Collections.unmodifiableList(getAllMethods());

            allMethodsCache = new SoftReference(allMethods);

        }

        return allMethods;

    }

    /*

     * Utility method used by subclasses to build lists of visible

     * methods.

     */

    void addToMethodMap(Map methodMap, List methodList) {

        Iterator iter = methodList.iterator();

        while (iter.hasNext()) {

            Method method = (Method)iter.next();

            methodMap.put(method.name().concat(method.signature()), method);

        }

    }

    abstract void addVisibleMethods(Map methodMap);

    public final List visibleMethods() throws ClassNotPreparedException {

        checkPrepared();

        /*

         * Build a collection of all visible methods. The hash

         * map allows us to do this efficiently by keying on the

         * concatenation of name and signature.

         */

        //System.out.println("jj: RTI: Calling addVisibleMethods for:" + this);

        Map map = new HashMap();

        addVisibleMethods(map);

        /*

         * ... but the hash map destroys order. Methods should be

         * returned in a sensible order, as they are in allMethods().

         * So, start over with allMethods() and use the hash map

         * to filter that ordered collection.

         */

        //System.out.println("jj: RTI: Calling allMethods for:" + this);

        List list = new ArrayList(allMethods());

        //System.out.println("jj: allMethods = " + jjstr(list));

        //System.out.println("jj: map = " + map.toString());

        //System.out.println("jj: map = " + jjstr(map.values()));

        list.retainAll(map.values());

        //System.out.println("jj: map = " + jjstr(list));

        //System.exit(0);

        return list;

    }

    static Object prev;

    static public String jjstr(Collection cc) {

        StringBuffer buf = new StringBuffer();

        buf.append("[");

        Iterator i = cc.iterator();

        boolean hasNext = i.hasNext();

        while (hasNext) {

            Object o = i.next();

            if (prev == null) {

                prev = o;

            } else {

                System.out.println("prev == curr?" + prev.equals(o));

                System.out.println("prev == curr?" + (prev == o));

            }

            buf.append( o + "@" + o.hashCode());

            //buf.append( ((Object)o).toString());

            hasNext = i.hasNext();

            if (hasNext)

                buf.append(", ");

        }

        buf.append("]");

        return buf.toString();

    }

    public final List methodsByName(String name) throws ClassNotPreparedException {

        // visibleMethods calls checkPrepared

        List methods = visibleMethods();

        ArrayList retList = new ArrayList(methods.size());

        Iterator iter = methods.iterator();

        while (iter.hasNext()) {

            Method candidate = (Method)iter.next();

            if (candidate.name().equals(name)) {

                retList.add(candidate);

            }

        }

        retList.trimToSize();

        return retList;

    }

    public final List methodsByName(String name, String signature) throws ClassNotPreparedException {

        // visibleMethods calls checkPrepared

        List methods = visibleMethods();

        ArrayList retList = new ArrayList(methods.size());

        Iterator iter = methods.iterator();

        while (iter.hasNext()) {

            Method candidate = (Method)iter.next();

            if (candidate.name().equals(name) &&

                candidate.signature().equals(signature)) {

                retList.add(candidate);

            }

        }

        retList.trimToSize();

        return retList;

    }

    List getInterfaces() {

        List myInterfaces;

        if (saKlass instanceof ArrayKlass) {

            // Actually, JLS says arrays implement Cloneable and Serializable

            // But, JVMDI-JDI just returns 0 interfaces for arrays. We follow

            // the same for consistency.

            myInterfaces = new ArrayList(0);

        } else {

            // Get a list of the sa InstanceKlass types

            List saInterfaces = ((InstanceKlass)saKlass).getDirectImplementedInterfaces();

            // Create a list of our InterfaceTypes

            int len = saInterfaces.size();

            myInterfaces = new ArrayList(len);