/******************************************************************************
 * Copyright (c) 2002, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.common.core.service;

import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.Platform;
import org.eclipse.gmf.runtime.common.core.internal.CommonCorePlugin;
import org.eclipse.gmf.runtime.common.core.internal.CommonCoreStatusCodes;
import org.eclipse.gmf.runtime.common.core.util.Log;
import org.osgi.framework.Bundle;

import com.ibm.icu.util.StringTokenizer;

/**
 * Concrete subclasses can be used to assist in parsing service provider
 * descriptors to filter out and delay loading of service providers that do not
 * apply.
 * <P>
 * This abstract class contains a set of useful utilities for such concrete
 * subclasses.
 * 
 * @author melaasar, mmostafa
 */
public class AbstractProviderConfiguration {
	/**
	 * The name of the 'object' XML attribute.
	 */
	protected static final String OBJECT = "object"; //$NON-NLS-1$
	
	/**
	 * The name of the 'id' XML attribute.
	 */
	protected static final String ID = "id"; //$NON-NLS-1$
	
	/**
	 * The name of the 'class' XML attribute.
	 */
	protected static final String CLASS = "class"; //$NON-NLS-1$
 
	/**
	 * The name of the 'method' XML attribute.
	 */
	protected static final String METHOD = "method"; //$NON-NLS-1$
	
	/**
	 * The name of the 'method' XML attribute.
	 */
	protected static final String STATIC_METHOD = "staticMethod"; //$NON-NLS-1$
	
	/**
	 * The name of the 'name' XML attribute.
	 */
	protected static final String NAME = "name"; //$NON-NLS-1$
	
	/**
	 * The name of the 'value' XML attribute.
	 */
	protected static final String VALUE = "value"; //$NON-NLS-1$
	
	/**
	 * The name of the 'notValue' XML attribute.
	 */
	protected static final String NOT_VALUE = "notValue"; //$NON-NLS-1$

	/**
	 * The name of the 'null' XML attribute value.
	 */
	protected static final String NULL = "null"; //$NON-NLS-1$
	
	/**
	 * the name of the context param
	 */
	protected static final String contextParam = "%Context"; //$NON-NLS-1$

	/**
	 * A map to store previously successful class lookups.
	 */
	private static Map isAssignableTable = new HashMap();

	/** 
	 * A map to store previously failed class lookups.
	 */
	private static Map isNotAssignableTable = new HashMap();
    
    /**
     * A map to hold the bundle to exception list
     */
    private static Map bundleToExceptionsSetMap = new HashMap();	
	/**
	 * a map of classes that get asked for methods they do not contain, by
	 * the provider, the map is a class to a Set of method signatures
	 */
	private static ClassToMethodSignaturesSetMap passiveClasses = 
		new ClassToMethodSignaturesSetMap();
	
	/**
	 * a class to cach passive classes, passive classes are the classes we asked 
	 * for a method with a specific signature and they faild to find it. The cach used 
	 * so in the next time we can tell if the method does not exists oin the class
	 * without calling getMethod by reflection, which improves the performance
	 * @author mmostafa
	 *
	 */
	private static class ClassToMethodSignaturesSetMap{
		
		/**
		 * internal map for the cach, it is a map of Class to Set of method signature Strings
		 */
		Map classToMethodSignaturesSetMap = new HashMap();
		
		/**
		 * adds a class and a method signature to the passive class cach
		 * @param clazz		the class
		 * @param signature	the method signature
		 */
		public void addMethod(Class clazz, String signature){
			Set signatures = (Set)classToMethodSignaturesSetMap.get(clazz);
			if (signatures==null){
				signatures = new HashSet();
				classToMethodSignaturesSetMap.put(clazz,signatures);
			}
			signatures.add(signature);
		}
		
		/**
		 * check if the class and the method signatrue are contained in the apssive collection,
		 * which means we do  need need to call get method oon the class becuase we will not 
		 * find it, this helps improving the performance.
		 * @param clazz
		 * @param signature
		 * @return
		 */
		public boolean contains(Class clazz, String signature){
			Set signatures = (Set)classToMethodSignaturesSetMap.get(clazz);
			if (signatures==null)
				return false;
			return signatures.contains(signature);
		}
	}
	
	/**
	 * internal class used to cach Methods, so we do not call getMethod too often 
	 * @author mmostafa
	 *
	 */
	private static class ClassToMethodSignatureToMethodCach{
		
		/**
		 * internal map to hold the cached data, it is a map of Class => Map
		 * of Singature string => method
		 */
		Map classToMethodSignatureToMethod = new HashMap();
		
		/**
		 * adds a <code>Method</code> to the cach
		 * @param clazz		the class we got the method from 
		 * @param methodSignature	the method signature
		 * @param method	the <code>Method</code>
		 */
		public void addMethod(Class clazz,String methodSignature, Method method ){
			Map signatureToMethodMap = (Map)classToMethodSignatureToMethod.get(clazz);
			if (signatureToMethodMap==null){
				signatureToMethodMap = new HashMap();
				classToMethodSignatureToMethod.put(clazz,signatureToMethodMap);
			}
			signatureToMethodMap.put(methodSignature,method);
		}
		
		/**
		 * gets a method from the cach using the class that owns it and the method 
		 * signature.
		 * @param clazz		the class that owns the method
		 * @param methodSignature	the method signature
		 * @return	the <code>Method</code> if found any, otherwise null
		 */
		public Method getMethod(Class clazz,String methodSignature){
			Map signatureToMethodMap  = (Map)classToMethodSignatureToMethod.get(clazz);
			if (signatureToMethodMap !=null){
				return (Method)signatureToMethodMap.get(methodSignature);
			}
			return null;
		}
		
	}
	
	/**
	 * map for class to Method signature to method cach
	 */
	private static ClassToMethodSignatureToMethodCach
		classToMethodSignatureToMethodCach = new ClassToMethodSignatureToMethodCach();
	
	
	
