/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * 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
 *
 * Created on: 10 déc. 2009
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "ExpressionEval.h"

#include <fml/executable/ExecutableLib.h>

#include <fml/expression/AvmCode.h>
#include <fml/expression/ExpressionConstructor.h>

#include <fml/operator/OperatorManager.h>


namespace sep
{


BF ExpressionEval::value(const BFCode & aCode, bool destroy_arg)
{
	switch( aCode.getAvmOpCode() )
	{
		case AVM_OPCODE_RANDOM:
		{
			return( ExpressionEval::random(aCode->first()) );
		}

		case AVM_OPCODE_ABS:
		{
			return( ExpressionEval::abs(aCode->first()) );
		}
		case AVM_OPCODE_CEIL:
		{
			return( ExpressionEval::ceil(aCode->first()) );
		}
		case AVM_OPCODE_FLOOR:
		{
			return( ExpressionEval::floor(aCode->first()) );
		}
		case AVM_OPCODE_ROUND:
		{
			return( ExpressionEval::round(aCode->first()) );
		}
		case AVM_OPCODE_TRUNCATE:
		{
			return( ExpressionEval::truncate(aCode->first()) );
		}


		case AVM_OPCODE_MIN:
		{
			return( ExpressionEval::min(aCode) );
		}
		case AVM_OPCODE_MAX:
		{
			return( ExpressionEval::max(aCode) );
		}


		case AVM_OPCODE_MOD:
		{
			return( ExpressionEval::mod(aCode->first(),
					aCode->second()) );
		}

		case AVM_OPCODE_SQRT:
		{
			return( ExpressionEval::sqrt(aCode->first()) );
		}

		case AVM_OPCODE_EXP:
		{
			return( ExpressionEval::exp(aCode->first()) );
		}
		case AVM_OPCODE_LN:
		{
			return( ExpressionEval::ln(aCode->first()) );
		}
		case AVM_OPCODE_LOG:
		{
			return( ExpressionEval::log(aCode->first()) );
		}

		case AVM_OPCODE_SIN:
		{
			return( ExpressionEval::sin(aCode->first()) );
		}
		case AVM_OPCODE_COS:
		{
			return( ExpressionEval::cos(aCode->first()) );
		}
		case AVM_OPCODE_TAN:
		{
			return( ExpressionEval::tan(aCode->first()) );
		}

		case AVM_OPCODE_SINH:
		{
			return( ExpressionEval::sinh(aCode->first()) );
		}
		case AVM_OPCODE_COSH:
		{
			return( ExpressionEval::cosh(aCode->first()) );
		}
		case AVM_OPCODE_TANH:
		{
			return( ExpressionEval::tanh(aCode->first()) );
		}

		case AVM_OPCODE_ASIN:
		{
			return( ExpressionEval::asin(aCode->first()) );
		}
		case AVM_OPCODE_ACOS:
		{
			return( ExpressionEval::acos(aCode->first()) );
		}
		case AVM_OPCODE_ATAN:
		{
			return( ExpressionEval::atan(aCode->first()) );
		}
		case AVM_OPCODE_ATAN2:
		{
			return( ExpressionEval::atan2(aCode->first(),
					aCode->second()) );
		}

		case AVM_OPCODE_ASINH:
		{
			return( ExpressionEval::asinh(aCode->first()) );
		}
		case AVM_OPCODE_ACOSH:
		{
			return( ExpressionEval::acosh(aCode->first()) );
		}
		case AVM_OPCODE_ATANH:
		{
			return( ExpressionEval::atanh(aCode->first()) );
		}


		default:
		{
			return( aCode );
		}
	}
}


BF ExpressionEval::random(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_RANDOM, aCode) );
}


BF ExpressionEval::abs(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ABS, aCode) );
}


BF ExpressionEval::ceil(const BF & aCode)
{
	if( aCode.isInteger() )
	{
		return( aCode );
	}

	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_CEIL, aCode) );
}


BF ExpressionEval::floor(const BF & aCode)
{
	if( aCode.isInteger() )
	{
		return( aCode );
	}

	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_FLOOR, aCode) );
}


BF ExpressionEval::round(const BF & aCode)
{
	if( aCode.isInteger() )
	{
		return( aCode );
	}

	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ROUND, aCode) );
}


BF ExpressionEval::truncate(const BF & aCode)
{
	if( aCode.isInteger() )
	{
		return( aCode );
	}

	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_TRUNCATE, aCode) );
}


BF ExpressionEval::min(const BF & aCode1, const BF & aCode2)
{
	if( aCode1 == ExecutableLib::_INFINITY_ )
	{
		return( aCode2 );
	}
	else if( aCode2 == ExecutableLib::_INFINITY_ )
	{
		return( aCode1 );
	}

	return( ExpressionConstructor::newCode(
			OperatorManager::OPERATOR_MIN, aCode1, aCode2) );
}


BF ExpressionEval::max(const BF & aCode1, const BF & aCode2)
{
	if( aCode1 == ExecutableLib::_INFINITY_ )
	{
		return( aCode1 );
	}
	else if( aCode2 == ExecutableLib::_INFINITY_ )
	{
		return( aCode2 );
	}

	return( ExpressionConstructor::newCode(
			OperatorManager::OPERATOR_MAX, aCode1, aCode2) );
}


