/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package flex.messaging.io;

import flex.messaging.MessageException;
import flex.messaging.io.amf.ASObject;
import flex.messaging.log.Log;
import flex.messaging.log.Logger;
import flex.messaging.util.ClassUtil;
import flex.messaging.util.ExceptionUtil;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.AbstractCollection;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * Uses Bean introspection to collect the properties for a given instance.
 */
public class BeanProxy extends AbstractProxy {
    static final long serialVersionUID = 7365078101695257715L;

    private static final int FAILED_PROPERTY_READ_ERROR = 10021;
    private static final int FAILED_PROPERTY_WRITE_ERROR = 10022;
    private static final int NON_READABLE_PROPERTY_ERROR = 10023;
    private static final int NON_WRITABLE_PROPERTY_ERROR = 10024;
    private static final int UNKNOWN_PROPERTY_ERROR = 10025;

    protected static final Map<Class, List<String>> rwPropertyNamesCache = new IdentityHashMap<Class, List<String>>();
    protected static final Map<Class, Map<String, BeanProperty>> rwBeanPropertyCache = new IdentityHashMap<Class, Map<String, BeanProperty>>();
    protected static final Map<Class, PropertyDescriptorCacheEntry> rwPropertyDescriptorCache = new IdentityHashMap<Class, PropertyDescriptorCacheEntry>();

    protected static final Map<Class, List<String>> roPropertyNamesCache = new IdentityHashMap<Class, List<String>>();
    protected static final Map<Class, Map<String, BeanProperty>> roBeanPropertyCache = new IdentityHashMap<Class, Map<String, BeanProperty>>();
    protected static final Map<Class, PropertyDescriptorCacheEntry> roPropertyDescriptorCache = new IdentityHashMap<Class, PropertyDescriptorCacheEntry>();

    protected boolean cacheProperties = true;
    protected boolean cachePropertiesDescriptors = true;
    protected Class stopClass = Object.class;

    protected static final Map ignoreProperties = new HashMap();

    static {
        initializeIgnoreProperties();
    }

    private static void initializeIgnoreProperties() {
        addIgnoreProperty(AbstractMap.class, "empty");
        addIgnoreProperty(AbstractCollection.class, "empty");
        addIgnoreProperty(ASObject.class, "type");
        addIgnoreProperty(Throwable.class, "stackTrace");
        addIgnoreProperty(File.class, "parentFile");
        addIgnoreProperty(File.class, "canonicalFile");
        addIgnoreProperty(File.class, "absoluteFile");
    }

    /**
     * Constructor.
     */
    public BeanProxy() {
        this(null);
    }

    /**
     * Construct a new BeanProxy with the provided default instance.
     *
     * @param defaultInstance defines the alias if provided
     */
    public BeanProxy(Object defaultInstance) {
        super(defaultInstance);

        // Override default behavior here... standard Map implementations
        // are treated as anonymous Objects, i.e. without an alias.
        if (defaultInstance != null)
            alias = getClassName(defaultInstance);
    }

    /**
     * {@inheritDoc}
     */
    public String getAlias(Object instance) {
        return getClassName(instance);
    }

    /**
     * {@inheritDoc}
     */
    public List getPropertyNames(Object instance) {
        if (instance == null)
            return null;

        Class c = instance.getClass();
        List<String> propertyNames = null;

        // Look up property names in cache if we don't have a custom serialization descriptor
        if (descriptor == null) {
            if (getIncludeReadOnly()) {
                synchronized (roPropertyNamesCache) {
                    propertyNames = roPropertyNamesCache.get(c);
                }
            } else {
                synchronized (rwPropertyNamesCache) {
                    propertyNames = rwPropertyNamesCache.get(c);
                }
            }
        }

        if (propertyNames != null)
            return propertyNames;

        // Make a copy of the property names to return
        propertyNames = new ArrayList<String>(getBeanProperties(instance).keySet());

        // Store property names in cache if we are caching properties
        // and we don't have a custom serialization descriptor
        if (cacheProperties && descriptor == null) {
            if (getIncludeReadOnly()) {
                synchronized (roPropertyNamesCache) {
                    roPropertyNamesCache.put(c, propertyNames);
                }
            } else {
                synchronized (rwPropertyNamesCache) {
                    rwPropertyNamesCache.put(c, propertyNames);
                }
            }
        }
        return propertyNames;
    }


