/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jem.internal.proxy.ide;
/*
 * $RCSfile: IDEStandardBeanProxyFactory.java,v $ $Revision: 1.7 $ $Date: 2004/10/12 20:20:14 $
 */

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.jem.internal.proxy.core.*;
import org.eclipse.jem.internal.proxy.initParser.InitializationStringParser;

public class IDEStandardBeanProxyFactory implements IStandardBeanProxyFactory {


	protected IDEProxyFactoryRegistry fRegistry;
	protected IDEStandardBeanTypeProxyFactory fBeanTypeProxyFactory;
	
	/*
	 * Return a bean proxy for the argument. To do this create through the correct BeanTypeProxy
	 * Which ensures that special subclasses of IDEBeanProxy are created. This is just a local
	 * helper method.
	 */
	static IIDEBeanProxy createBeanProxy(ProxyFactoryRegistry aRegistry, Object anObject) {

		return ((IDEStandardBeanProxyFactory) aRegistry.getBeanProxyFactory()).createIDEBeanProxyWith(anObject);
	}
	
	IDEStandardBeanProxyFactory(IDEProxyFactoryRegistry aRegistry) {
		fRegistry = aRegistry;
		fRegistry.registerBeanProxyFactory(this);
		fBeanTypeProxyFactory = (IDEStandardBeanTypeProxyFactory) aRegistry.getBeanTypeProxyFactory();
	}
	
	public IStringBeanProxy createBeanProxyWith(String aString) {
		return fBeanTypeProxyFactory.stringClass.createStringBeanProxy(aString);
	}
	
	public INumberBeanProxy createBeanProxyWith(float aFloat) {
		return fBeanTypeProxyFactory.floatType.createFloatBeanProxy(aFloat);
	}
	
	public INumberBeanProxy createBeanProxyWith(short aShort) {
		return fBeanTypeProxyFactory.shortType.createShortBeanProxy(aShort);
	}
	
	public ICharacterBeanProxy createBeanProxyWith(char aChar) {
		return fBeanTypeProxyFactory.charType.createCharBeanProxy(aChar);
	}
	
	public ICharacterBeanProxy createBeanProxyWith(Character aCharacter) {
		return fBeanTypeProxyFactory.charClass.createCharacterBeanProxy(aCharacter);
	}
	
	public IIntegerBeanProxy createBeanProxyWith(int anInt) {
		return fBeanTypeProxyFactory.intType.createIntegerBeanProxy(anInt);
	}
	
	public IIntegerBeanProxy createBeanProxyWith(Integer anInteger) {
		return fBeanTypeProxyFactory.integerClass.createIntegerBeanProxy(anInteger);
	}
	
	public INumberBeanProxy createBeanProxyWith(long aLong) {
		return fBeanTypeProxyFactory.longType.createLongBeanProxy(aLong);
	}
	
