/*
    * 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.math.BigDecimal;
  import java.math.BigInteger;
  
  import org.peaseplate.TemplateRuntimeException;
  import org.peaseplate.internal.BuildContext;
  import org.peaseplate.internal.conversion.ConversionException;
  import org.peaseplate.locator.TemplateLocator;
  import org.peaseplate.service.ConversionService;
  
  public abstract class AbstractNumericCommand extends AbstractDoubleParameterCommand {
  
  	public AbstractNumericCommand(TemplateLocator locator, int line, int column, ICommand leftCommand, ICommand rightCommand) {
  		super(locator, line, column, leftCommand, rightCommand);
  	}
  
  	public abstract String getSign();
  	
  	public Object call(BuildContext context) throws TemplateRuntimeException {
  		Object result = null;
  		ConversionService conversionService = context.getEngine().getConversionService();
  		Object left = callLeftCommand(context);
  		Object right = callRightCommand(context);
  		Class<?> leftType = (left != null) ? left.getClass() : Void.class;
  		Class<?> rightType = (right != null) ? right.getClass() : Void.class;
  		
  		try {
  			if ((leftType == StringBuilder.class) || (rightType == StringBuilder.class))
  				result = calculate(
  					conversionService.convey(left, StringBuilder.class),
  					conversionService.convey(right, StringBuilder.class)
  				);
  
  			else if ((leftType == StringBuffer.class) || (rightType == StringBuffer.class))
  				result = calculate(
  					conversionService.convey(left, StringBuffer.class),
  					conversionService.convey(right, StringBuffer.class)
  				);
  			
  			else if ((leftType == String.class) || (rightType == String.class))
  				result = calculate(
  					conversionService.convey(left, String.class),
  					conversionService.convey(right, String.class)
  				);
  			
  			else if ((leftType == BigDecimal.class) || (rightType == BigDecimal.class))
  				result = calculate(
  					conversionService.convey(left, BigDecimal.class),
  					conversionService.convey(right, BigDecimal.class)
  				);
  			
  			else if ((leftType == BigInteger.class) || (rightType == BigInteger.class))
  				result = calculate(
  					conversionService.convey(left, BigInteger.class),
  					conversionService.convey(right, BigInteger.class)
  				);
  			
  			else if (
  				(leftType == double.class) || (leftType == Double.class) ||
  				(rightType == double.class) || (rightType == Double.class)
  			)
  				result = calculate(
  					conversionService.convey(left, Double.class),
  					conversionService.convey(right, Double.class)
  				);
  			
  			else if (
  				(leftType == float.class) || (leftType == Float.class) ||
  				(rightType == float.class) || (rightType == Float.class)
  			)
  				result = calculate(
  					conversionService.convey(left, Float.class),
  					conversionService.convey(right, Float.class)
  				);
  			
  			else if (
  				(leftType == long.class) || (leftType == Long.class) ||
  				(rightType == long.class) || (rightType == Long.class)
  			)
 				result = calculate(
 					conversionService.convey(left, Long.class),
 					conversionService.convey(right, Long.class)
 				);
 			
 			else if (
 				(leftType == int.class) || (leftType == Integer.class) ||
 				(rightType == int.class) || (rightType == Integer.class)
 			)
 				result = calculate(
 					conversionService.convey(left, Integer.class),
 					conversionService.convey(right, Integer.class)
 				);
 			
 			else if (
 				(leftType == char.class) || (leftType == Character.class) ||
 				(rightType == char.class) || (rightType == Character.class)
 			)
 				result = calculate(
 					conversionService.convey(left, Character.class),
 					conversionService.convey(right, Character.class)
 				);
 			
 			else if (
 				(leftType == short.class) || (leftType == Short.class) ||
 				(rightType == short.class) || (rightType == Short.class)
 			)
 				result = calculate(
 					conversionService.convey(left, Short.class),
 					conversionService.convey(right, Short.class)
 				);
 			
 			else if (
 				(leftType == byte.class) || (leftType == Byte.class) ||
 				(rightType == byte.class) || (rightType == Byte.class)
 			)
 				result = calculate(
 					conversionService.convey(left, Byte.class),
 					conversionService.convey(right, Byte.class)
 				);
 			
 			else
 				result = calculate(left, right);
 		}
 		catch (ConversionException e) {
 			if (e.getValue() == left)
 				throw new TemplateRuntimeException(
 					getLeftCommand().getLocator(), getLeftCommand().getLine(), getLeftCommand().getColumn(),
 					"Could not convert left operator to " + e.getType(), e
 				);
 	
 			else if (e.getValue() == right)
 				throw new TemplateRuntimeException(
 					getRightCommand().getLocator(), getRightCommand().getLine(), getRightCommand().getColumn(),
 					"Could not convert right operator to " + e.getType(), e
 				);
 	
 			else 
 				throw new TemplateRuntimeException(
 					getLocator(), getLine(), getColumn(),
 					"Could not convert operator to " + e.getType(), e
 				);
 		}
 
 	    return result;
     }
 
 	public Byte calculate(Byte left, Byte right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Byte.class
 		);
 	}
 	
 	public Short calculate(Short left, Short right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Short.class
 		);
 	}
 	
 	public Character calculate(Character left, Character right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Character.class
 		);
 	}
 	
 	public Integer calculate(Integer left, Integer right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Integer.class
 		);
 	}
 	
 	public Long calculate(Long left, Long right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Long.class
 		);
 	}
 	
 	public Float calculate(Float left, Float right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Float.class
 		);
 	}
 	
 	public Double calculate(Double left, Double right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + Double.class
 		);
 	}
 	
 	public BigInteger calculate(BigInteger left, BigInteger right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + BigInteger.class
 		);
 	}
 	
 	public BigDecimal calculate(BigDecimal left, BigDecimal right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + BigDecimal.class
 		);
 	}
 	
 	public String calculate(String left, String right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + String.class
 		);
 	}
 	
 	public StringBuffer calculate(StringBuffer left, StringBuffer right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + StringBuffer.class
 		);
 	}
 	
 	public StringBuilder calculate(StringBuilder left, StringBuilder right) throws TemplateRuntimeException {
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + StringBuilder.class
 		);
 	}
 	
 	public Object calculate(Object left, Object right) throws TemplateRuntimeException {
 		Class<?> leftType = (left != null) ? left.getClass() : Void.class;
 		Class<?> rightType = (right != null) ? right.getClass() : Void.class;
 
 		throw new TemplateRuntimeException(
 			getLocator(), getLine(), getColumn(),
 			"Operation " + getSign() + " not supported on operands of type " + leftType + " and " + rightType
 		);
 	}
 	
 	/**
 	 * @see java.lang.Object#toString()
 	 */
 	@Override
 	public String toString() {
 		return "(" + getLeftCommand() + " " + getSign() + " " + getRightCommand() + ")";
 	}
 	
 }