    /**
     * {@inheritDoc}
     */
    public Class getType(Object instance, String propertyName) {
        if (instance == null || propertyName == null)
            return null;

        BeanProperty bp = getBeanProperty(instance, propertyName);
        return bp == null ? null : bp.getType();
    }

    /**
     * {@inheritDoc}
     */
    public Object getValue(Object instance, String propertyName) {
        if (instance == null || propertyName == null)
            return null;

        BeanProperty bp = getBeanProperty(instance, propertyName);
        if (bp != null)
            return getBeanValue(instance, bp);

        SerializationContext context = getSerializationContext();
        if (!ignorePropertyErrors(context)) {
            // Property '{propertyName}' not found on class '{alias}'.
            MessageException ex = new MessageException();
            ex.setMessage(UNKNOWN_PROPERTY_ERROR, new Object[]{propertyName, getAlias(instance)});
            throw ex;
        }
        return null;
    }

    /**
     * Gets the value specified by the BeanProperty.
     *
     * @param instance Object to get the value from
     * @param bp       the property to get
     * @return the value of the property if it exists
     */
    protected final Object getBeanValue(Object instance, BeanProperty bp) {
        String propertyName = bp.getName();
        if (bp.isRead()) {
            try {
                Object value = bp.get(instance);
                if (value != null && descriptor != null) {
                    SerializationDescriptor subDescriptor = (SerializationDescriptor) descriptor.get(propertyName);
                    if (subDescriptor != null) {
                        PropertyProxy subProxy = PropertyProxyRegistry.getProxyAndRegister(value);
                        subProxy = (PropertyProxy) subProxy.clone();
                        subProxy.setDescriptor(subDescriptor);
                        subProxy.setDefaultInstance(value);
                        value = subProxy;
                    }
                }
                return value;
            } catch (Exception e) {
                SerializationContext context = getSerializationContext();

                // Log failed property set errors
                if (Log.isWarn() && logPropertyErrors(context)) {
                    Logger log = Log.getLogger(LOG_CATEGORY);
                    log.warn("Failed to get property {0} on type {1}.",
                            new Object[]{propertyName, getAlias(instance)}, e);
                }

                if (!ignorePropertyErrors(context)) {
                    // Failed to get property '{propertyName}' on type '{className}'.
                    MessageException ex = new MessageException();
                    ex.setMessage(FAILED_PROPERTY_READ_ERROR, new Object[]{propertyName, getAlias(instance)});
                    ex.setRootCause(e);
                    throw ex;
                }
            }
        } else {
            SerializationContext context = getSerializationContext();
            if (!ignorePropertyErrors(context)) {
                //Property '{propertyName}' not readable from class '{alias}'.
                MessageException ex = new MessageException();
                ex.setMessage(NON_READABLE_PROPERTY_ERROR, new Object[]{propertyName, getAlias(instance)});
                throw ex;
            }
        }
        return null;
    }