	/**
	 * Gets the class name of <code>object</code>.
	 * @param object the object for which the class name is to be found.
	 * @return the class name
	 */
	static String getClassName( Object object ) {
	    String cn = object.getClass().getName();
	    return cn.substring( cn.lastIndexOf('.')+1);
	}
	
	/**
	 * A descriptor for an XML configuration element that identifies a class by
	 * name and optionally its methods.
	 */
	public static class ObjectDescriptor {
		/** 
		 * The name of the class.
		 */
		private String contextClassName;
		
		/**
		 * The ID of the plugin that contains the class.
		 */
		private String contextClassPlugin;
		
		/**
		 * <code>true</code> if a syntax error has occurred,
		 * <code>false</code> otherwise.
		 */ 
		private boolean syntaxError; 
		
		/**
		 * A list of method descriptors for the class.
		 */
		private final List methods;
		
		/**
		 * A list of method descriptors for the class.
		 */
		private final List staticMethods;

		/**
		 * Creates a new object descriptor from its configuration element.
		 * 
		 * @param configElement
		 *            The configuration element.
		 */
		public ObjectDescriptor(IConfigurationElement configElement) {
			this(configElement, CLASS);
		}

		/**
		 * Creates a new object descriptor from its configuration element.
		 * 
		 * @param configElement
		 *            The configuration element.
		 * @param classNameTag
		 *            The name of the 'class' XML attribute.
		 */
		public ObjectDescriptor(
			IConfigurationElement configElement,
			String classNameTag) {

			 String s = configElement.getAttribute(classNameTag);
			 if (s != null) {
				 int start = s.indexOf("(");//$NON-NLS-1$
				 if (start != -1) {
					contextClassName = s.substring(0, start).trim();
				 	int end = s.indexOf(")");//$NON-NLS-1$
					if (end != -1 && end > start+1)
						contextClassPlugin = s.substring(start+1, end);
				 } else
					contextClassName = s.trim();
			 }

			 IConfigurationElement[] methodConfigs =
				configElement.getChildren(METHOD);
			 
			 IConfigurationElement[] staticMethodConfigs =
				configElement.getChildren(STATIC_METHOD);

			if (methodConfigs.length != 0) {
				methods = new ArrayList(methodConfigs.length);
				for (int i = 0; i < methodConfigs.length; i++) {
					String name = methodConfigs[i].getAttribute(NAME);
					if (name != null) {
						try {
							MethodDescriptor methodDescriptor =
								new MethodDescriptor(name);
							ValueDescriptor value =
								new ValueDescriptor(methodConfigs[i]);
							if (value != null)
								methods.add(new MethodValueEntry(methodDescriptor, value));
						} catch (Exception e) {
							syntaxError = true;
							Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getContributor().getName()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: invalid syntax for method [" + name + "]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
						}
					} else {
						syntaxError = true;
						Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getContributor().getName()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "] : missing method name");  //$NON-NLS-1$ //$NON-NLS-2$ 
					}
				}
			} 
			else
				methods = Collections.EMPTY_LIST;
			
			
			if (staticMethodConfigs.length != 0) {
				staticMethods = new ArrayList(staticMethodConfigs.length);
				for (int i = 0; i < staticMethodConfigs.length; i++) {
					String name = staticMethodConfigs[i].getAttribute(NAME);
					if (name != null) {
						try {
							StaticMethodDescriptor methodDescriptor =
								new StaticMethodDescriptor(name);
							ValueDescriptor value =
								new ValueDescriptor(staticMethodConfigs[i]);
							if (value != null)
								staticMethods.add(new MethodValueEntry(methodDescriptor, value));
						} catch (Exception e) {
							syntaxError = true;
							Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getContributor().getName()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: invalid syntax for method [" + name + "]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
						}
					} else {
						syntaxError = true;
						Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getContributor().getName()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "] : missing method name");  //$NON-NLS-1$ //$NON-NLS-2$ 
					}
				}
			}else
				staticMethods = Collections.EMPTY_LIST;
			
			
			
