/*******************************************************************************
 * Copyright (c) 2005 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
 *******************************************************************************/
/*
 *  $RCSfile: ExpressionProxy.java,v $
 *  $Revision: 1.5 $  $Date: 2005/08/24 20:39:05 $ 
 */
package org.eclipse.jem.internal.proxy.core;

import java.util.EventObject;
import java.util.logging.Level;
 

/**
 * This is a proxy for an IExpression evaluation value. It is used as a place holder proxy value for result of an expression, and
 * then the value can be used in a later expression, or at the end, it can callback and return a proxy in the IDE 
 * side in a callback for usage later on outside of the IExpression.
 * <p>
 * After receiving the resolved event, listeners should not hold onto the ExpressionProxy because it would then be invalid. At that
 * point they should instead hold onto the resolved bean proxy.
 * 
 * @see org.eclipse.jem.internal.proxy.core.IExpression#assignExpressionProxy()
 * @see org.eclipse.jem.internal.proxy.core.IExpression#createExpressionProxyExpression(int, ExpressionProxy)
 * @since 1.1.0
 */
public class ExpressionProxy implements IProxy {

	public ProxyFactoryRegistry getProxyFactoryRegistry() {
		return getExpression().getRegistry();
	}
	
	/**
	 * The event object for the resolved event of the proxy listener.
	 * <p>
	 * The source will be the ExpressionProxy that is being resolved.
	 * @since 1.1.0
	 */
	public static class ProxyEvent extends EventObject {
		
		/**
		 * Comment for <code>serialVersionUID</code>
		 * 
		 * @since 1.1.0
		 */
		private static final long serialVersionUID = -2305781662465107377L;
		private final IBeanProxy proxy;

		/**
		 * @param source the expression proxy for the event.
		 * @param proxy the bean proxy the expression proxy (source) resolved to.
		 * 
		 * @since 1.1.0
		 */
		public ProxyEvent(ExpressionProxy source, IBeanProxy proxy) {
			super(source);
			this.proxy = proxy;
		}
		
		/**
		 * Construct the event with no proxy. Used for not resolved and void.
		 * @param source
		 * 
		 * @since 1.1.0
		 */
		public ProxyEvent(ExpressionProxy source) {
			this(source, null);
		}
		
		/**
		 * Get the proxy value that the expression proxy (source) resolved to.
		 * @return
		 * 
		 * @since 1.1.0
		 */
		public IBeanProxy getProxy() {
			return proxy;
		}
	}
	
	/**
	 * Listener for expression proxy events.
	 * 
	 * @since 1.1.0
	 */
	public interface ProxyListener {
		/**
		 * The expression proxy has been resolved. The event contains the resolved proxy.
		 * At this point, any listeners should no longer hold onto the ExpressionProxy
		 * because it is now invalid. They should hold onto the resolved bean proxy instead.
		 * 
		 * @param event
		 * 
		 * @since 1.1.0
		 */
		public void proxyResolved(ProxyEvent event);
		
		/**
		 * This is called for ExpressionProxies that have a callback listener, but the proxy 
		 * was never resolved. This means that the expression that assigns to the proxy was
		 * not executed. In this case the event does not have a bean proxy in it.
		 * 
		 * @param event
		 * 
		 * @since 1.1.0
		 */
		public void proxyNotResolved(ProxyEvent event);
		
		/**
		 * This is called for ExpressionProxies that were assigned to an expression that
		 * had a <code>VOID</code> return type. This is usually for method invocations that
		 * have a void return type. In this case the event does not have a bean proxy in it.
		 * @param event
		 * 
		 * @since 1.1.0
		 */
		public void proxyVoid(ProxyEvent event);
	}
	