    /**
     * {@inheritDoc}
     */
    public void setValue(Object instance, String propertyName, Object value) {
        BeanProperty bp = getBeanProperty(instance, propertyName);

        if (bp != null) {
            if (bp.isWrite()) {
                try {
                    Class desiredPropClass = bp.getType();
                    TypeMarshaller marshaller = TypeMarshallingContext.getTypeMarshaller();
                    value = marshaller.convert(value, desiredPropClass);
                    ClassUtil.validateAssignment(instance, propertyName, value);
                    bp.set(instance, value);
                } catch (Exception e) {
                    SerializationContext context = getSerializationContext();

                    // Log ignore failed property set errors
                    if (Log.isWarn() && logPropertyErrors(context)) {
                        Logger log = Log.getLogger(LOG_CATEGORY);
                        log.warn("Failed to set property {0} on type {1}.",
                                new Object[]{propertyName, getAlias(instance)}, e);
                    }

                    if (!ignorePropertyErrors(context)) {
                        // Failed to get property '{propertyName}' on type '{className}'.
                        MessageException ex = new MessageException();
                        ex.setMessage(FAILED_PROPERTY_WRITE_ERROR, new Object[]{propertyName, getAlias(instance)});
                        ex.setRootCause(e);
                        throw ex;
                    }
                }
            } else {
                SerializationContext context = getSerializationContext();

                if (Log.isWarn() && logPropertyErrors(context)) {
                    Logger log = Log.getLogger(LOG_CATEGORY);
                    log.warn("Property {0} not writable on class {1}",
                            new Object[]{propertyName, getAlias(instance)});
                }

                if (!ignorePropertyErrors(context)) {
                    //Property '{propertyName}' not writable on class '{alias}'.
                    MessageException ex = new MessageException();
                    ex.setMessage(NON_WRITABLE_PROPERTY_ERROR, new Object[]{propertyName, getAlias(instance)});
                    throw ex;
                }
            }
        } else {
            SerializationContext context = getSerializationContext();

            if (Log.isWarn() && logPropertyErrors(context)) {
                Logger log = Log.getLogger(LOG_CATEGORY);
                log.warn("Ignoring set property {0} for type {1} as a setter could not be found.",
                        new Object[]{propertyName, getAlias(instance)});
            }

            if (!ignorePropertyErrors(context)) {
                // Property '{propertyName}' not found on class '{alias}'.
                MessageException ex = new MessageException();
                ex.setMessage(UNKNOWN_PROPERTY_ERROR, new Object[]{propertyName, getAlias(instance)});
                throw ex;
            }
        }
    }

    /**
     * Are we ignoring property errors?
     *
     * @param context serialization paramters.
     * @return true if ignoring property errors.
     */
    protected boolean ignorePropertyErrors(SerializationContext context) {
        return context.ignorePropertyErrors;
    }

    /**
     * Should we log property errors?
     *
     * @param context serialization parameters.
     * @return true if we should log property errors.
     */
    protected boolean logPropertyErrors(SerializationContext context) {
        return context.logPropertyErrors;
    }

    /**
     * Determins the classname for both normal types via Class.getName() and
     * virtual types via ASObject.getType(). Virtual types starting
     * with the special ">" token are also handled and the underlying
     * className is returned.
     *
     * @param instance the object to examine.
     * @return the classname to use for instances of this type
     */
    protected String getClassName(Object instance) {
        String className;

        if (instance instanceof ASObject) {
            className = ((ASObject) instance).getType();
        } else if (instance instanceof ClassAlias) {
            className = ((ClassAlias) instance).getAlias();
        } else {
            className = instance.getClass().getName();
            // If there's an alias, use that as the class name.
            ClassAliasRegistry registry = ClassAliasRegistry.getRegistry();
            String aliasedClass = registry.getClassName(className);
            className = (aliasedClass == null) ? className : aliasedClass;
        }

        return className;
    }