BF ExpressionEval::min(const BFCode & aCode)
{
	AvmCode::size_type argCount = aCode->size();

	if( argCount > 2 )
	{
		BFList symbolicValue;
		BF minValue;

		AvmCode::iterator itArg = aCode->begin();
		AvmCode::iterator endArg = aCode->end();
		for( ; itArg != endArg ; ++itArg )
		{
			if ( (*itArg).isNumeric() )
			{
				minValue = (*itArg);

				// NEXT
				++itArg;

				break;
			}
			else if( (*itArg) != ExecutableLib::_INFINITY_ )
			{
				symbolicValue.add_union( (*itArg) );
			}
		}

		for( ; itArg != endArg ; ++itArg )
		{
			if( (*itArg) == ExecutableLib::_INFINITY_ )
			{
//				continue;
			}

			else if ( (*itArg).isNumeric() )
			{
				minValue = ExpressionEval::min(minValue, *itArg);
			}
			else
			{
				symbolicValue.add_union( (*itArg) );
			}
		}

		if( symbolicValue.nonempty() )
		{
			BFCode newCode(OperatorManager::OPERATOR_MIN);
			if( minValue.valid() )
			{
				newCode->append( minValue );
			}
			newCode->append( symbolicValue );

			return( newCode );
		}
		else if( minValue.valid() )
		{
			return( minValue );
		}
		else if( aCode->nonempty() )
		{
			return( aCode->first() );
		}
		else
		{
			return( aCode );
		}
	}
	else if( argCount == 2 )
	{
		return( ExpressionEval::min(aCode->first(), aCode->second()) );
	}
	else if( argCount == 1 )
	{
		return( aCode->first() );
	}
	else
	{
		return( aCode );
	}
}

BF ExpressionEval::max(const BFCode & aCode)
{
	AvmCode::size_type argCount = aCode->size();

	if( argCount > 2 )
	{
		BFList symbolicValue;
		BF maxValue;

		AvmCode::iterator itArg = aCode->begin();
		AvmCode::iterator endArg = aCode->end();
		for( ; itArg != endArg ; ++itArg )
		{
			if( (*itArg) == ExecutableLib::_INFINITY_ )
			{
				return( *itArg );
			}

			else if ( (*itArg).isNumeric() )
			{
				maxValue = (*itArg);

				// NEXT
				++itArg;

				break;
			}
			else
			{
				symbolicValue.add_union( (*itArg) );
			}
		}

		for( ; itArg != endArg ; ++itArg )
		{
			if( (*itArg) == ExecutableLib::_INFINITY_ )
			{
				return( (*itArg) );
			}

			else if ( (*itArg).isNumeric() )
			{
				maxValue = ExpressionEval::max(maxValue, *itArg);
			}
			else
			{
				symbolicValue.add_union( (*itArg) );
			}
		}

		if( symbolicValue.nonempty() )
		{
			BFCode newCode(OperatorManager::OPERATOR_MAX);
			if( maxValue.valid() )
			{
				newCode->append( maxValue );
			}
			newCode->append( symbolicValue );

			return( newCode );
		}
		else if( maxValue.valid() )
		{
			return( maxValue );
		}
		else if( aCode->nonempty() )
		{
			return( aCode->first() );
		}
		else
		{
			return( aCode );
		}
	}
	else if( argCount == 2 )
	{
		return( ExpressionEval::max(aCode->first(), aCode->second()) );
	}
	else if( argCount == 1 )
	{
		return( aCode->first() );
	}
	else
	{
		return( aCode );
	}
}


BF ExpressionEval::mod(const BF & aCode1, const BF & aCode2)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_MOD, aCode1, aCode2) );
}


BF ExpressionEval::sqrt(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_SQRT, aCode) );
}


BF ExpressionEval::exp(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_EXP, aCode) );
}


BF ExpressionEval::ln(const BF & aCode)
{
	switch( aCode.classKind() )
	{
		case FORM_BUILTIN_INTEGER_KIND:
		{
			if( aCode.to_ptr< Integer >()->toInteger() > 0 )
			{
//				return( ExpressionConstructor::newFloat(
//						::ln(aCode.to_ptr< Integer >()->toInteger())) );
			}
			break;
		}

		case FORM_BUILTIN_FLOAT_KIND:
		{
			if( aCode.toFloat() > 0 )
			{
//				return( ExpressionConstructor::newFloat(
//						::ln(aCode.toFloat())) );
			}
			break;
		}


		default:
		{
			break;
		}
	}

	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_LN, aCode) );
}


BF ExpressionEval::log(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_LOG, aCode) );
}


BF ExpressionEval::sin(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_SIN, aCode) );
}

BF ExpressionEval::cos(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_COS, aCode) );
}

BF ExpressionEval::tan(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_TAN, aCode) );
}


BF ExpressionEval::sinh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_SINH, aCode) );
}

BF ExpressionEval::cosh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_COSH, aCode) );
}

BF ExpressionEval::tanh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_TANH, aCode) );
}


BF ExpressionEval::asin(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ASIN, aCode) );
}

BF ExpressionEval::acos(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ACOS, aCode) );
}

BF ExpressionEval::atan(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ATAN, aCode) );
}


BF ExpressionEval::atan2(const BF & aCode1, const BF & aCode2)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ATAN2, aCode1, aCode2) );
}


BF ExpressionEval::asinh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ASINH, aCode) );
}

BF ExpressionEval::acosh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ACOSH, aCode) );
}

BF ExpressionEval::atanh(const BF & aCode)
{
	return( ExpressionConstructor::newExpr(
			OperatorManager::OPERATOR_ATANH, aCode) );
}


}