	/**
	 * An implementation of ProxyListener that does nothing. It can be
	 * used as a superclass for individual listeners that are only interested
	 * in some of the events.
	 * 
	 * @since 1.1.0
	 */
	public static class ProxyAdapter implements ProxyListener {
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyNotResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
		 */
		public void proxyNotResolved(ProxyEvent event) {
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
		 */
		public void proxyResolved(ProxyEvent event) {
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyVoid(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent)
		 */
		public void proxyVoid(ProxyEvent event) {
		}
	}
	
	final private int proxyID;
	final private int proxyType;
	private ListenerList listenerList;
	private Expression expression;
	
	/**
	 * Create with the given proxy id.
	 * @param proxyid
	 * 
	 * @since 1.1.0
	 */
	public ExpressionProxy(int proxyid, int proxyType, Expression expression) {
		this.proxyID = proxyid;
		this.proxyType = proxyType;
		this.expression = expression;
	}
	
	/**
	 * Get the expression this proxy is for. 
	 * @return
	 * 
	 * @since 1.1.0
	 */
	public Expression getExpression() {
		return expression;
	}
	
	/**
	 * Used internally in expression to get the proxy type. 
	 * @return
	 * 
	 * @since 1.1.0
	 */
	protected final int getProxyType() {
		return proxyType;
	}
	
	/**
	 * Return the proxy id.
	 * @return
	 * 
	 * @since 1.1.0
	 */
	public final int getProxyID() {
		return proxyID;
	}
	
	/**
	 * Add a listener. If listener already added, it has no effect.
	 * @param listener
	 * 
	 * @since 1.1.0
	 */
	public void addProxyListener(ProxyListener listener) {
		if (listenerList == null)
			listenerList = new ListenerList();
		listenerList.add(listener);
	}
	
	/**
	 * Remove a listener. If listener not already added, then no error.
	 * @param listener
	 * 
	 * @since 1.1.0
	 */
	public void removeProxyListener(ProxyListener listener) {
		if (listenerList != null)
			listenerList.remove(listener);
	}
	
	/**
	 * Used by internal subclasses or Expression to know if anyone is listening.
	 * @return
	 * 
	 * @since 1.1.0
	 */
	protected final boolean hasListeners() {
		return listenerList != null && !listenerList.isEmpty();
	}
	
	/**
	 * The proxy has been fired (one of the events has occurred). Subclasses should clean
	 * up and not hold onto anything that would be expensive in case the proxy is still
	 * held onto be someone. For example the default clears the listener list.
	 * <p>
	 * <b>Note:</b> Subclasses must call super.dispose().
	 * 
	 * @since 1.1.0
	 */
	protected void dispose() {
		listenerList = null;
		expression = null;
	}
	
	/**
	 * Used by internal subclasses  or by Expression to fire the resolved event. Once fired all listeners are removed.
	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
	 * prevents listeners from being held on to if any one accidently still holds the proxy.
	 * @param proxy
	 * 
	 * @since 1.1.0
	 */
	protected void fireResolved(IBeanProxy proxy) {
		if (hasListeners()) {
			ProxyEvent event = new ProxyEvent(this, proxy);
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				try {
					((ProxyListener) listeners[i]).proxyResolved(event);
				} catch (RuntimeException e) {
					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
				}
			}
		}
		dispose();
	}
	
	/**
	 * Used by internal subclasses or by Expression to fire the not resolved event. Once fired all listeners are removed.
	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
	 * prevents listeners from being held on to if any one accidently still holds the proxy.
	 * 
	 * @since 1.1.0
	 */
	protected void fireNotResolved() {
		if (hasListeners()) {
			ProxyEvent event = new ProxyEvent(this);
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				try {
					((ProxyListener) listeners[i]).proxyNotResolved(event);
				} catch (RuntimeException e) {
					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
				}
				
			}
		}
		dispose();
	}
	
	/**
	 * Used by internal subclasses or by Expression to fire the void resolved event. Once fired all listeners are removed.
	 * This is because only one kind of firing can be done for a expression proxy and then the proxy is dead. This
	 * prevents listeners from being held on to if any one accidently still holds the proxy.
	 * 
	 * @since 1.1.0
	 */
	protected void fireVoidResolved() {
		if (hasListeners()) {
			ProxyEvent event = new ProxyEvent(this);
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				try {
					((ProxyListener) listeners[i]).proxyVoid(event);
				} catch (RuntimeException e) {
					ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
				}
				
			}
		}
		dispose();
	}	

	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isBeanProxy()
	 */
	public final boolean isBeanProxy() {
		return false;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.proxy.core.IProxy#isExpressionProxy()
	 */
	public final boolean isExpressionProxy() {
		return true;
	}
	
	/**
	 * Is this proxy valid for reassignment. By default only if the type is NORMAL_EXPRESSION_PROXY.
	 * Subclasses may override and return true in their cases.
	 * 
	 * @return
	 * 
	 * @since 1.1.0
	 */
	public boolean isValidForReassignment() {
		return getProxyType() == Expression.NORMAL_EXPRESSION_PROXY;
	}
	
	
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		return super.toString()+": "+getProxyID(); //$NON-NLS-1$
	}
}