    /**
     * Return a map of properties for a object.
     *
     * @param instance object to examine.
     * @return a map of Strings to BeanProperty objects.
     */
    protected Map<String, BeanProperty> getBeanProperties(Object instance) {
        Class c = instance.getClass();
        Map<String, BeanProperty> props;

        // look up instance class in cache if we don't have a custom descriptor.
        if (descriptor == null) {
            if (getIncludeReadOnly()) {
                synchronized (roBeanPropertyCache) {
                    props = roBeanPropertyCache.get(c);
                }
            } else {
                synchronized (rwBeanPropertyCache) {
                    props = rwBeanPropertyCache.get(c);
                }
            }
            if (props != null)
                return props;
        }

        props = new HashMap<String, BeanProperty>();
        PropertyDescriptor[] pds = getPropertyDescriptors(c);
        if (pds == null)
            return null;

        List excludes = null;
        if (descriptor != null) {
            excludes = descriptor.getExcludesForInstance(instance);
            if (excludes == null) // For compatibility with older implementations
                excludes = descriptor.getExcludes();
        }

        // Add standard bean properties first
        for (PropertyDescriptor pd : pds) {
            String propertyName = pd.getName();
            Method readMethod = pd.getReadMethod();
            Method writeMethod = pd.getWriteMethod();

            // If there's a public read method but no writeMethod and includeReadOnly
            // flag is off, then skip the property.
            if (readMethod != null && isPublicAccessor(readMethod.getModifiers()) && !getIncludeReadOnly() && writeMethod == null)
                continue;

            // Skip excluded and ignored properties as well.
            if ((excludes != null && excludes.contains(propertyName)) || isPropertyIgnored(c, propertyName))
                continue;

            // Ensure we don't include Object getClass() property, possibly returned (incorrectly) by custom BeanInfos
            if (getIncludeReadOnly() && writeMethod == null && "class".equals(propertyName))
                continue;

            // Skip any classloader properties
            final Class<?> type = pd.getPropertyType();
            if (type != null && ClassLoader.class.isAssignableFrom(type))
                continue;

            props.put(propertyName, new BeanProperty(propertyName, pd.getPropertyType(),
                    readMethod, writeMethod, null));
        }

        // Then add public fields to list if property does not already exist
        Field[] fields = instance.getClass().getFields();
        for (Field field : fields) {
            String propertyName = field.getName();
            int modifiers = field.getModifiers();
            if (isPublicField(modifiers) && !props.containsKey(propertyName)) {
                // Skip excluded and ignored properties.
                if ((excludes != null && excludes.contains(propertyName)) || isPropertyIgnored(c, propertyName))
                    continue;

                props.put(propertyName, new BeanProperty(propertyName, field.getType(), null, null, field));
            }
        }

        // Update the cache if we don't have a custom serialization descriptor and we are caching.
        if (descriptor == null && cacheProperties) {
            if (getIncludeReadOnly()) {
                synchronized (roBeanPropertyCache) {
                    roBeanPropertyCache.put(c, props);
                }
            } else {
                synchronized (rwBeanPropertyCache) {
                    rwBeanPropertyCache.put(c, props);
                }
            }
        }

        return props;
    }

    /**
     * Return true if this property is write only, which means we cannot get a value for it.
     *
     * @param instance     the instance
     * @param propertyName the property name
     * @return true if there is a way to write but not read the property
     */
    public boolean isWriteOnly(Object instance, String propertyName) {
        if (instance == null || propertyName == null)
            return false;

        BeanProperty bp = getBeanProperty(instance, propertyName);
        return bp != null && bp.isWrite() && !bp.isRead();
    }

    /**
     * Return a specific property descriptor for a named property.
     *
     * @param instance     the object to use.
     * @param propertyName the property to get.
     * @return a descriptor for the property.
     */
    protected final BeanProperty getBeanProperty(Object instance, String propertyName) {
        Class c = instance.getClass();
        Map props;

        // It is faster to use the BeanProperty cache if we are going to cache it.
        if (descriptor == null && cacheProperties) {
            props = getBeanProperties(instance);
            return props == null ? null : (BeanProperty) props.get(propertyName);
        }

        // Otherwise, just build up the property we are asked for
        PropertyDescriptorCacheEntry pce = getPropertyDescriptorCacheEntry(c);
        if (pce == null)
            return null;

        Object pType = pce.propertiesByName.get(propertyName);
        if (pType == null)
            return null;

        List excludes = null;
        if (descriptor != null) {
            excludes = descriptor.getExcludesForInstance(instance);
            if (excludes == null) // For compatibility with older implementations
                excludes = descriptor.getExcludes();
        }

        if (pType instanceof PropertyDescriptor) {
            PropertyDescriptor pd = (PropertyDescriptor) pType;

            Method readMethod = pd.getReadMethod();
            Method writeMethod = pd.getWriteMethod();

            // If there's a public read method but no writeMethod and includeReadOnly
            // flag is off, then skip the property.
            if (readMethod != null && isPublicAccessor(readMethod.getModifiers()) && !getIncludeReadOnly() && writeMethod == null)
                return null;

            // Skip excluded and ignored properties as well.
            if ((excludes != null && excludes.contains(propertyName)) || isPropertyIgnored(c, propertyName))
                return null;

            return new BeanProperty(propertyName, pd.getPropertyType(), readMethod, writeMethod, null);
        } else if (pType instanceof Field) {
            Field field = (Field) pType;

            String pName = field.getName();
            int modifiers = field.getModifiers();
            if (isPublicField(modifiers) && pName.equals(propertyName)) {
                // Skip excluded and ignored properties.
                return ((excludes != null && excludes.contains(propertyName)) || isPropertyIgnored(c, propertyName)) ?
                        null : new BeanProperty(propertyName, field.getType(), null, null, field);
            }
        }

        return null;
    }

