/*******************************************************************************
 * Copyright (c) 2006 Oracle Corporation.
 * 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:
 *    Cameron Bateman/Oracle - initial API and implementation
 *    
 ********************************************************************************/

package org.eclipse.jst.jsf.validation.internal.el.operators;

import java.math.BigDecimal;
import java.math.BigInteger;

import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.jsf.common.internal.types.FloatLiteralType;
import org.eclipse.jst.jsf.common.internal.types.IAssignable;
import org.eclipse.jst.jsf.common.internal.types.IntegerLiteralType;
import org.eclipse.jst.jsf.common.internal.types.LiteralType;
import org.eclipse.jst.jsf.common.internal.types.TypeCoercer;
import org.eclipse.jst.jsf.common.internal.types.TypeCoercionException;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.TypeTransformer;
import org.eclipse.jst.jsf.common.internal.types.ValueType;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;

/**
 * Represents non-dividing arithmetic EL operators: +,-,*
 * Based on JSP.2.3.5.1
 * 
 * @author cbateman
 *
 */
/*package*/ abstract class NoDivArithmeticBinaryOperator extends ArithmeticBinaryOperator 
{
    NoDivArithmeticBinaryOperator(DiagnosticFactory diagnosticFactory) {
        super(diagnosticFactory);
    }

    protected abstract Long doRealOperation(Long firstArg, Long secondArg);
    
    protected abstract Double doRealOperation(Double firstArg, Double secondArg);

    public ValueType performOperation(ValueType firstArg, ValueType secondArg)
    {
        // JSP.2.3.5.1, step 1, if either arg is null, return (Long) 0
        if (TypeCoercer.typeIsNull(firstArg.getSignature())
                && TypeCoercer.typeIsNull(secondArg.getSignature()))
        {
            return new IntegerLiteralType(0);
        }
        
        final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
        final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
        
        // JSP.2.3.5.1, step 2, if either arg is a BigDecimal, coerce to BigDecimal
        // and apply
        if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
                || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg))
        {
            return handleNumericArithmetic(firstArg, secondArg, BigDecimal.class);
        }
        
        // JSP.2.3.5.1, step 3, if either arg is float or double or 
        // a String containing "., e or E", then coerce if the other is
        // a big int, coerce up to BigDecimal, else to Double
        // Note: we are ignoring strings we can't resolve to figure out
        // if the contain "., e or E".  Assume they always do
        if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg)
                ||TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg)
                ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg)
                ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg))
        {
            if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
                    ||TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
            {
                // if the other operand is BigInteger, treat as BigDecimal
                return handleNumericArithmetic(firstArg, secondArg, BigDecimal.class);
            }

            // otherwise as double
            return handleNumericArithmetic(firstArg, secondArg, Double.class);
        }
        
        // JSP.2.3.5.1, step 4, if one is a big integer, coerce to big integer
        if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
                || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
        {
            return handleNumericArithmetic(firstArg, secondArg, BigInteger.class);
        }
        
        // JSP.2.3.5.1, step 5, otherwise, try to coerce to Long
        return handleNumericArithmetic(firstArg, secondArg, Long.class);
    }

    public Diagnostic validate(ValueType firstArg, ValueType secondArg) 
    {
        // JSP.2.3.5.1, step 1, if either arg is null, return (Long) 0
        if (TypeCoercer.typeIsNull(firstArg.getSignature())
                && TypeCoercer.typeIsNull(secondArg.getSignature()))
        {
            return _diagnosticFactory.create_BINARY_OP_BOTH_OPERANDS_NULL(getOperatorName());
        }
        
        final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
        final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
        
        // JSP.2.3.5.1, step 2, if either arg is a BigDecimal, coerce to BigDecimal
        // and apply
        if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
                || TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg))
        {
            return validateNumericArithmetic(firstArg, secondArg, BigDecimal.class);
        }
        
        // JSP.2.3.5.1, step 3, if either arg is float or double or 
        // a String containing "., e or E", then coerce if the other is
        // a big int, coerce up to BigDecimal, else to Double
        // Note: we are ignoring strings we can't resolve to figure out
        // if the contain "., e or E".  Assume they always do
        if (TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedFirstArg)
                ||TypeConstants.TYPE_BOXED_DOUBLE.equals(boxedSecondArg)
                ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedFirstArg)
                ||TypeConstants.TYPE_BOXED_FLOAT.equals(boxedSecondArg))
        {
            if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
                    ||TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
            {
                // if the other operand is BigInteger, treat as BigDecimal
                return validateNumericArithmetic(firstArg, secondArg, BigDecimal.class);
            }

            // otherwise as double
            return validateNumericArithmetic(firstArg, secondArg, Double.class);
        }
        
        // JSP.2.3.5.1, step 4, if one is a big integer, coerce to big integer
        if (TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
                || TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
        {
            return validateNumericArithmetic(firstArg, secondArg, BigInteger.class);
        }
        
        // JSP.2.3.5.1, step 5, otherwise, try to coerce to Long
        return validateNumericArithmetic(firstArg, secondArg, Long.class);
    }

    /**
     * @param firstArg
     * @param secondArg
     * @param numberType
     * @return a value type based on the result of the arithmetic operation
     */
    protected ValueType handleNumericArithmetic(ValueType firstArg, ValueType secondArg, Class numberType)
    {
        try
        {
//            final String coercedFirstArg = 
                TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
//            final String coercedSecondArg = 
                TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
            
            if (firstArg instanceof LiteralType && secondArg instanceof LiteralType)
            {
                try
                {
                    Number firstValue = 
                        ((LiteralType)firstArg).coerceToNumber(numberType);
                    Number secondValue = 
                        ((LiteralType)secondArg).coerceToNumber(numberType);
                    
                    LiteralType result = null;
                    
                    if (numberType == Double.class)
                    {
                        Double resultValue = 
                            doRealOperation((Double)firstValue, 
                                    (Double) secondValue);
                        result = new FloatLiteralType(resultValue.doubleValue());
                    }
                    else if (numberType == Long.class)
                    {
                        Long resultValue = 
                            doRealOperation((Long) firstValue, (Long) secondValue);
                        result = new IntegerLiteralType(resultValue.longValue());
                    }
                    else
                    {
                        throw new AssertionError("unsupport arithmetic upcast type");
                    }
                    
                    return result;  
                }
                catch (TypeCoercionException tce)
                {
                    // could happen if two string literals passed
                    return null;
                }
            }
            
            // if we get to here, then we have two valid numeric arith
            // types, but at least one is not a literal, so the best we can
            // say is that the return will be the same asthe type of numeric
            // coercion
            if (numberType == BigDecimal.class)
            {
                return new ValueType(TypeConstants.TYPE_BIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
            }
            else if (numberType == Double.class)
            {
                return new ValueType(Signature.SIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
            }
            else if (numberType == BigInteger.class)
            {
                return new ValueType(TypeConstants.TYPE_BIG_INTEGER, IAssignable.ASSIGNMENT_TYPE_RHS);
            }
            else
            {
                return new ValueType(Signature.SIG_LONG, IAssignable.ASSIGNMENT_TYPE_RHS);
            }
        }
        catch (TypeCoercionException tce)
        {
            // coercion to number failed, so no go
            return null;
        }
    }
    
    /**
     * @param firstArg
     * @param secondArg
     * @param numberType
     * @return a diagnostic validating the arithmetic expr firstArg op secondArg
     */
    protected Diagnostic validateNumericArithmetic(ValueType firstArg, ValueType secondArg, Class numberType)
    {
        try
        {
//            final String coercedFirstArg = 
            TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
//            final String coercedSecondArg = 
            TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
            
            if (firstArg instanceof LiteralType && secondArg instanceof LiteralType)
            {
                try
                {
                    Number firstValue = 
                        ((LiteralType)firstArg).coerceToNumber(numberType);
                    Number secondValue = 
                        ((LiteralType)secondArg).coerceToNumber(numberType);
                    
                    Number result = null;
                    
                    if (numberType == Double.class)
                    {
                        result =
                            doRealOperation((Double)firstValue, 
                                    (Double) secondValue);
                    }
                    else if (numberType == Long.class)
                    {
                        result =
                            doRealOperation((Long) firstValue, (Long) secondValue);
                    }
                    else
                    {
                        throw new AssertionError("unsupport arithmetic upcast type");
                    }
                    
                    return _diagnosticFactory.
                        create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME
                            (getOperatorName(), result.toString());  
                }
                catch (TypeCoercionException tce)
                {
                    // could happen when two strings are passed
                    return _diagnosticFactory.
                        create_BINARY_OP_COULD_NOT_COERCE_LITERALS_TO_NUMBERS();
                }
            }
            
            // if we get to here, then we have two valid numeric arith
            // types, but at least one is not a literal
            // everything should be ok
            return Diagnostic.OK_INSTANCE;
        }
        catch (TypeCoercionException tce)
        {
            // coercion to number failed, so no go
            return _diagnosticFactory.
                create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(getOperatorName());
        }
    }

}