/*******************************************************************************
 * Copyright (c) 2001, 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.adapters.jdom;

import java.util.List;
import java.util.Map;

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.jdt.core.*;

import org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter;
import org.eclipse.jem.internal.java.adapters.ReadAdaptor;
import org.eclipse.jem.internal.java.adapters.nls.ResourceHandler;
import org.eclipse.jem.java.*;
import org.eclipse.jem.java.internal.impl.MethodImpl;
import org.eclipse.jem.util.TimerTests;
import org.eclipse.jem.internal.plugin.JavaPlugin;

/**
 * Java Method Reflection Adapter for JDOM (i.e. JDT model)
 * Creation date: (6/6/2000 4:42:50 PM)
 * @author: Administrator
 */
public class JavaMethodJDOMAdaptor extends JDOMAdaptor implements IJavaMethodAdapter  {

	/*
	 * Step ids used for TimerTests of performance testing.
	 */
	public static final String REFLECT_METHOD = "Reflect JDOM Method"; //$NON-NLS-1$

	protected IMethod sourceMethod = null;

	protected IType parentType = null;

	public JavaMethodJDOMAdaptor(Notifier target, IJavaProject workingProject) {
		super(target, workingProject);
	}

	
	protected boolean flushReflectedValues(boolean clearCachedModelObject) {
		if (clearCachedModelObject)
			clearSource();
		MethodImpl method = (MethodImpl) getTarget();
		method.setIsGenerated(false);
		method.setFinal(false);
		method.setNative(false);
		method.setStatic(false);
		method.setSynchronized(false);
		method.setConstructor(false);
		method.setAbstract(false);
		method.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
		method.setEType(null);
		method.getParametersGen().clear();
		method.getJavaExceptionsGen().clear();		
		parentType = null;
		return true;
	}
	
	protected void postFlushReflectedValuesIfNecessary(boolean isExisting) {
		((MethodImpl) getTarget()).setReflected(false);
		super.postFlushReflectedValuesIfNecessary(isExisting);
	}	
	/**
	 * addExceptions - reflect our exception list
	 */
	protected void addExceptions() {
		try {
			IMethod sourceMethod = getSourceMethod();
			String[] exceptionNames = sourceMethod.getExceptionTypes();
			List exceptions = ((MethodImpl) getTarget()).getJavaExceptionsGen();
			for (int i = 0; i < exceptionNames.length; i++) {
				exceptions.add(createJavaClassRef(typeNameFromSignature(exceptionNames[i])));
			}
		} catch (JavaModelException npe) {
			// name stays null and we carry on
		}
	}
	
	
	protected String[] getParameterNames() {
		String[] parmNames = new String[0], parmTypeNames = getSourceMethod().getParameterTypes();
		try {
			parmNames = getSourceMethod().getParameterNames();
		} catch (JavaModelException npe) {
			// name stays null and we carry on
		}
		// Temp hack to work around a JavaModel bug, above call on a Binary method may return null
		if (parmNames == null || parmNames.length == 0) {
			parmNames = new String[parmTypeNames.length];
			for (int i = 0; i < parmTypeNames.length; i++) {
				parmNames[i] = "arg" + i;//$NON-NLS-1$
			}
		}	
		return parmNames;
	}

	/**
	 * addParameters - reflect our parms
	 */
	protected void addParameters() {
		String[] parmTypeNames = getSourceMethod().getParameterTypes();
		MethodImpl javaMethodTarget = (MethodImpl) getTarget();
		List params = javaMethodTarget.getParametersGen();
		for (int i = 0; i < parmTypeNames.length; i++) {
			params.add(createJavaParameter(javaMethodTarget, null, typeNameFromSignature(parmTypeNames[i])));
		}
	}

	protected void clearSource() {
		sourceMethod = null;
	}

	protected JavaClass getContainingJavaClass() {
		return ((Method) getTarget()).getContainingJavaClass();
	}

	/**
	 * getParentType - return the IType which corresponds to our parent JavaClass we're going to do this a lot, so cache it.
	 */
	protected IType getParentType() {
		if (parentType == null) {
			Method targetMethod = (Method) getTarget();
			if(targetMethod != null){
				JavaClass parentJavaClass = targetMethod.getContainingJavaClass();
				JavaClassJDOMAdaptor pa = (JavaClassJDOMAdaptor) EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
				if (pa != null)
					parentType = pa.getSourceType();
			}
		}
		return parentType;
	}

	/**
	 * getParmTypeSignatures - return an array of Strings (in Signature format) for our parameter types For reflection purposes, we can only rely on
	 * our UUID, since our parms may not yet be known. see org.eclipse.jdt.core.SourceMapper.convertTypeNamesToSigs()
	 */
	protected String[] getParmTypeSignatures() {
		Method javaMethodTarget = (Method) getTarget();
		String[] typeNames = getTypeNamesFromMethodID(((XMIResource) javaMethodTarget.eResource()).getID(javaMethodTarget));
		if (typeNames == null)
			return emptyStringArray;
		int n = typeNames.length;
		if (n == 0)
			return emptyStringArray;
		String[] typeSigs = new String[n];
		try {
			for (int i = 0; i < n; ++i) {
				typeSigs[i] = Signature.createTypeSignature(new String(typeNames[i]), getParentType().isBinary());
			}
		} catch (IllegalArgumentException e) {
			JavaPlugin.logError(e);
		}
		return typeSigs;
	}