    /**
     * Return an array of JavaBean property descriptors for a class.
     *
     * @param c the class to examine.
     * @return an array ot JavaBean PropertyDescriptors.
     */
    private PropertyDescriptor[] getPropertyDescriptors(Class c) {
        PropertyDescriptorCacheEntry pce = getPropertyDescriptorCacheEntry(c);
        return pce == null ? null : pce.propertyDescriptors;
    }

    /**
     * Return an entry from the property descriptor cache for a class.
     *
     * @param c the class
     * @return a descriptor cache entry or null
     */
    private PropertyDescriptorCacheEntry getPropertyDescriptorCacheEntry(Class c) {
        PropertyDescriptorCacheEntry pce;
        if (getIncludeReadOnly()) {
            synchronized (roPropertyDescriptorCache) {
                pce = roPropertyDescriptorCache.get(c);
            }
        } else {
            synchronized (rwPropertyDescriptorCache) {
                pce = rwPropertyDescriptorCache.get(c);
            }
        }

        try {
            if (pce == null) {
                BeanInfo beanInfo = Introspector.getBeanInfo(c, stopClass);
                pce = new PropertyDescriptorCacheEntry();
                pce.propertyDescriptors = beanInfo.getPropertyDescriptors();
                pce.propertiesByName = createPropertiesByNameMap(pce.propertyDescriptors, c.getFields());
                if (cachePropertiesDescriptors) {
                    if (getIncludeReadOnly()) {
                        synchronized (roPropertyDescriptorCache) {
                            roPropertyDescriptorCache.put(c, pce);
                        }
                    } else {
                        synchronized (rwPropertyDescriptorCache) {
                            rwPropertyDescriptorCache.put(c, pce);
                        }
                    }
                }
            }
        } catch (IntrospectionException ex) {
            // Log failed property set errors
            if (Log.isError()) {
                Logger log = Log.getLogger(LOG_CATEGORY);
                log.error("Failed to introspect object of type: " + c + " error: " + ExceptionUtil.toString(ex));
            }

            // Return an empty descriptor rather than crashing
            pce = new PropertyDescriptorCacheEntry();
            pce.propertyDescriptors = new PropertyDescriptor[0];
            pce.propertiesByName = new TreeMap();
        }
        return pce;
    }

    private Map createPropertiesByNameMap(PropertyDescriptor[] pds, Field[] fields) {
        Map m = new HashMap(pds.length);
        for (PropertyDescriptor pd : pds) {
            Method readMethod = pd.getReadMethod();
            if (readMethod != null && isPublicAccessor(readMethod.getModifiers()) &&
                    (getIncludeReadOnly() || pd.getWriteMethod() != null))
                m.put(pd.getName(), pd);
        }
        for (Field field : fields) {
            if (isPublicField(field.getModifiers()) && !m.containsKey(field.getName()))
                m.put(field.getName(), field);
        }
        return m;
    }

    /**
     * Is this property on the ignore list for this class?
     *
     * @param c            the class.
     * @param propertyName the property name.
     * @return true if we should ignore this property.
     */
    public static boolean isPropertyIgnored(Class c, String propertyName) {
        boolean result = false;
        Set propertyOwners = (Set) ignoreProperties.get(propertyName);
        if (propertyOwners != null) {
            while (c != null) {
                if (propertyOwners.contains(c)) {
                    result = true;
                    break;
                }
                c = c.getSuperclass();
            }
        }
        return result;
    }

    /**
     * Add a property to the ignore list for this class.
     *
     * @param c            the class.
     * @param propertyName the property to ignore.
     */
    public static void addIgnoreProperty(Class c, String propertyName) {
        synchronized (ignoreProperties) {
            Set propertyOwners = (Set) ignoreProperties.get(propertyName);
            if (propertyOwners == null) {
                propertyOwners = new HashSet();
                ignoreProperties.put(propertyName, propertyOwners);
            }
            propertyOwners.add(c);
        }
    }

