/*
    * Copyright (c) 2005 Regents of the University of California (Regents). Created
    * by TELS, Graduate School of Education, University of California at Berkeley.
    *
    * This software is distributed under the GNU Lesser General Public License, v2.
    *
    * Permission is hereby granted, without written agreement and without license
    * or royalty fees, to use, copy, modify, and distribute this software and its
    * documentation for any purpose, provided that the above copyright notice and
   * the following two paragraphs appear in all copies of this software.
   *
   * REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE. THE SOFTWAREAND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
   * HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
   * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
   *
   * IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
   * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
   * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
   * REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.sail.common.beansupport;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Logger;
  
  @SuppressWarnings("unchecked")
  public class DynamicObject
  {
  	/**
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(DynamicObject.class
  			.getName());
  
  	protected static final Object [] NO_ARGS = new Object[0];
  	protected MethodTable methods = new MethodTable();
  	protected Class theClass;
  	protected Object instance;
  	
  	public DynamicObject()
  	{
  	}
  	
  	public Class getInstanceClass()
  	{
  		return theClass;
  	}
  	
  	public void setInstanceClass(ClassLoader loader, String className)
  	{
  		try
  		{
  			theClass = loader.loadClass(className);
  			instance = theClass.newInstance();
  			methods.setInstance(instance);
  		}
  		catch (ClassNotFoundException e)
  		{
  			logger.severe("ClassLoader, String -  : exception: " + e); //$NON-NLS-1$
  		}
  		catch (InstantiationException e)
  		{
  			logger.severe("ClassLoader, String -  : exception: " + e); //$NON-NLS-1$
  		}
  		catch (IllegalAccessException e)
  		{
  			logger.severe("ClassLoader, String -  : exception: " + e); //$NON-NLS-1$
  		}
  	}
  	
  	public Object getInstance()
  	{
  		return instance;
  	}
  	
  	public void setInstance(Object instance)
  	{
  		theClass = instance.getClass();
  		this.instance  = instance;
  		methods.setInstance(instance);
  	}
  	
  	public Object invoke(String methodName, Object [] args)
  	{
  		Method method = methods.findMethod(methodName, args);
  		return invoke(method, args);
  	}
  	
  	public Object invoke(String methodName)
  	{
  		return invoke(methodName, NO_ARGS);
 	}
 	
 	protected Object invoke(Method method, Object [] args)
 	{
 		try
 		{
 			method.invoke(instance, args);
 		}
 		catch (IllegalArgumentException e)
 		{
 			// TODO Auto-generated catch block
 			logger.severe("Method, Object[] -  : exception: " + e); //$NON-NLS-1$
 		}
 		catch (IllegalAccessException e)
 		{
 			// TODO Auto-generated catch block
 			logger.severe("Method, Object[] -  : exception: " + e); //$NON-NLS-1$
 		}
 		catch (InvocationTargetException e)
 		{
 			// TODO Auto-generated catch block
 			logger.severe("Method, Object[] -  : exception: " + e); //$NON-NLS-1$
 		}
 		return null;
 	}
 	
 	public class SignatureList
 	{
 		protected Map methods = new HashMap();
 		protected List<Signature> signatureList = new ArrayList<Signature>();
 		
 		public SignatureList(Class instanceClass, String name)
 		{
 //			List allSigs = new Vector();
 			Method [] methods = instanceClass.getMethods();
 			for (Method element : methods) {
 				if (element.getName().equals(name))
 				{
 					signatureList.add(new Signature(element));
 				}
 			}
 		}
 		
 		protected Signature findSignature(Object [] args)
 		{
 			Iterator signatures = signatureList.iterator();
 			while (signatures.hasNext())
 			{
 				Signature signature = (Signature) signatures.next();
 				if (signature.isSignature(args))
 				{
 					return signature;
 				}
 			}
 			return null;
 		}
 		
 		public Method findMethod(Object [] args)
 		{
 			Signature signature = findSignature(args);
 			if (signature != null)
 				return signature.getMethod();
 			return null;
 		}
 	}
 	
 	public class Signature
 	{
 		protected Method method;
 		protected Class<? extends Object>[] types;
 		
 		public Signature(Method method)
 		{
 			this.method = method;
 			types = method.getParameterTypes();
 		}
 		
 		public Method getMethod()
 		{
 			return method;
 		}
 
 		public boolean isSignature(Object [] args)
 		{
 			if (types.length == args.length)
 			{
 				for (int i = 0; i < types.length; i++)
 				{
 					final Class<? extends Object> sourceClass = args[i].getClass();
 					final Class<? extends Object> targetClass = types[i];
 					if (! targetClass.isAssignableFrom(sourceClass))
 					{
 						return false;
 					}
 				}
 				return true;
 			}
 			return false;
 		}
 	}
 	
 	public class MethodTable
 	{
 		protected Map<String,SignatureList> table = new HashMap<String,SignatureList>();
 		protected Object instance;
 		protected Class instanceClass;
 		
 		public MethodTable()
 		{
 		}
 		
 		public void setInstance(Object instance)
 		{
 			if (this.instance != null)
 			{
 				table.clear();
 				this.instance = null;
 				instanceClass = null;
 			}
 			this.instance = instance;
 			if (this.instance != null)
 			{
 				instanceClass = this.instance.getClass();
 			}
 		}
 		
 		public Method findMethod(String name, Object [] args)
 		{
 			if (instance != null)
 			{
 				SignatureList list = table.get(name);
 				if (list == null)
 				{
 					list = new SignatureList(instanceClass, name);
 					table.put(name, list);
 				}
 				return list.findMethod(args);
 			}
 			return null;
 		}
 	}
 }