/*

   * Copyright 2002-2008 the original author or authors.

   *

   * Licensed 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 org.springframework.beans;

 import java.beans.BeanInfo;

 import java.beans.IntrospectionException;

 import java.beans.Introspector;

 import java.beans.PropertyDescriptor;

 import java.lang.ref.Reference;

 import java.lang.ref.WeakReference;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.WeakHashMap;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.springframework.core.JdkVersion;

 import org.springframework.util.ClassUtils;

 public class CachedIntrospectionResults {

 	private static final Log logger = LogFactory.getLog(CachedIntrospectionResults.class);

	

 	static final Set acceptedClassLoaders = Collections.synchronizedSet(new HashSet());

	

 	static final Map classCache = Collections.synchronizedMap(new WeakHashMap());


	

 	public static void acceptClassLoader(ClassLoader classLoader) {

 		if (classLoader != null) {

 			acceptedClassLoaders.add(classLoader);

 		}

 	}

	

	public static void clearClassLoader(ClassLoader classLoader) {

		if (classLoader == null) {

			return;

		}

		synchronized (classCache) {

			for (Iterator it = classCache.keySet().iterator(); it.hasNext();) {

				Class beanClass = (Class) it.next();

				if (isUnderneathClassLoader(beanClass.getClassLoader(), classLoader)) {

					it.remove();

				}

			}

		}

		synchronized (acceptedClassLoaders) {

			for (Iterator it = acceptedClassLoaders.iterator(); it.hasNext();) {

				ClassLoader registeredLoader = (ClassLoader) it.next();

				if (isUnderneathClassLoader(registeredLoader, classLoader)) {

					it.remove();

				}

			}

		}

	}

	

	static CachedIntrospectionResults forClass(Class beanClass) throws BeansException {

		CachedIntrospectionResults results = null;

		Object value = classCache.get(beanClass);

		if (value instanceof Reference) {

			Reference ref = (Reference) value;

			results = (CachedIntrospectionResults) ref.get();

		}

		else {

			results = (CachedIntrospectionResults) value;

		}

		if (results == null) {

			// can throw BeansException

			results = new CachedIntrospectionResults(beanClass);

			if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||

					isClassLoaderAccepted(beanClass.getClassLoader())) {

				classCache.put(beanClass, results);

			}

			else {

				if (logger.isDebugEnabled()) {

					logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");

				}

				classCache.put(beanClass, new WeakReference(results));

			}

		}

		return results;

	}

	

	private static boolean isClassLoaderAccepted(ClassLoader classLoader) {

		// Iterate over array copy in order to avoid synchronization for the entire

		// ClassLoader check (avoiding a synchronized acceptedClassLoaders Iterator).

		Object[] acceptedLoaderArray = acceptedClassLoaders.toArray();

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

			ClassLoader registeredLoader = (ClassLoader) acceptedLoaderArray[i];

			if (isUnderneathClassLoader(classLoader, registeredLoader)) {

				return true;

			}

		}

		return false;

	}

	

	private static boolean isUnderneathClassLoader(ClassLoader candidate, ClassLoader parent) {

		if (candidate == null) {

			return false;

		}

		if (candidate == parent) {

			return true;

		}

		ClassLoader classLoaderToCheck = candidate;

		while (classLoaderToCheck != null) {

			classLoaderToCheck = classLoaderToCheck.getParent();

			if (classLoaderToCheck == parent) {

				return true;

			}

		}

		return false;

	}


	

	private final BeanInfo beanInfo;

	

	private final Map propertyDescriptorCache;


	

	private CachedIntrospectionResults(Class beanClass) throws BeansException {

		try {

			if (logger.isTraceEnabled()) {

				logger.trace("Getting BeanInfo for class [" + beanClass.getName() + "]");

			}

			this.beanInfo = Introspector.getBeanInfo(beanClass);

			// Immediately remove class from Introspector cache, to allow for proper

			// garbage collection on class loader shutdown - we cache it here anyway,

			// in a GC-friendly manner. In contrast to CachedIntrospectionResults,

			// Introspector does not use WeakReferences as values of its WeakHashMap!

			Class classToFlush = beanClass;

			do {

				Introspector.flushFromCaches(classToFlush);

				classToFlush = classToFlush.getSuperclass();

			}

			while (classToFlush != null);

			if (logger.isTraceEnabled()) {

				logger.trace("Caching PropertyDescriptors for class [" + beanClass.getName() + "]");

			}

			this.propertyDescriptorCache = new HashMap();

			// This call is slow so we do it once.

			PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();

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

				PropertyDescriptor pd = pds[i];

				if (logger.isTraceEnabled()) {

					logger.trace("Found bean property '" + pd.getName() + "'" +

							(pd.getPropertyType() != null ?

							" of type [" + pd.getPropertyType().getName() + "]" : "") +

							(pd.getPropertyEditorClass() != null ?

							"; editor [" + pd.getPropertyEditorClass().getName() + "]" : ""));

				}

				if (JdkVersion.isAtLeastJava15()) {

					pd = new GenericTypeAwarePropertyDescriptor(beanClass, pd.getName(),

							pd.getReadMethod(), pd.getWriteMethod(), pd.getPropertyEditorClass());

				}

				this.propertyDescriptorCache.put(pd.getName(), pd);

			}

		}

		catch (IntrospectionException ex) {

			throw new FatalBeanException("Cannot get BeanInfo for object of class [" + beanClass.getName() + "]", ex);

		}

	}

	BeanInfo getBeanInfo() {

		return this.beanInfo;

	}

	Class getBeanClass() {

		return this.beanInfo.getBeanDescriptor().getBeanClass();

	}

	PropertyDescriptor getPropertyDescriptor(String propertyName) {

		return (PropertyDescriptor) this.propertyDescriptorCache.get(propertyName);

	}

}