    /**
     * Do the provided modifiers indicate that this is public?
     *
     * @param modifiers the flags to check
     * @return true if public but not final, static or transient.
     */
    public static boolean isPublicField(int modifiers) {
        return (Modifier.isPublic(modifiers) && !Modifier.isFinal(modifiers)
                && !Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers));
    }

    /**
     * Do the provided modifiers indicate that this is public?
     *
     * @param modifiers the flags to check
     * @return true if public but not static.
     */
    public static boolean isPublicAccessor(int modifiers) {
        return (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers));
    }

    /**
     * A class that holds information about a bean property.
     */
    protected static class BeanProperty {
        private String name;
        private Class type;
        private Method readMethod, writeMethod;
        private Field field;

        protected BeanProperty(String name, Class type, Method read, Method write, Field field) {
            this.name = name;
            this.type = type;
            this.writeMethod = write;
            this.readMethod = read;
            this.field = field;
        }

        /**
         * The name of the property..
         *
         * @return the name.
         */
        public String getName() {
            return name;
        }

        /**
         * The type of the property.
         *
         * @return the type
         */
        public Class getType() {
            return type;
        }

        /**
         * Is there a setter for this property?
         *
         * @return true if there is a write method.
         */
        public boolean isWrite() {
            return writeMethod != null || field != null;
        }

        /**
         * Is there a getter for this property?
         *
         * @return true if there is a read method.
         */
        public boolean isRead() {
            return readMethod != null || field != null;
        }

        /**
         * Returns the Class object that declared the public field or getter function.
         *
         * @return an object of the declaring class for the read method or null if the read method is undefined.
         */
        public Class getReadDeclaringClass() {
            if (readMethod != null)
                return readMethod.getDeclaringClass();
            if (field != null)
                return field.getDeclaringClass();
            return null;
        }

        /**
         * Return a class that represents the type of the property.
         *
         * @return the type of the property or null if there is no read method defined.
         */
        public Class getReadType() {
            if (readMethod != null)
                return readMethod.getReturnType();
            if (field != null)
                return field.getType();
            return null;
        }

        /**
         * Returns a string indicating the setter or field name of the property.
         * The setter is prefixed by 'method ', or the field is prefixed by 'field '.
         *
         * @return A string suitable for debugging.
         */
        public String getWriteName() {
            if (writeMethod != null)
                return "method " + writeMethod.getName();
            if (field != null)
                return "field " + field.getName();
            return null;
        }

        /**
         * Set the property of the object to the specified value.
         *
         * @param bean  the bean to set the property on.
         * @param value the value to set.
         * @throws IllegalAccessException    if no access.
         * @throws InvocationTargetException if the setter throws an exception.
         */
        public void set(Object bean, Object value) throws IllegalAccessException,
                InvocationTargetException {
            if (writeMethod != null)
                writeMethod.invoke(bean, value);
            else if (field != null)
                field.set(bean, value);
            else
                throw new MessageException("Setter not found for property " + name);
        }

        /**
         * Get the value of this property from the specified object.
         *
         * @param bean the object to retrieve the value from
         * @return the value of the property.
         * @throws IllegalAccessException    if no access.
         * @throws InvocationTargetException if the getter throws an exception.
         */
        public Object get(Object bean) throws IllegalAccessException, InvocationTargetException {
            Object obj = null;
            if (readMethod != null)
                obj = readMethod.invoke(bean, (Object[]) null);
            else if (field != null)
                obj = field.get(bean);
            return obj;
        }
    }

    /**
     * Clears all static caches.
     */
    public static void clear() {
        synchronized (ignoreProperties) {
            ignoreProperties.clear();
            initializeIgnoreProperties();  // reset to original state
        }
        synchronized (rwPropertyNamesCache) {
            rwPropertyNamesCache.clear();
        }
        synchronized (rwBeanPropertyCache) {
            rwBeanPropertyCache.clear();
        }
        synchronized (rwPropertyDescriptorCache) {
            rwPropertyDescriptorCache.clear();
        }
        synchronized (roPropertyNamesCache) {
            roPropertyNamesCache.clear();
        }
        synchronized (roBeanPropertyCache) {
            roBeanPropertyCache.clear();
        }
        synchronized (roPropertyDescriptorCache) {
            roPropertyDescriptorCache.clear();
        }
    }

    /**
     * A cache entry.
     */
    protected static class PropertyDescriptorCacheEntry {
        PropertyDescriptor[] propertyDescriptors;
        Map propertiesByName;
    }
}