/*******************************************************************************
 * Copyright (c) 2003, 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
 *******************************************************************************/
package org.eclipse.jem.internal.java.adapters.jdk;
/*


 */

import java.util.List;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.XMIResource;
import org.eclipse.jem.java.*;
import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
import org.eclipse.jem.java.internal.impl.MethodImpl;
/**
 * Insert the type's description here.
 * Creation date: (6/6/2000 4:42:50 PM)
 * @author: Administrator
 */
public class JavaMethodJDKAdaptor extends JDKAdaptor implements IJavaMethodAdapter {
	protected java.lang.reflect.AccessibleObject sourceAccessible = null; // Could be method or ctor.
	protected Class parentType = null;
	// cache a static empty Class[] for no parm methods
	protected static Class[] emptyClassArray = new Class[0];
	// cache a static empty String[], too
	protected static String[] emptyStringArray = new String[0];
	public JavaMethodJDKAdaptor(Notifier target, JavaJDKAdapterFactory anAdapterFactory) {
		super(target, anAdapterFactory);
	}
	/**
	 * addExceptions - reflect our exception list
	 */
	protected void addExceptions() {
		Class[] exceptions =
			(getSourceAccessible() instanceof java.lang.reflect.Method)
				? ((java.lang.reflect.Method) getSourceAccessible()).getExceptionTypes()
				: ((java.lang.reflect.Constructor) getSourceAccessible()).getExceptionTypes();
		//	EList exList = (EList) javaMethodTarget.primRefValue(JavaRefPackage.eINSTANCE.getMethod_JavaExceptions());
		List exList = getMethodTarget().getJavaExceptionsGen();
		for (int i = 0; i < exceptions.length; i++) {
			exList.add(createJavaClassRef(exceptions[i].getName()));
		}
	}

