package org.neo.swarm.core.aop.silc.comp;
   
   import java.io.Serializable;
   import java.lang.reflect.AccessibleObject;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.HashMap;
   import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.neo.swarm.core.aop.AspectComponent;
  
  
  /***
   * This class manages the interceptor chain for an aspected component.
   * 
   * @author damiang
   * @author navery
   */
  public class AspectComponentImpl extends AccessibleObject implements AspectComponent, Serializable {
  	private Class[] interfaces;
  	private Object key; // key used to reference this object; DG - would like to get rid of this
  	private Object target; // TODO: make this transient to prevent massive serialization...considering mobility etc. - making it transient blows up serialization
  	private Map perspectiveInterceptors; //[perspective, Map][method, interceptor]]]
      private ProxyFactory proxyFactory;
  
      public AspectComponentImpl(Object key, Class[] interfaces, Object target, ProxyFactory proxyFactory) {
          if (interfaces == null || interfaces.length == 0) {
  			throw new IllegalArgumentException("interfaces must be supplied");
  		}
  		if (target == null) {
  			throw new IllegalArgumentException("target must not be null");
  		}
          if (proxyFactory == null) {
              throw new IllegalArgumentException("ProxyFactory must not be null");
          }
  		this.key = key;
  		this.target = target;
  		this.interfaces = interfaces;
          this.proxyFactory = proxyFactory;
  		perspectiveInterceptors = new HashMap();
  		// add the default perspective
  		addPerspective(Perspective.DEFAULT);
  	}
  	
  	/***
  	 * Apply an interceptor to all methods - and if needed classify it using the given perspective.
  	 */
  	public void addInterceptor(Perspective perspective, MethodInterceptor methodInterceptor) {
  		for (Iterator iter = getPerspectiveInterceptorMap(perspective).values().iterator(); iter.hasNext();) {
  			List interceptors = (List) iter.next();
  			if (!interceptors.contains(methodInterceptor)) {
  				interceptors.add(methodInterceptor);
  			}
  		}
  	}
  
  	/***
  	 * Apply interceptor to only one method.
  	 * @param method
  	 * @param interceptor
  	 */
  	public void addInterceptor(Perspective perspective, Method method, MethodInterceptor interceptor) {
  		List interceptors = getInterceptorsForMethod(perspective, method);
  		if (!interceptors.contains(interceptor)) {
  			interceptors.add(interceptor);
  		}
  	}
  	
  	public Object getTarget() {
  		return target;
  	}
  
      public Object getProxy() {
          return getProxy(Perspective.DEFAULT);
  	}
  	
  	public Object getProxy(Perspective perspective) {
          return proxyFactory.createProxy(perspective, key, interfaces, this);
  	}
  
      // This is just for a perf test - will be removed
      public Object getCGLibProxy() {
          return proxyFactory.createProxy(key, interfaces, this, getPerspectiveInterceptorMap(Perspective.DEFAULT));
      }
  
  	/***
  	 * callback from the invocation handler - this is where we need to apply the associated perspective.
  	 */
  	public Object invokeMethod(Object key, Perspective perspective, Object proxy, Method method, Object[] args) throws Throwable {
  		Invocation invocation = getInvocation(key, perspective, method, args);
  		return invocation.proceed();
  	}
  	
  	public Method[] getInterfaceMethods() {
  		ArrayList list = new ArrayList();
 		for (int i = 0; i < interfaces.length; i++) {
 			Class anInterface = interfaces[i];
 			list.addAll(Arrays.asList(anInterface.getMethods()));
 		}
 		return (Method[]) list.toArray(new Method[list.size()]);
 	}
 
 	public Class[] getInterfaces() {
 		return interfaces;
 	}
 
 	private Map getPerspectiveInterceptorMap(Perspective perspective) {
 		if (perspectiveInterceptors.get(perspective) == null) {
 			addPerspective(perspective);
 		}
 		return (Map) perspectiveInterceptors.get(perspective);
 	}
 
 	
 	private Invocation getInvocation(Object key, Perspective perspective, Method method, Object[] args) {
 		return new AspectInvocation(this, key, target, method, args, getInterceptorsAsArray(perspective, method));
 	}
 
 	private MethodInterceptor[] getInterceptorsAsArray(Perspective perspective, Method method) {
 		List interceptors = getInterceptorsForMethod(perspective, method);
 		if (interceptors == null) {
 			return new MethodInterceptor[0];
 		}
 		return (MethodInterceptor[]) interceptors.toArray(new MethodInterceptor[interceptors.size()]);
 	}
 
 	private List getInterceptorsForMethod(Perspective perspective, Method method) {
 			Map methodMap = getPerspectiveInterceptorMap(perspective);
 			return (List) methodMap.get(getMethodKey(method));		
 	}
 
 	private Map createMethodToInterceptorMap() {
 		Map map = new HashMap();
 		for (int i = 0; i < interfaces.length; i++) {
 			initInterceptorChain(interfaces[i].getMethods(), map);
 		}
 		return map;
 	}
 
 	private void initInterceptorChain(Method[] methods, Map map) {
 		for (int i = 0; i < methods.length; i++) {
 			map.put(getMethodKey(methods[i]), new LinkedList());
 		}
 	}
 
     // this will not work with overridden methods!
 	private String getMethodKey(Method method) {
 		return method.getDeclaringClass().getName() + "." + method.getName();
 	}
 
 
 	private void addPerspective(Perspective perspective) {
 		perspectiveInterceptors.put(perspective, createMethodToInterceptorMap());
 	}
 
 }