			if (contextClassName != null)
				contextClassName = contextClassName.intern();
			if (contextClassPlugin != null)
				contextClassPlugin = contextClassPlugin.intern();
		}

		/**
		 * Tests if the object descriptor applies to the given context object.
		 * 
		 * @param object
		 *            The context object.
		 * @return <code>true</code> if it applies; <code>false</code>
		 *         otherwise
		 */
		public boolean sameAs(Object object) {
			if (syntaxError)
				return false;

			Object targetObject = object;
			if (contextClassName != null) {
				if (!isAssignableTo(object.getClass(), contextClassName)) {
					targetObject = getAdapter(object, contextClassName, contextClassPlugin);
					if (targetObject == null)
						return false;
				}
			} 
			
			for(Iterator iter = methods.iterator(); iter.hasNext();) {
				MethodValueEntry entry = (MethodValueEntry)iter.next();
				Object methodValue = invokeMethod(entry.method, targetObject);
				
				if (methodValue == null || !entry.value.sameAs(methodValue))
					return false;
			}
			
			for(Iterator iter = staticMethods.iterator(); iter.hasNext();) {
				MethodValueEntry entry = (MethodValueEntry)iter.next();
				Object methodValue = invokeStaticMethod((StaticMethodDescriptor)entry.method, targetObject);
				
				if (methodValue == null || !entry.value.sameAs(methodValue))
					return false;
			}
			
			return true;
		}
	}

	/**
	 * A descriptor for an XML configuration element that identifies a method by
	 * name and its formal parameters.
	 */
	private static class MethodDescriptor {
        
        protected String dataForIntialize = NULL;
		
		/**
		 * The method name.
		 */
		private String name;
		
		/**
		 * The array of method parameters.
		 */
		private Object parameterObjects[];
		
		/**
		 * The array of method parameter types.
		 */
		private Class parameterTypes[];
		
		/**
		 * The next cascading method descriptor.
		 */
		private MethodDescriptor next;

		/**
		 * The list of method parameters.
		 */
		private List parameters;
		
		/**
		 * the method signature
		 *
		 */
		private String signature = null;
		
		
		protected MethodDescriptor(){
			// empty 
		}

		/**
		 * Creates a new method descriptor from a string representing the
		 * method's full cascading invocation with parameters.
		 * <P>
		 * The format of the string is:
		 * <P>
		 * <code>method_name([params])[.method_name([params])]*</code>
		 * <P>
		 * Where:
		 * <UL>
		 * <LI>the <i>params </i> are comma-separated string literals without
		 * double quotes.</LI>
		 * <LI>only string <i>params </i> are allowed (no texual representation
		 * of non-string params are allowed)</LI>
		 * </UL>
		 * <P>
		 * For example:
		 * <P>
		 * <code>getPropertyValue(Source_Connection).getName()</code>
		 * 
		 * @param string
		 *            the method invocation string
		 */
		public MethodDescriptor(String string) {
            dataForIntialize = string;
		}
        
        protected boolean isInitialized(){
            return (dataForIntialize==null);
        }

        protected void initialize() {
            //check if already initialized
            if (isInitialized())
                return;
            try {
                // set method name
                dataForIntialize = parseName(dataForIntialize.trim());
    			// set method parameters
                dataForIntialize = parseParameterList(dataForIntialize.trim());
    
    			// fill the parameter objects and types arrays
    			if (parameters != null && !parameters.isEmpty()) {
    				Collections.reverse(parameters);
    				parameterObjects = parameters.toArray();
    				parameterTypes = new Class[parameterObjects.length];
    				for (int i = 0; i < parameterObjects.length; i++) {
    					String p = (String) parameterObjects[i];
    					int objIndex = p.indexOf("[object]"); //$NON-NLS-1$
    					boolean isObject = objIndex >= 0;
    					int parseAsIndex = p.indexOf(":::"); //$NON-NLS-1$
    					try {
    						if (isObject && (parseAsIndex >= 0))
    							// assume order: [object] before type:::param
    							assert (objIndex < parseAsIndex);
    						if (parseAsIndex >= 0) {
    							// "type:::param"
    							String parseAs =
    								p.substring((isObject ? 8 : 0), parseAsIndex);
    							String value =
    								p.substring(parseAsIndex + 3, p.length());
    							if (parseAs.equalsIgnoreCase("int")) { //$NON-NLS-1$
    								parameterTypes[i] = Integer.class;
    								parameterObjects[i] = Integer.decode(value);
    							} else if (parseAs.equalsIgnoreCase("bool")) { //$NON-NLS-1$
    								parameterTypes[i] = Boolean.class;
    								parameterObjects[i] = Boolean.valueOf(value);
    							} else if (parseAs.equalsIgnoreCase("double")) { //$NON-NLS-1$
    								parameterTypes[i] = Double.class;
    								parameterObjects[i] = Double.valueOf(value);
    							}
    							// if [object] present, set type to Object
    							if (isObject)
    								parameterTypes[i] = Object.class;
    						} else if (isObject) { // "[object]param"
    							String value = p.substring(8, p.length());
    							parameterTypes[i] = Object.class;
    							parameterObjects[i] = value;
    						} else // "param"
    							parameterTypes[i] = String.class;
    					} catch (Exception e) {
    						String value =
    							p.substring(
    								((parseAsIndex >= 0) ? parseAsIndex + 3 : 0),
    								p.length());
    						parameterObjects[i] = value;
    						parameterTypes[i] = String.class;
    					}
    				}
    			}
    			parameters = null;
    
    			// set method parameters
    			if (dataForIntialize.length() != 0) {
    				if (dataForIntialize.charAt(0) != '.')
    					throw new IllegalArgumentException();
    				next = new MethodDescriptor(dataForIntialize.substring(1).trim());
    			}
    			
    		 if (this.name != null)
    				name = name.intern();
            }finally{
                dataForIntialize = null;
            }
        }

		/**
		 * Parses and returns the method name in a method invocation string.
		 * 
		 * @param string
		 *            the method invocation string
		 * @return the method name
		 */
		protected String parseName(String string) {
			int index = string.indexOf('(');
			if (index == -1)
				throw new IllegalArgumentException(); 
			name = string.substring(0, index).trim();
			return string.substring(index + 1);
		}

		/**
		 * Parses a method invocation string for the list of parameters, which
		 * are placed in the <code>parameters</code> field.
		 * 
		 * @param string
		 *            the method invocation string
		 * @return the end part of the method invocation string that has not
		 *         been parsed.
		 */
		protected String parseParameterList(String string) {
			int index = -1;
			String paramStr = null;
			while (paramStr == null) {
				index = string.indexOf(')', index + 1);
				if (index == -1)
					throw new IllegalArgumentException(); 
				if (index == 0 || string.charAt(index - 1) != '\\')
					paramStr = string.substring(0, index);
			}
			if (paramStr.length() != 0) {
				parameters = new ArrayList();
				parseParameters(paramStr.trim());
			}
			return string.substring(index + 1);
		}

		/**
		 * Parses a string containing a list of method parameters and stores
		 * them in the <code>parameters</code> field.
		 * 
		 * @param string
		 *            the comma-separated list of method parameters.
		 */
		private void parseParameters(String string) {
			int index = string.indexOf(',');
			if (index != -1 && string.charAt(index - 1) != '\\') {
				parseParameters(string.substring(index + 1).trim());
				parameters.add(string.substring(0, index));
			} else
				parameters.add(string);
		}

		/**
		 * Returns the method name.
		 * 
		 * @return the method name
		 */
		public String getName() {
			return name;
		}
		
		/**
		 * Sets the method name.
		 * @param the method name
		 */
		public void setName(String name) {
			this.name = name;
		}

		/**
		 * Returns an array of string params.
		 * 
		 * @return the parameters
		 */
		public Object[] getParameters() {
			return parameterObjects;
		}

		/**
		 * Returns an array of parameter classes.
		 * 
		 * @return the parameter types
		 */
		public Class[] getParameterTypes() {
			return parameterTypes;
		}
		
		/**
		 * sets the the array of params.
		 * @param paramters
		 */
		protected void setParameters(Object[] paramters) {
			parameterObjects = paramters;
		}

		/**
		 * sets the the array of parameter types.
		 * @param paramtersTypes
		 */
		public void setParameterTypes(Class[] paramterTypes) {
			this.parameterTypes = paramterTypes;
		}

		/**
		 * Returns the next cascading method descriptor, if any.
		 * 
		 * @return the next method descriptor, or <code>null</code> if there
		 *         is none
		 */
		public MethodDescriptor getNext() {
			return next;
		}
		
		/**
		 * sets the next cascading method descriptor, if any.
		 * @param next
		 */
		protected void setNext(MethodDescriptor next) {
			this.next = next;
		}

		/**
		 * Gets the Paramters List
		 * @return The list of method parameters.
		 */
		protected List getParamtersList(){
			return parameters;
		}
		
		/**
		 * utility method used to get the signature of the method this method descriptor
		 * descripe.
		 * @return the signature of the method
		 */
		public String getSignature(){
			if (this.signature==null){
				StringBuffer sb = 
					new StringBuffer();
				sb.append(name);
				sb.append('(');
				if(parameterTypes!=null)
					for(int index= 0 ; index < parameterTypes.length ; index++){
						Class clazz = parameterTypes[index];
						sb.append(clazz.getName());
						if(index<parameterTypes.length-1)
							sb.append(',');
					}
				sb.append(')');
				signature = sb.toString();
			}
			return signature;
			
		}
	}

	
	private static class StaticMethodDescriptor extends MethodDescriptor {
        
		/**
		 * the plugin Name
		 */
		private String pluginID;
		
		/**
		 * the Class Name
		 */
		private String className;
		
		/**
		 * Creates a new method descriptor from a string representing the
		 * method's full cascading invocation with parameters.
		 * <P>
		 * The format of the string is:
		 * <P>
		 * <code>PluginID\ClassName.method_name([params])[.method_name([params])]*</code>
		 * <P>
		 * Where:
		 * <UL>
		 * <LI>the <i>params </i> are comma-separated string literals without
		 * double quotes.</LI>
		 * <LI>only string <i>params </i> are allowed (no texual representation
		 * of non-string params are allowed)</LI>
		 * <LI>to identify a parameter as the current context you put %
		 * </UL>
		 * <P>
		 * For example:
		 * <P>
		 * <code>MyPluginID\MyClass.MyStaticFunction(%,"some value")</code>
		 * 
		 * @param string
		 *            the method invocation string
		 */
		public StaticMethodDescriptor(String string) {
            dataForIntialize = string;
		}
        
        public void initialize() {
            // check if already initialized
            if (isInitialized())
                return;
            try {
                // set plugin ID
                dataForIntialize = parsePluginID(dataForIntialize.trim());
    			// set class Name 
                dataForIntialize = parseClassName(dataForIntialize.trim());
    			// set method name
                dataForIntialize = parseName(dataForIntialize.trim());
    			// set method parameters
                dataForIntialize = parseParameterList(dataForIntialize.trim());
    
    			List parameters = getParamtersList();
    			
    			// fill the parameter objects and types arrays
    			if (parameters != null && !parameters.isEmpty()) {
    				Collections.reverse(parameters);
    				Object[] parameterObjects = parameters.toArray();
    				Class[] parameterTypes = new Class[parameterObjects.length];
    				for (int i = 0; i < parameterObjects.length; i++) {
    					String p = (String) parameterObjects[i];
    					int objIndex = p.indexOf("[object]"); //$NON-NLS-1$
    					boolean isObject = objIndex >= 0;
    					int parseAsIndex = p.indexOf(":::"); //$NON-NLS-1$
    					try {
    						if (isObject && (parseAsIndex >= 0))
    							// assume order: [object] before type:::param
    							assert (objIndex < parseAsIndex);
    						if (parseAsIndex >= 0) {
    							// "type:::param"
    							String parseAs =
    								p.substring((isObject ? 8 : 0), parseAsIndex);
    							String value =
    								p.substring(parseAsIndex + 3, p.length());
    							if (parseAs.equalsIgnoreCase("int")) { //$NON-NLS-1$
    								parameterTypes[i] = Integer.class;
    								parameterObjects[i] = Integer.decode(value);
    							} else if (parseAs.equalsIgnoreCase("bool")) { //$NON-NLS-1$
    								parameterTypes[i] = Boolean.class;
    								parameterObjects[i] = Boolean.valueOf(value);
    							} else if (parseAs.equalsIgnoreCase("double")) { //$NON-NLS-1$
    								parameterTypes[i] = Double.class;
    								parameterObjects[i] = Double.valueOf(value);
    							}
    							// if [object] present, set type to Object
    							if (isObject)
    								parameterTypes[i] = Object.class;
    						} else if (isObject) { // "[object]param"
    							String value = p.substring(8, p.length());
    							parameterTypes[i] = Object.class;
    							parameterObjects[i] = value;
    						} else if (p.startsWith(contextParam)){// "param" 
    							parameterTypes[i] = getParameterType(p);
    							parameterObjects[i] = "%Context"; //$NON-NLS-1$
    						}
    						else
    							parameterTypes[i] = String.class;
    					} catch (Exception e) {
    						String value =
    							p.substring(
    								((parseAsIndex >= 0) ? parseAsIndex + 3 : 0),
    								p.length());
    						parameterObjects[i] = value;
    						parameterTypes[i] = String.class;
    					}
    				}
    				setParameters(parameterObjects);
    				setParameterTypes(parameterTypes);
    			}
    			parameters = null;
    
    			// set method parameters
    			if (dataForIntialize.length() != 0) {
    				if (dataForIntialize.charAt(0) != '.')
    					throw new IllegalArgumentException();
    				setNext(new MethodDescriptor(dataForIntialize.substring(1).trim()));
    			}
    			
    		 if (getName() != null)
    				setName(getName().intern());
            }finally{
                dataForIntialize = null;
            }
        }

		
		/**
		 * parse the passed paramter to extract the paramter's class
		 * @param p		the parapemter 
		 * @return
		 */
		private Class getParameterType(String parameter) {
			int startIndex = parameter.indexOf("["); //$NON-NLS-1$
			int endIndex = parameter.indexOf("]"); //$NON-NLS-1$
			if(startIndex==-1 || endIndex==-1)
				throw new IllegalArgumentException(); 
			String parameterTypeString= parameter.substring(startIndex+1,endIndex).trim();
			
			endIndex = parameterTypeString.indexOf('/');
			if(endIndex==-1 || endIndex==parameterTypeString.length()-1)
				throw new IllegalArgumentException(); 
			String parameterPluginID = parameterTypeString.substring(0,endIndex).trim();
			String parameterClassName = parameterTypeString.substring(endIndex + 1);
			Class clazz = loadClass(parameterClassName,parameterPluginID);
			if(clazz==null)
				clazz =  Object.class;
			return clazz;
		}

		/**
		 * Parses and returns the Plugin ID in a method invocation string.
		 * 
		 * @param string
		 *            the method invocation string
		 * @return the plugin name
		 */
		private String parsePluginID(String string) {
			int index = string.indexOf('/');
			if (index == -1)
				throw new IllegalArgumentException(); 
			pluginID = string.substring(0, index).trim();
			return string.substring(index + 1);
		}
		
		/**
		 * Parses and returns the Plugin ID in a method invocation string.
		 * 
		 * @param string
		 *            the method invocation string
		 * @return the plugin name
		 */
		private String parseClassName(String string) {
			int index = string.indexOf('(');
			if (index == -1)
				throw new IllegalArgumentException(); 
			index = string.lastIndexOf('.',index);
			if (index == -1)
				throw new IllegalArgumentException(); 
			className = string.substring(0, index).trim();
			return string.substring(index + 1);
		}
		
	public String getPluginID(){
			return pluginID;
		}
		
		public String getClassName(){
			return className;
		}
	
	}
	
	
	/**
	 * A descriptor for an XML configuration element that identifies a method
	 * result by its type and <code>toString()</code> value.
	 */
	private static class ValueDescriptor {
		
		/**
		 * The valid value literals.
		 */
		private Set valueLiterals;
		
		/**
		 * The invalid valud literals.
		 */
		private Set notValueLiterals;
		
		/**
		 * The valid value objects.
		 */
		private List valueObjects;
		
		/**
		 * The invalid value objects.
		 */
		private List notValueObjects;

		/**
		 * Creates a new value descriptor from its configuration element.
		 * 
		 * @param configElement
		 *            The configuration element.
		 */
		public ValueDescriptor(IConfigurationElement configElement) {
			valueLiterals = new HashSet();
			String s = configElement.getAttribute(VALUE);
			if (s != null)
				parseValueLiteralString(s, valueLiterals);

			notValueLiterals = new HashSet();
			s = configElement.getAttribute(NOT_VALUE);
			if (s != null)
				parseValueLiteralString(s, notValueLiterals);

			IConfigurationElement[] valueConfigs = configElement.getChildren(VALUE);
			valueObjects = new ArrayList(valueConfigs.length);
			for (int i=0; i<valueConfigs.length; i++)
				valueObjects.add(new ObjectDescriptor(valueConfigs[i]));

			IConfigurationElement[] notValueConfigs = configElement.getChildren(NOT_VALUE);
			notValueObjects = new ArrayList(notValueConfigs.length);
			for (int i=0; i<notValueConfigs.length; i++)
				notValueObjects.add(new ObjectDescriptor(notValueConfigs[i]));
		}
		
		/**
		 * Parse the string <code>s</code>, which is a comma-separated list
		 * of value literals and place them in the given <code>list</code>.
		 * 
		 * @param s
		 *            the string to be parsed
		 * @param list
		 *            the set of literal string values from <code>s</code>.
		 */
		private void parseValueLiteralString(String s, Set list) {
			// parse the string comma-separated string literals ignoring escaped commas
			int start = 0;
			int end = s.indexOf(',');
			while (end != -1) {
				if (s.charAt(end-1) == '\\') {
					s = s.substring(0, end-1) + s.substring(end);
					end = s.indexOf(',', end);
					continue;
				}
				list.add(s.substring(start, end).trim().intern());
				start = end +1;
				end = s.indexOf(',', start);
			}
			list.add(s.substring(start).trim().intern());
		}
		
		/**
		 * Returns <code>true</code> if I am the same as <code>object</code>,
		 * <code>false</code> otherwise.
		 * 
		 * @param object
		 *            the object to be tested
		 * @return <code>true</code> if I am the same as <code>object</code>,
		 *         <code>false</code> otherwise.
		 */
		public boolean sameAs(Object object) {
			if (!valueLiterals.isEmpty()) {
				if (!valueLiterals.contains(object.toString()))
					return false;
			}
			if (!notValueLiterals.isEmpty()) {
				if (notValueLiterals.contains(object.toString()))
					return false;
			}
			if (!valueObjects.isEmpty()) {
				if (!isObjectinList(object, valueObjects))
					return false;
			}
			if (!notValueObjects.isEmpty()) {
				if (isObjectinList(object, notValueObjects))
					return false;
			}
			return true;
		}
		
		/**
		 * Answers whether or not an object in <code>list</code> is the
		 * {@link #sameAs(Object)}<code>object</code>.
		 * 
		 * @param object
		 *            the object to find
		 * @param list
		 *            the list of objects
		 * @return <code>true</code> if an object in <code>list</code> is
		 *         the {@link #sameAs(Object)}<code>object</code>,
		 *         <code>false</code> otherwise.
		 */
		private boolean isObjectinList(Object object, List list) {
			Iterator i = list.iterator();
			while (i.hasNext()) {
				if (((ObjectDescriptor)i.next()).sameAs(object))
					return true;
			}
			return false;
		}
	}

	/**
	 * Describes a method value using a method descriptor and a value descriptor.
	 */
	private static class MethodValueEntry {
		
		/**
		 * The method descriptor.
		 */
		public MethodDescriptor method;
		
		/**
		 * The value descriptor.
		 */
		public ValueDescriptor value;

		/**
		 * Creates a new method value entry.
		 * @param method the method descriptor
		 * @param value the value descriptor
		 */
		public MethodValueEntry(MethodDescriptor method, ValueDescriptor value) {
			super();
			this.method = method;
			this.value = value;
		}
	}

	/**
	 * A helper method to return a list of objects whose ids are given in a
	 * comma-separated string and whose instances are given in an object map.
	 * 
	 * @param objectsIds
	 *            A comma-separated object ids string
	 * @param objectMap
	 *            A map of object ids to their instances
	 * @param configElement
	 *            The configuration element, used for error logging
	 * @return a list of object instances whose ids are given or
	 *         <code>null</code> if no ids matched any instances
	 */
	protected static List getObjectList(String objectsIds, Map objectMap, IConfigurationElement configElement) {
		if (objectsIds == null)
			return null;
		StringTokenizer ids = new StringTokenizer(objectsIds.trim(), ","); //$NON-NLS-1$
		if (!ids.hasMoreTokens())
			return null;
		
		List objectList = new ArrayList();
		while (ids.hasMoreTokens()) {
			String objectId = ids.nextToken().trim();
			Object objectVal = objectMap.get(objectId);
			if (objectVal != null)
				objectList.add(objectVal);
			else {
				Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE, configElement.getDeclaringExtension().getContributor().getName()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: object id (" + objectId + ") is not in the list " + objectMap.keySet());  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			}
		}
		return objectList;
	}

	/**
	 * Parses the comma-separated <code>s</code> string and returns a set of
	 * the individual entries in the string.
	 * 
	 * @param s
	 *            A comma-separated string
	 * @return a set of the individual entries in the string.
	 */
	protected static Set getStrings(String s) {
		if (s == null)
			return null;
		Set stringList = new HashSet();
		StringTokenizer ids = new StringTokenizer(s.trim(), ","); //$NON-NLS-1$
		while (ids.hasMoreTokens()) {
			stringList.add(ids.nextToken().trim());
		}
		return stringList.isEmpty() ? null : stringList;
	}

	/**
	 * Tests if an object matches at least one in the list of object descriptors
	 * passed.
	 * 
	 * @param object
	 *            the object for which to find a match
	 * @param objects
	 *            the list of object in which to find a match
	 * @return <code>true</code> if there was a match, <code>false</code>
	 *         otherwise
	 */
	protected static boolean objectMatches(Object object, List objects) {
		if (object != null) {
			for (Iterator i = objects.iterator(); i.hasNext();) {
				ObjectDescriptor desc = (ObjectDescriptor) i.next();
				if (desc.sameAs(object))
					return true;
			}
		}
		return false;
	}

	/**
	 * A utility method to load a class using its name and a given class loader.
	 * 
	 * @param className
	 *            The class name
	 * @param bundle
	 *            The class loader
	 * @return The loaded class or <code>null</code> if could not be loaded
	 */
	 /*protected static Class loadClass(String className, Bundle bundle) {
		try {
			return bundle.loadClass(className);
		} catch (ClassNotFoundException e) {
			return null;
		}
	}*/
	
	/**
	 * A utility method to load a class using its name and a given class loader.
	 * 
	 * @param className
	 *            The class name
	 * @param bundle
	 *            The class loader
	 * @return The loaded class or <code>null</code> if could not be loaded
	 */
	protected static Class loadClass(String className, String pluginId) {
		StringBuffer keyStringBuf = new StringBuffer(className.length()
			+ pluginId.length() + 2); // 2 is for . and extra.
		keyStringBuf.append(pluginId);
		keyStringBuf.append('.');
		keyStringBuf.append(className);
		String keyString = keyStringBuf.toString();
		WeakReference ref = (WeakReference) successLookupTable.get(keyString);
		Class found = (ref != null) ? (Class) ref.get()
			: null;
		if (found == null) {
			if (ref != null)
				successLookupTable.remove(keyString);
			if (!failureLookupTable.contains(keyString)) {
				try {
					Bundle bundle = basicGetPluginBundle(pluginId);
					if (bundle!=null){
                        // never load the class if the bundle is not active other wise
                        // we will cause the plugin to load
                        // unless the class is in the exception list
                        int state = bundle.getState();
                        if ( state == org.osgi.framework.Bundle.ACTIVE || isInExceptionList(bundle,className)){
    						found = bundle.loadClass(className);
    						successLookupTable.put(keyString, new WeakReference(found));
                            if (state == org.osgi.framework.Bundle.ACTIVE){
                                bundleToExceptionsSetMap.remove(bundle);
                            }
                        }
					}else{
						failureLookupTable.add(keyString);
					}
				} catch (ClassNotFoundException e) {
					failureLookupTable.add(keyString);
				}
			}
		}
		return found;
	}
	
	
	private static boolean isInExceptionList(Bundle bundle, String className) {
        String packageName = className.substring(0,className.lastIndexOf('.'));
        Set exceptionSet = (Set)bundleToExceptionsSetMap.get(bundle);
        if (exceptionSet==null){
            Dictionary dict = bundle.getHeaders();
            String value = (String)dict.get("Eclipse-LazyStart"); //$NON-NLS-1$
            if (value!=null){
                int index  = value.indexOf("exceptions"); //$NON-NLS-1$
                if (index!=-1){
                    try {
                        int start = value.indexOf('"',index+1);
                        int end = value.indexOf('"',start+1);
                        String exceptions = value.substring(start+1,end);
                        exceptionSet = new HashSet(2);
                        StringTokenizer tokenizer = new StringTokenizer(exceptions, ","); //$NON-NLS-1$
                        while (tokenizer.hasMoreTokens()) {
                            exceptionSet.add(tokenizer.nextToken().trim());
                        }
                    }catch(IndexOutOfBoundsException exception){
                        // this means the MF did not follow the documented format for the exceptions list
                        // so i'll consider it empty
                        exceptionSet = Collections.EMPTY_SET;
                    }
                    
                }else{
                    exceptionSet = Collections.EMPTY_SET;
                }
            }else{
                exceptionSet = Collections.EMPTY_SET;
            }
            bundleToExceptionsSetMap.put(bundle, exceptionSet);
        }
        return exceptionSet.contains(packageName);
    }

    /**
	 * Given a bundle id, it checks if the bundle is found and activated. If it
	 * is, the method returns the bundle, otherwise it returns <code>null</code>.
	 * 
	 * @param pluginId
	 *            the bundle ID
	 * @return the bundle, if found
	 */
	protected static Bundle getPluginBundle(String pluginId) {
		Bundle bundle = basicGetPluginBundle(pluginId);
		if (null != bundle && bundle.getState() == org.osgi.framework.Bundle.ACTIVE)
			return bundle;
		return null;
	}
    
    private static Bundle basicGetPluginBundle(String pluginId) {
        return Platform.getBundle(pluginId);   
    }

	/**
	 * Tests if the given class is assignable to the given class name. Optimized
	 * to look first in a cache of previously retrieved results.
	 * 
	 * @param clazz
	 *            the class to be tested
	 * @param className
	 *            the class name to test against
	 * @return <code>true</code> if the class is assignable to the class name,
	 *         <code>false</code> otherwise.
	 */
	protected static boolean isAssignableTo(Class clazz, String className) {
		if (clazz == null)
			return false;

		if ( contains(isNotAssignableTable, clazz, className) ) {
			return false;
		}
		
		if ( contains(isAssignableTable, clazz, className) ) {
			return true;
		}
	
		boolean result = isAssignableToNoCache(clazz,className);
		
		if (result) {
			add(isAssignableTable, clazz, className);
		} else {
			add(isNotAssignableTable, clazz, className);
		}

		return result;
	}

	/**
	 * Tests if the given class is assignable to the given class name.
	 * 
	 * @param clazz
	 *            the class to be tested
	 * @param className
	 *            the class name to test against
	 * @return <code>true</code> if the class is assignable to the class name,
	 *         <code>false</code> otherwise.
	 */
	private static boolean isAssignableToNoCache(Class clazz, String className) {
// mgoyal: This approach isn't safe to use as it can cause incorrect
// plugin load. Documenting this approach for further analysis. Don't
// remove or uncomment this.
//		try {
//			if(clazz.getName().equals(className))
//				return true;
//			
//			ClassLoader clsLoader = clazz.getClassLoader();
//			if(clsLoader != null) {
//				Class testCls = clsLoader.loadClass(className);
//				if(testCls != null && testCls.isAssignableFrom(clazz))
//					return true;
//			}
//			return false;
//		} catch (ClassNotFoundException e) {
//			return false;
//		}
//		
		
		// test the class itself
		if (clazz.getName().equals(className))
			return true;
		
		// test all the interfaces the class implements
		Class[] interfaces = clazz.getInterfaces();
		for (int i = 0; i < interfaces.length; i++) {
			if (checkInterfaceHierarchy(interfaces[i], className))
				return true;
		}
		
		// test superclass
		return isAssignableTo(clazz.getSuperclass(), className);
	}

	/**
	 * A map of classes that have been successfully loaded, keyed on the class
	 * name optionally prepended by the plugin ID, if specified.
	 */
	private static Map successLookupTable = new HashMap();
	
	/**
	 * A map of classes that could not be loaded, keyed on the class name
	 * optionally prepended by the plugin ID, if specified.
	 */
	private static Set failureLookupTable = new HashSet();

	/**
	 * Gets an adapter for <code>object</code> to the class described by
	 * <code>className</code> qualified by the optional <code>pluginId</code>.
	 * 
	 * @param object
	 *            the object to be adapted
	 * @param className
	 *            the name of the adapter class
	 * @param pluginId
	 *            the optional plugin ID (can be <code>null/code>)
	 * @return the adapted object, or <code>null</code> if it couldn't be found
	 */
	protected static Object getAdapter(Object object, String className, String pluginId) {
		if (!(object instanceof IAdaptable))
			return null;
		if(pluginId != null) {
			Class theClass = loadClass(className,pluginId);
			return theClass != null ? ((IAdaptable) object).getAdapter(theClass) : null;
		}
		return null;
	}

	/**
	 * A utility method to invoke a cascading list of methods.
	 * 
	 * @param methodDescriptor
	 *            the first method descriptor
	 * @param object
	 *            The object to invoke the method on
	 * @return the value of the invokation
	 */
	protected static Object invokeMethod(MethodDescriptor methodDescriptor, Object object) {
		String methodSignature = null;
		Class clazz =null;
		try {
			if (methodDescriptor == null || object == null)
				return null;
            if (!methodDescriptor.isInitialized()){
                methodDescriptor.initialize();
            }
			methodSignature = methodDescriptor.getSignature();
			clazz = object.getClass();
			if (passiveClasses.contains(clazz,methodSignature))
				return null;
			Method method = classToMethodSignatureToMethodCach.
				getMethod(clazz,methodSignature);
			if(method==null){
				method = clazz.getMethod(methodDescriptor.getName(),
										 methodDescriptor.getParameterTypes());
				classToMethodSignatureToMethodCach.addMethod(clazz,methodSignature,method);
			}
			Object valueObj = 
				method.invoke(object, methodDescriptor.getParameters());
			if (methodDescriptor.getNext() == null)
				return valueObj == null ? NULL : valueObj;
			return invokeMethod(methodDescriptor.getNext(), valueObj);
		} catch (Exception e) {
			passiveClasses.addMethod(clazz,methodSignature);
			return null;
		}
	}
	
	/**
	 * A utility method to invoke a cascading list of methods.
	 * 
	 * @param StaticMethodDescriptor
	 *            the static method descriptor
	 * @param object
	 *            The context object to use (it could be null)
	 * @return the value of the invokation
	 */
	protected static Object invokeStaticMethod(StaticMethodDescriptor methodDescriptor, Object object) {
		try {
			if (methodDescriptor == null)
				return null;
            if (!methodDescriptor.isInitialized()){
                methodDescriptor.initialize();
            }
			
			Object[] valuesCopy = null;
            if (methodDescriptor.getParameters() != null) {
                valuesCopy = methodDescriptor.getParameters()
                    .clone();
                for (int i = 0; i < valuesCopy.length; i++) {
                    if (valuesCopy[i].equals(contextParam)) {
                        valuesCopy[i] = object;
                    }
                }
            }
			
			Method method = getStaticMethod(methodDescriptor);
			Object valueObj = (method != null) ? method.invoke(object,
                valuesCopy)
                : null;

			if (methodDescriptor.getNext() == null)
				return valueObj == null ? NULL : valueObj;
			return invokeMethod(methodDescriptor.getNext(), valueObj);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * utility method used to get a static method object
	 * @param pluginID			the plugin that owns the class
	 * @param className			the class to use to call hte static method
	 * @param methodName		the method to get
	 * @param ParameterTypes	the parameter types 
	 * @return					the  method object
	 */
	private static Method getStaticMethod(StaticMethodDescriptor staticMethodDescriptor) {
		Class theClass = loadClass(staticMethodDescriptor.getClassName(),
									staticMethodDescriptor.getPluginID());
		if (theClass==null)
			return null;
		Method theMethod = null;
		try {
			String methodSignature = staticMethodDescriptor.getSignature(); 
			theMethod = classToMethodSignatureToMethodCach.getMethod(theClass,methodSignature);
			if(theMethod==null){
			   theMethod = theClass.getMethod(staticMethodDescriptor.getName(),
											staticMethodDescriptor.getParameterTypes());
				classToMethodSignatureToMethodCach.addMethod(theClass,methodSignature,theMethod);
			}
		} catch (SecurityException e) {
			// no special handling needed;
		} catch (NoSuchMethodException e) {
			// no special handling needed;
		}
		return theMethod;
	}

	/**
	 * Check the interfaces the whole way up. If one of them matches
	 * <code>className</code> return <code>true</code>. Optimized to look
	 * first in a cache of previously retrieved results.
	 * 
	 * @param interfaceToCheck
	 *            The interface whose name we are testing.
	 * @param className
	 *            the name of the interface to we are trying to match
	 * @return <code>true</code> if one of the interfaces in the hierarchy
	 *         matches <code>className</code>,<code>false</code>
	 *         otherwise.
	 */
	private static boolean checkInterfaceHierarchy(Class interfaceToCheck, String className) {
		
		if ( contains(isNotAssignableTable, interfaceToCheck, className) ) {
			return false;
		}
		
		if ( contains(isAssignableTable, interfaceToCheck, className) ) {
			return true;
		}
		
		boolean result = checkInterfaceHierarchyNoCache(interfaceToCheck,className);
		
		if (result) {
			add(isAssignableTable, interfaceToCheck, className);
		} else {
			add(isNotAssignableTable, interfaceToCheck, className);
		}
		
		return result;
	}

	/**
	 * Check the interfaces the whole way up. If one of them matches
	 * <code>className</code> return <code>true</code>.
	 * 
	 * @param interfaceToCheck
	 *            The interface whose name we are testing.
	 * @param className
	 *            the name of the interface to we are trying to match
	 * @return <code>true</code> if one of the interfaces in the hierarchy
	 *         matches <code>className</code>,<code>false</code>
	 *         otherwise.
	 */
	private static boolean checkInterfaceHierarchyNoCache(Class interfaceToCheck, String className) {
		if(interfaceToCheck.getName().equals(className))
			return true;
		Class[] superInterfaces = interfaceToCheck.getInterfaces();
		for (int i = 0; i < superInterfaces.length; i++) {
			if(checkInterfaceHierarchy(superInterfaces[i], className))
				return true;
		}
		return false;
	}
	
	/**
	 * Determines whether the <code>map</code> contains an entry for the
	 * <key,value>pair.
	 * 
	 * @param map
	 *            the map in which to find the key and value
	 * @param key
	 *            the key
	 * @param value
	 *            the value
	 * @return <code>true</code> if the map contains the key/value pair,
	 *         <code>false</code> otherwise
	 */
	private static boolean contains(Map map, Object key, String value) {
		
		boolean result = false;
		
		Object val = map.get(key);
		if (val != null) {
			Set values = (Set)val;
			result = values.contains(value);
		}
		
		return result;
	}
	
	/**
	 * Adds the <key,value>pair to the <code>map</code>.
	 * 
	 * @param map
	 *            the map in which to add the value
	 * @param key
	 *            the key
	 * @param value
	 *            the value
	 */
	private static void add(Map map, Object key, String value) {
		
		Set values = (Set)map.get(key);
		if (values == null) {
			values = new HashSet();
			map.put(key, values);
		}
		
		values.add(value);
	}
}