	protected MethodImpl getMethodTarget() {
		return (MethodImpl) getTarget();
	}
	/**
	 * addParameters - reflect our parms
	 */
	protected void addParameters() {
		Class[] parmTypes =
			(getSourceAccessible() instanceof java.lang.reflect.Method)
				? ((java.lang.reflect.Method) getSourceAccessible()).getParameterTypes()
				: ((java.lang.reflect.Constructor) getSourceAccessible()).getParameterTypes();
		MethodImpl javaMethodTarget = getMethodTarget();
		// 	List pList = (List) javaMethodTarget.primRefValue(JavaRefPackage.eINSTANCE.getMethod_Parameters());
		List pList = javaMethodTarget.getParametersGen();
		for (int i = 0; i < parmTypes.length; i++) {
			pList.add(createJavaParameter(javaMethodTarget, "arg" + i, getTypeName(parmTypes[i]))); //$NON-NLS-1$
		}
	}
	protected JavaClass getContainingJavaClass() {
		return ((Method) getTarget()).getContainingJavaClass();
	}
	/**
	 * getParentType - return the Class which corresponds to our parent JavaClass
	 * we're going to do this a lot, so cache it.
	 */
	protected Class getParentType() {
		if (parentType == null) {
			Method targetMethod = (Method) getTarget();
			JavaClass parentJavaClass = targetMethod.getContainingJavaClass();
			JavaClassJDKAdaptor pa = (JavaClassJDKAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
			if (pa != null)
				parentType = pa.getSourceType();
		}
		return parentType;
	}
	/**
	 * getParmTypeSignatures - return an array of Classes for our parameter types
	 * 	For reflection purposes, we can only rely on our ID, since our parms may
	 *  not yet be known.
	 */
	protected Class[] getParmTypes() {
		Method javaMethodTarget = (Method) getTarget();
		String id = ((XMIResource) javaMethodTarget.eResource()).getID(javaMethodTarget);
		String[] typeNames = getTypeNamesFromMethodID(id);
		if (typeNames == null)
			return emptyClassArray;
		int n = typeNames.length;
		if (n == 0)
			return emptyClassArray;
		Class[] types = new Class[n];
		for (int i = 0; i < n; ++i) {
			types[i] = getType(typeNames[i]);
		}
		return types;
	}
	public Object getReflectionSource() {
		return getSourceAccessible();
	}
	
    /* (non-Javadoc)
     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
     */
    public boolean hasCachedReflectionSource() { 
        return sourceAccessible != null;
    }
	/**
	 * getsourceMethod - return the java.lang.reflect.Method which describes our implementing method
	 */
	protected java.lang.reflect.AccessibleObject getSourceAccessible() {
		if (sourceAccessible == null) {
			Class parent = this.getParentType();
			if (parent != null) {
				Class[] parmTypes = this.getParmTypes();
				try {
					sourceAccessible = parent.getDeclaredMethod(((Method) getTarget()).getName(), parmTypes);
				} catch (NoSuchMethodException e) {
					// OK, can't reflect it
				}

				if (sourceAccessible == null) {
					// It wasn't a method, try for constructor.
					try {
						sourceAccessible = parent.getDeclaredConstructor(parmTypes);
					} catch (NoSuchMethodException e) {
						// OK, can't reflect it
					}
				}
			}
		}
		return sourceAccessible;
	}
	/**
	 * getValueIn method comment.
	 */
	public Object getValueIn(EObject object, EObject attribute) {
		// At this point, this adapter does not dynamically compute any values,
		// all values are pushed back into the target on the initial call.
		return super.getValueIn(object, attribute);
	}
	/**
	 * reflectValues - template method, subclasses override to pump values into target.
	 * on entry: UUID, name, containing package (and qualified name), and document must be set.
	 * Method adaptor:
	 *	- set modifiers
	 *	- set name
	 * 	- set return type
	 * 	- add parameters
	 * 	- add exceptions
	 */
	public boolean reflectValues() {
		if (getSourceAccessible() != null) {
			((Method) getTarget()).setIsGenerated(false);
			setModifiers();
			setNaming();
			setReturnType();
			addParameters();
			addExceptions();
			return true;
		}
		return false;
	}
	
	
	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter#reflectGeneratedIfNecessary()
	 */
	public boolean reflectGeneratedIfNecessary() {
		return reflectValuesIfNecessary();
	}
	
	public boolean reflectParamNamesIfNecessary() {
		return reflectValuesIfNecessary();
	}
	
	/**
	 * setModifiers - set the attribute values related to modifiers here
	 */
	protected void setModifiers() {
		Method methodTarget = (Method) getTarget();
		int modifiers =
			(getSourceAccessible() instanceof java.lang.reflect.Method)
				? ((java.lang.reflect.Method) getSourceAccessible()).getModifiers()
				: ((java.lang.reflect.Constructor) getSourceAccessible()).getModifiers();
		methodTarget.setAbstract(java.lang.reflect.Modifier.isAbstract(modifiers));
		methodTarget.setFinal(java.lang.reflect.Modifier.isFinal(modifiers));
		methodTarget.setNative(java.lang.reflect.Modifier.isNative(modifiers));
		methodTarget.setStatic(java.lang.reflect.Modifier.isStatic(modifiers));
		methodTarget.setSynchronized(java.lang.reflect.Modifier.isSynchronized(modifiers));
		methodTarget.setConstructor(getSourceAccessible() instanceof java.lang.reflect.Constructor);
		// Set visibility
		JavaClass javaClass = getContainingJavaClass();
		if ((javaClass.getKind() == TypeKind.INTERFACE_LITERAL) || (java.lang.reflect.Modifier.isPublic(modifiers)))
			methodTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
		else if (java.lang.reflect.Modifier.isPrivate(modifiers))
			methodTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
		else if (java.lang.reflect.Modifier.isProtected(modifiers))
			methodTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
		else
			//Visibility must be package
			methodTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
	}
	/**
	 * setNaming - set the naming values here
	 * 	- qualified name must be set first, that is the path to the real Java class
	 *	- ID
	 * 	- name-based UUID
	 */
	protected void setNaming() {
		//
		//	naming is currently a no-op since the name and UUID must be set prior to reflection
		//	...and ID is redundant with UUID.
		//	javaFieldTarget.setID(parent.getQualifiedName() + "_" + javaFieldTarget.getName());
	}
	/**
	 * setType - set our return type here
	 */
	protected void setReturnType() {
		if (getSourceAccessible() instanceof java.lang.reflect.Method) {
			Class type = ((java.lang.reflect.Method) getSourceAccessible()).getReturnType();
			Method javaMethodTarget = (Method) getTarget();
			/*
					JavaParameter newParameter = createJavaParameter(javaMethodTarget, "result", getTypeName(type));//$NON-NLS-1$
					newParameter.setParameterKind(MetaJavaParameterKind.RETURN);
					javaMethodTarget.getParameters().add(newParameter);
			*/
			javaMethodTarget.setEType(createJavaClassRef(getTypeName(type)));
		}
	}
}