	public Object getReflectionSource() {
		return getSourceMethod();
	}
	
    /* (non-Javadoc)
     * @see org.eclipse.jem.internal.java.adapters.JavaReflectionAdaptor#hasReflectionSource()
     */
    public boolean hasCachedReflectionSource() {
        return sourceMethod != null;
    }

	/*
	 * Used by Java Class JDOM adapter to create and set with a source method/
	 */	
	public void primSetMethod(IMethod method) {
		sourceMethod = method;
	}
	/**
	 * getsourceMethod - return the IMethod which describes our implementing method
	 */
	public IMethod getSourceMethod() {
		if ((sourceMethod == null) || (!sourceMethod.exists())) {
			try {
				IType parent = this.getParentType();
				if (parent != null) {
					String[] parmNames = this.getParmTypeSignatures();
					sourceMethod = JDOMSearchHelper.searchForMatchingMethod(parent, ((Method) getTarget()).getName(), parmNames);
				}
			} catch (JavaModelException e) {
				//do nothing
			}
		}
		return sourceMethod;
	}

	protected IType getType() {
		return getParentType();
	}

	protected Map getTypeResolutionCache() {
		Method method = (Method) getTarget();
		if (method != null) {
			JavaClass javaClass = method.getJavaClass();
			if (javaClass != null) {
				JDOMAdaptor classAdaptor = (JDOMAdaptor) retrieveAdaptorFrom(javaClass);
				if (classAdaptor != null)
					return classAdaptor.getTypeResolutionCache();
			}
		}
		return null;
	}

	/**
	 * 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() {
		super.reflectValues();
		try {
			TimerTests.basicTest.startCumulativeStep(REFLECT_METHOD);
			if (isResourceLoaded() && getSourceProject() != null && getSourceMethod() != null && sourceMethod.exists()) {
				setModifiers();
				setNaming();
				setReturnType();
				addParameters();
				addExceptions();
				return true;
			}
		} finally {
			TimerTests.basicTest.stopCumulativeStep(REFLECT_METHOD);
		}
		return false;
	}

	/**
	 * Set the generated flag if @generated is found in the source.
	 */
	protected void setGeneratedFlag() {
		Method methodTarget = (Method) getTarget();
		try {
			String source = getSourceMethod().getSource();
			if (source != null) {
				int index = source.indexOf(Method.GENERATED_COMMENT_TAG);
				if (index > 0)
					methodTarget.setIsGenerated(true);
			}
		} catch (JavaModelException npe) {
			//System.out.println(ResourceHandler.getString("Error_Setting_GenFlag_ERROR_", new Object[]
			// {((XMIResource)methodTarget.eResource()).getID(methodTarget), npe.getMessage()})); //$NON-NLS-1$ = "error setting the generated flag on
			// {0}, exception: {1}"
		}
	}

	
	/* (non-Javadoc)
	 * @see org.eclipse.jem.internal.java.adapters.IJavaMethodAdapter#reflectGeneratedIfNecessary()
	 */
	public boolean reflectGeneratedIfNecessary() {
		if (reflectValuesIfNecessary()) {
			setGeneratedFlag();
			return true;
		}
		return false;
	}
	
	public boolean reflectParamNamesIfNecessary() {
		if (reflectValuesIfNecessary()) {
			String [] paramNames = getParameterNames();
			List param = ((MethodImpl)getTarget()).getParameters();
			for (int i = 0; i < paramNames.length; i++) {
				((JavaParameter)param.get(i)).setName(paramNames[i]);				
			}
			return true;
		}
		return false;
	}
	/**
	 * setModifiers - set the attribute values related to modifiers here
	 */
	protected void setModifiers() {
		Method methodTarget = (Method) getTarget();
		try {
			methodTarget.setFinal(Flags.isFinal(getSourceMethod().getFlags()));
			methodTarget.setNative(Flags.isNative(getSourceMethod().getFlags()));
			methodTarget.setStatic(Flags.isStatic(getSourceMethod().getFlags()));
			methodTarget.setSynchronized(Flags.isSynchronized(getSourceMethod().getFlags()));
			methodTarget.setConstructor(getSourceMethod().isConstructor());

			JavaClass javaClass = getContainingJavaClass();
			//Set abstract
			if (javaClass.getKind().getValue() == TypeKind.INTERFACE)
				methodTarget.setAbstract(true);
			else
				methodTarget.setAbstract(Flags.isAbstract(getSourceMethod().getFlags()));
			// Set visibility
			if (javaClass.getKind().getValue() == TypeKind.INTERFACE || Flags.isPublic(getSourceMethod().getFlags()))
				methodTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
			else if (Flags.isPrivate(getSourceMethod().getFlags()))
				methodTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
			else if (Flags.isProtected(getSourceMethod().getFlags()))
				methodTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
			else
				//Visibility must be package
				methodTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
		} catch (JavaModelException npe) {
			System.out
					.println(ResourceHandler
							.getString(
									"Error_Introspecting_Flags_ERROR_", (new Object[] { ((XMIResource) methodTarget.eResource()).getID(methodTarget), npe.getMessage()}))); //$NON-NLS-1$ = "error introspecting flags on {0}, exception: {1}"
		}
	}

