/*
 * Copyright 2005-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *	   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.ws.server.endpoint;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.MethodParameter;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;

/**
 * Represents a bean method that will be invoked as part of an incoming Web service message.
 *
 * <p>Consists of a {@link Method}, and a bean {@link Object}.
 *
 * @author Arjen Poutsma
 * @since 1.0.0
 */
public final class MethodEndpoint {

	private final Object bean;

	private final Method method;

	private final BeanFactory beanFactory;

	/**
	 * Constructs a new method endpoint with the given bean and method.
	 *
	 * @param bean	 the object bean
	 * @param method the method
	 */
	public MethodEndpoint(Object bean, Method method) {
		Assert.notNull(bean, "bean must not be null");
		Assert.notNull(method, "method must not be null");
		this.bean = bean;
		this.method = method;
		this.beanFactory = null;
	}

	/**
	 * Constructs a new method endpoint with the given bean, method name and parameters.
	 *
	 * @param bean			 the object bean
	 * @param methodName	 the method name
	 * @param parameterTypes the method parameter types
	 * @throws NoSuchMethodException when the method cannot be found
	 */
	public MethodEndpoint(Object bean, String methodName, Class<?>... parameterTypes) throws NoSuchMethodException {
		Assert.notNull(bean, "bean must not be null");
		Assert.notNull(methodName, "method must not be null");
		this.bean = bean;
		this.method = bean.getClass().getMethod(methodName, parameterTypes);
		this.beanFactory = null;
	}

	/**
	 * Constructs a new method endpoint with the given bean name and method. The bean name will be lazily initialized when
	 * {@link #invoke(Object...)} is called.
	 *
	 * @param beanName	  the bean name
	 * @param beanFactory the bean factory to use for bean initialization
	 * @param method	  the method
	 */
	public MethodEndpoint(String beanName, BeanFactory beanFactory, Method method) {
		Assert.hasText(beanName, "'beanName' must not be null");
		Assert.notNull(beanFactory, "'beanFactory' must not be null");
		Assert.notNull(method, "'method' must not be null");
		Assert.isTrue(beanFactory.containsBean(beanName),
				"Bean factory [" + beanFactory + "] does not contain bean " + "with name [" + beanName + "]");
		this.bean = beanName;
		this.beanFactory = beanFactory;
		this.method = method;
	}

	/** Returns the object bean for this method endpoint. */
	public Object getBean() {
		if (beanFactory != null && bean instanceof String) {
			String beanName = (String) bean;
			return beanFactory.getBean(beanName);
		}
		else {
			return bean;
		}
	}

	/** Returns the method for this method endpoint. */
	public Method getMethod() {
		return this.method;
	}

	/** Returns the method parameters for this method endpoint. */
	public MethodParameter[] getMethodParameters() {
		int parameterCount = getMethod().getParameterTypes().length;
		MethodParameter[] parameters = new MethodParameter[parameterCount];
		for (int i = 0; i < parameterCount; i++) {
			parameters[i] = new MethodParameter(getMethod(), i);
		}
		return parameters;
	}

	/** Returns the method return type, as {@code MethodParameter}. */
	public MethodParameter getReturnType() {
		return new MethodParameter(method, -1);
	}

	/**
	 * Invokes this method endpoint with the given arguments.
	 *
	 * @param args the arguments
	 * @return the invocation result
	 * @throws Exception when the method invocation results in an exception
	 */
	public Object invoke(Object... args) throws Exception {
		Object endpoint = getBean();
		ReflectionUtils.makeAccessible(method);
		try {
			return method.invoke(endpoint, args);
		}
		catch (InvocationTargetException ex) {
			handleInvocationTargetException(ex);
			throw new IllegalStateException(
					"Unexpected exception thrown by method - " + ex.getTargetException().getClass().getName() + ": " +
							ex.getTargetException().getMessage());
		}
	}

	private void handleInvocationTargetException(InvocationTargetException ex) throws Exception {
		Throwable targetException = ex.getTargetException();
		if (targetException instanceof RuntimeException) {
			throw (RuntimeException) targetException;
		}
		if (targetException instanceof Error) {
			throw (Error) targetException;
		}
		if (targetException instanceof Exception) {
			throw (Exception) targetException;
		}

	}

	public boolean equals(Object o) {
		if (this == o) {
			return true;
		}
		if (o != null && o instanceof MethodEndpoint) {
			MethodEndpoint other = (MethodEndpoint) o;
			return this.bean.equals(other.bean) && this.method.equals(other.method);
		}
		return false;
	}

	public int hashCode() {
		return 31 * this.bean.hashCode() + this.method.hashCode();
	}

	public String toString() {
		return method.toGenericString();
	}

}