/*
    * This file is part of Pease Plate Template Engine.
    * 
    * Pease Plate Template Engine is free software: you can redistribute
    * it and/or modify it under the terms of the GNU Lesser General 
    * Public License as published by the Free Software Foundation, 
    * either version 3 of the License, or any later version.
    * 
    * Pease Plate Template Engine is distributed in the hope that it 
   * will be useful, but WITHOUT ANY WARRANTY; without even the implied
   * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the GNU Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public 
   * License along with Pease Plate Template Engine. If not, see 
   * <http://www.gnu.org/licenses/>.
   * 
   * Copyright (c) 2008 Manfred HANTSCHEL
   */
  package org.peaseplate.internal.lang.command;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  
  import org.peaseplate.TemplateRuntimeException;
  import org.peaseplate.internal.BuildContext;
  import org.peaseplate.internal.util.ReflectionException;
  import org.peaseplate.internal.util.ReflectionUtils;
  import org.peaseplate.locator.TemplateLocator;
  
  public abstract class AbstractObjectCallCommand extends AbstractNativeCallCommand {
  
  	public AbstractObjectCallCommand(TemplateLocator locator, int line, int column, ICommand command, ICommand... parameterCommands) {
  	    super(locator, line, column, command, parameterCommands);
      }
  	
  	/**
  	 * Distinguishes between maps, lists and other objects. 
  	 * 
  	 * If object is a map, it resolves the return value from the map.
  	 * 
  	 * If the object is a list and the identifier is a number, it resolves 
  	 * the return value from the list.
  	 * 
  	 * If the object is an array and the identifier is a number, it resolves
  	 * the return value from the array.
  	 *  
  	 * In any other case, it invokes the method with the specified identifier
  	 * and the parameters on the object.
  	 * 
  	 * It depends on the call in which order the options are used.
  	 * 
  	 * @param onObject the object
  	 * @param identifier the name of the map entry, the index of the list, or the name of the method.
  	 * @param parameters the parameters
  	 * @return the result
  	 */
  	protected abstract Object callObject(BuildContext context, Object onObject, Object identifier) throws TemplateRuntimeException;
  	
  	protected Object callField(Object onObject, Field field) throws TemplateRuntimeException {
  		try {
  	        return field.get(onObject);
          }
          catch (IllegalArgumentException e) {
  			throw new TemplateRuntimeException(
  				getLocator(), getLine(), getColumn(),
  				"Illegal argument exception when calling field \"" + field + "\"", e
  			);
          }
          catch (IllegalAccessException e) {
  			throw new TemplateRuntimeException(
  				getLocator(), getLine(), getColumn(),
  				"Cannot access field \"" + field + "\"", e
  			);
          }
  	}
  	
  	protected Object callMap(BuildContext context, Map<?, ?> onMap, Object identifier) throws TemplateRuntimeException {
  		if (hasParameters())
  			return callMethod(context, onMap, String.valueOf(identifier));
  
  		return onMap.get(identifier);
  	}
  	
  	protected Object callList(List<?> onList, int index) throws TemplateRuntimeException {
  		if (hasParameters())
  			throw new TemplateRuntimeException(
  				getLocator(), getLine(), getColumn(), "Calls on a List must not have parameters"
  			);
  		
  		if ((index < 0) || (index >= onList.size()))
  			return null;
  		
  		return onList.get(index);
  	}
 	
 	protected Object callArray(Object[] onArray, int index) throws TemplateRuntimeException {
 		if (hasParameters())
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(), "Calls on an Array must not have parameters"
 			);
 		
 		if ((index < 0) || (index >= onArray.length))
 			return null;
 		
 		return onArray[index];
 	}
 
 	protected Object callFieldOrMethod(BuildContext context, Object onObject, String identifier) throws TemplateRuntimeException {
 		identifier = identifier.toLowerCase(Locale.getDefault());
 		
 		if (!hasParameters()) {
 			Field field = getField(onObject.getClass(), identifier);
 			
 			if (field != null)
 				return callField(onObject, field);
 		}
 		
 		return callMethod(context, onObject, identifier);
 	}
 	
 	protected Object callMethod(BuildContext context, Object onObject, String identifier) throws TemplateRuntimeException {
 		Method method = getMethod(onObject.getClass(), identifier.toLowerCase(Locale.getDefault()), getNumberOfParameters());
 		
 		if (method == null)
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(), 
 				"No method matches " + ReflectionUtils.formatMethodName(onObject.getClass(), identifier, getNumberOfParameters())
 			);
 		
 		return callMethod(context, onObject, method);
 	}
 
 	protected Object callMethod(BuildContext context, Object onObject, Method method) throws TemplateRuntimeException {
 		try {
 			Object[] parameters = ReflectionUtils.callParameterCommands(context, getParameterCommands(), method);
 
 			return method.invoke(onObject, parameters);
 		}
 		catch (ReflectionException e) {
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(),
 				"Could not call " + method, e
 			);
 		}
 		
 		catch (IllegalAccessException e) {
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(),
 				"Illegal access on method " + method, e
 			);
 		}
 		catch (IllegalArgumentException e) {
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(),
 				"Invalid argument when calling method " + method, e
 			);
 		}
 		catch (InvocationTargetException e) {
 			throw new TemplateRuntimeException(
 				getLocator(), getLine(), getColumn(),
 				"Call on " + method + " threw exception", e
 			);
 		}
 	}
 	
 	protected abstract Field getField(Class<?> clazz, String identifier) throws TemplateRuntimeException;
 	
 	protected Field findField(Class<?> clazz, String identifier) throws TemplateRuntimeException {
 		identifier = identifier.toLowerCase(Locale.getDefault());
 		
 		return scanFields(clazz, identifier);
 	}
 	
 	protected Field scanFields(Class<?> clazz, String identifier) throws TemplateRuntimeException {
 		Field[] fields = clazz.getFields();
 		
 		for (int i=fields.length-1; i>=0; i-=1)
 			if (identifier.equalsIgnoreCase(fields[i].getName()))
 				return fields[i];
 
 		return null;
 	}
 		
 	protected abstract Method getMethod(Class<?> clazz, String identifier, int numberOfParameters) throws TemplateRuntimeException;
 	
 }