	/**
	 * 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() {
		String typeName = null;
		try {
			typeName = typeNameFromSignature(getSourceMethod().getReturnType());
		} catch (JavaModelException npe) {
			// name stays null and we carry on
		}
		if (typeName != null) {
			Method javaMethodTarget = (Method) getTarget();
			javaMethodTarget.setEType(createJavaClassRef(typeName));
		}
	}

	/**
	 * Insert the method's description here. Creation date: (10/3/2001 10:08:34 AM)
	 * 
	 * @param newSourceMethod
	 *            org.eclipse.jdt.core.IMethod
	 */
	public void setSourceMethod(org.eclipse.jdt.core.IMethod newSourceMethod) {
		sourceMethod = newSourceMethod;
	}
	
	/*
	 * Override to tolerate JDK 5 variable types.
	 * @see org.eclipse.jem.internal.adapters.jdom.JDOMAdaptor#typeNameFromSignature(java.lang.String)
	 */
	protected String typeNameFromSignature(String typeSignature) {
		String erasure = null;
		try {
			erasure = Signature.getTypeErasure(typeSignature);
		} catch (IllegalArgumentException e) {
			//The signature is not the correct format for a variable.
		}
		if (erasure != null) {
			String variableName = null;
			String resolvedVariable = null;
			
			int arrayCount = Signature.getArrayCount(erasure);
			if (arrayCount > 0) {
				//We have an array.  Check if the element type is a variable.
				String elementTypeName = Signature.getElementType(erasure);
				variableName = Signature.toString(elementTypeName);
				resolvedVariable = resolveVariableName(erasure, variableName);
				if (resolvedVariable != null) {
					//Add array info.
					StringBuffer b = new StringBuffer(resolvedVariable);
					for (int i = 0; i < arrayCount; i++) {
						b.append("[]"); //$NON-NLS-1$
					}
					resolvedVariable = b.toString();
				}
			} else {
				variableName = Signature.toString(erasure);
				//Need to resolve the variable.
				resolvedVariable = resolveVariableName(erasure, variableName);
			}
			if (resolvedVariable == null) {
				return super.typeNameFromSignature(erasure);
			} else {
				return resolvedVariable;
			}
		}
		return super.typeNameFromSignature(typeSignature);
	}


	private String resolveVariableName(String erasure, String variableName) {
		IMethod method = getSourceMethod();
		ITypeParameter[] typeParameters = null;
		try {
			typeParameters = method.getTypeParameters();
		} catch (JavaModelException e1) {
			//Failed to retrieve type parameters for any number of reasons.
		}
		ITypeParameter typeParam = null;
		if (typeParameters != null && typeParameters.length > 0) {
			for (int i = 0; i < typeParameters.length; i++) {
				if (typeParameters[i].exists() && variableName.equals(typeParameters[i].getElementName())) {
					typeParam = typeParameters[i];
					break;
				}
			}
			if (typeParam != null) {
				String[] bounds = null;
				try {
					bounds = typeParam.getBounds();
				} catch (JavaModelException e) {}
				if (bounds != null && bounds.length > 0) {
					return JDOMSearchHelper.getResolvedTypeName(bounds[0], getType(), getTypeResolutionCache());
				} else {
					return "java.lang.Object";
				}
			}
		}

		IJavaElement parent = method.getParent();
		if (parent instanceof IType)
		{
			try {
				typeParameters = ((IType)parent).getTypeParameters();
			} catch (JavaModelException e1) {
				//Failed to retrieve type parameters for any number of reasons.
			}
		}
		if (typeParameters != null && typeParameters.length > 0) {
			for (int i = 0; i < typeParameters.length; i++) {
				if (typeParameters[i].exists() && variableName.equals(typeParameters[i].getElementName())) {
					typeParam = typeParameters[i];
					break;
				}
			}
			if (typeParam != null) {
				String[] bounds = null;
				try {
					bounds = typeParam.getBounds();
				} catch (JavaModelException e) {}
				if (bounds != null && bounds.length > 0) {
					return JDOMSearchHelper.getResolvedTypeName(bounds[0], getType(), getTypeResolutionCache());
				} else {
					return "java.lang.Object";
				}
			}
		}
		return null;
	}
}