	public INumberBeanProxy createBeanProxyWith(Number aNumber) {
		IDENumberBeanTypeProxy numberTypeProxy = (IDENumberBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(aNumber.getClass());
		return numberTypeProxy.createNumberBeanProxy(aNumber);
	}
	
	public IBooleanBeanProxy createBeanProxyWith(boolean aBoolean) {
		return fBeanTypeProxyFactory.booleanType.createBooleanBeanProxy(aBoolean);
	}
	
	public IBooleanBeanProxy createBeanProxyWith(Boolean aBoolean) {
		return fBeanTypeProxyFactory.booleanClass.createBooleanBeanProxy(aBoolean);
	}
	
	public INumberBeanProxy createBeanProxyWith(byte aByte) {
		return fBeanTypeProxyFactory.byteType.createByteBeanProxy(aByte);
	}
	
	public INumberBeanProxy createBeanProxyWith(double aDouble) {
		return fBeanTypeProxyFactory.doubleType.createDoubleBeanProxy(aDouble);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#convertToPrimitiveBeanProxy(org.eclipse.jem.internal.proxy.core.IBeanProxy)
	 */
	public IBeanProxy convertToPrimitiveBeanProxy(IBeanProxy nonPrimitiveProxy) {
		if (nonPrimitiveProxy == null)
			return null;
		if (!nonPrimitiveProxy.isValid())
			return nonPrimitiveProxy;
		IDEBeanTypeProxy type = (IDEBeanTypeProxy) nonPrimitiveProxy.getTypeProxy();
		if (type.getClass() == Boolean.class)
			return this.createBeanProxyWith(((IBooleanBeanProxy) nonPrimitiveProxy).booleanValue());
		else if (type.getClass() == Byte.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).byteValue());
		else if (type.getClass() == Character.class)
			return this.createBeanProxyWith(((ICharacterBeanProxy) nonPrimitiveProxy).charValue());
		else if (type.getClass() == Double.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).doubleValue());
		else if (type.getClass() == Float.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).floatValue());
		else if (type.getClass() == Integer.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).intValue());
		else if (type.getClass() == Long.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).longValue());
		else if (type.getClass() == Short.class)
			return this.createBeanProxyWith(((INumberBeanProxy) nonPrimitiveProxy).shortValue());
		else
			return nonPrimitiveProxy;
	}

	/**
	 * Create a one-dimensional array. The result will be the same as calling
	 * createBeanProxyWith(IBeanTypeProxy type, new int[1] {x}) where 'x' is the value passed in as
	 * the dimension.
	 */
	public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int dimension) throws ThrowableProxy {
		return createBeanProxyWith(type, new int[] { dimension });
	}
	
	/**
	 * Create an array bean proxy.
	 *  - (int, new int[2] {3, 4}) will create: int [3] [4]
	 *  - (int[], new int[1] {1}) int [1]
	 *  - (int[], new int[2] {2,3}) int [2] [3]
	 * 
	 *  - (int[], null) or (int[], new int[0]) or (int, null) or (int, new int[0]) int [0]... or
	 * (int[][]..., null) or (int[][]..., new int[0]) int[0][]... This is because an array instance
	 * with no specified dimensions is not valid.
	 *  - (int[][], new int[1] {3}) int[3][]
	 */
	public IArrayBeanProxy createBeanProxyWith(IBeanTypeProxy type, int[] dimensions) throws ThrowableProxy {
		if (type.isArray())
			return ((IDEArrayBeanTypeProxy) type).createBeanProxyWith(dimensions); // Already an
																				   // array type,
																				   // just pass it
																				   // on.
		else {
			// It is not an array type, so we need to get an array of this type and dimensions.
			IDEArrayBeanTypeProxy arrayType =
				(IDEArrayBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(type.getTypeName(), dimensions.length);
			return arrayType.createBeanProxyWith(dimensions);
		}
	}
	
	public void releaseProxy(IBeanProxy aProxy) {
		// Do nothing. This is more for remote proxies
	}
	
	/**
	 * createIDEBeanProxyWith method comment. This is not part of the IStandardBeanProxyFactory
	 * interface. It is available only from IDEBeanProxyFactory so that IDE registered extensions
	 * can wrapper a bean. They will need to get current and explicitly cast to
	 * IDEBeanProxyFactory, so they should only be IDE types themselves.
	 */
	public IIDEBeanProxy createIDEBeanProxyWith(Object anObject) {
		if (anObject == null)
			return null;
		return ((IDEBeanTypeProxy) fBeanTypeProxyFactory.getBeanTypeProxy(anObject.getClass())).newBeanProxy(anObject);
	}
	
	/**
	 * For the IDE Factory we will create an IDEBeanProxy using the initializationString. If the
	 * format of the string is not one we understand, pass it onto the evaluator. The
	 * initStringParser is passed to allow shortcut evaluation. Package protected so only
	 * IDEBeanTypeProxies can create instances.
	 */
	IBeanProxy createBeanProxy(IDEBeanTypeProxy aTypeProxy, String initializationString) {
		if (initializationString.equals("null")) //$NON-NLS-1$
			return null; // Value is initialized as null.
		// We have to evaluate the result of the initializationString
		try {
			ClassLoader pluginClassLoader = fRegistry.getPluginClassLoader();
			Object newValue = InitializationStringParser.evaluate(initializationString, pluginClassLoader);
			return newValue != null ? aTypeProxy.newBeanProxy(newValue) : null;
		} catch (Exception exc) {
			ProxyPlugin.getPlugin().getLogger().log(
				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc));
			return null;
		}
	}
	
	/**
	 * For the IDE Factory we will create an IDEBeanProxy using the null constructor Package
	 * protected so only IDEBeanTypeProxies can create instances.
	 */
	IBeanProxy createBeanProxy(IDEBeanTypeProxy aTypeProxy) {

		Class beanType = aTypeProxy.fClass;

		// If the beanType is a primitive, the creation will fail because you can't
		// create a primitive without a value.
		try {
			return aTypeProxy.newBeanProxy(!(aTypeProxy.isPrimitive()) ? beanType.newInstance() : null);
		} catch (Exception exc) {
			ProxyPlugin.getPlugin().getLogger().log(
				new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc));
			return null;
		}
	}
	
	/*
	 *  (non-Javadoc)
	 * @see org.eclipse.jem.internal.proxy.core.IBeanProxyFactory#terminateFactory(boolean)
	 */
	public void terminateFactory(boolean wait) {
		// Nothing really to do here - more applicable to remote proxy factories
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createExpression()
	 */
	public IExpression createExpression() {
		return new IDEExpression(this.fRegistry);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanProxyFactory#createBeanProxyFrom(java.lang.String)
	 */
	public IBeanProxy createBeanProxyFrom(String initializationString) throws ThrowableProxy {
		if (initializationString.equals("null")) //$NON-NLS-1$
			return null; // Value is initialized as null.
		// We have to evaluate the result of the initializationString
		try {
			ClassLoader pluginClassLoader = fRegistry.getPluginClassLoader();
			InitializationStringParser parser = InitializationStringParser.createParser(initializationString, pluginClassLoader);
			Object newValue = parser.evaluate();
			if (newValue != null) {
				return fRegistry.getBeanProxy(parser.getExpectedType(), newValue);
			} else 
				return null;
		} catch (Exception exc) {
			ProxyPlugin.getPlugin().getLogger().log(
					new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc));
			return null;
		}
	}

}