/*******************************************************************************
 * 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 mai 2016
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and Implementation
 ******************************************************************************/

#ifndef FML_NUMERIC_BASIC_RATIONALIMPL_H_
#define FML_NUMERIC_BASIC_RATIONALIMPL_H_

#include <fml/numeric/Number.h>

#include <fml/numeric/Integer.h>

#include <cmath>


namespace sep
{


template< typename Num_T , typename Den_T >
class BasicRational
{

public:
	/**
	 * TYPEDEF
	 */
	typedef  Num_T  TNum;
	typedef  Den_T  TDen;


protected:
	/**
	 * ATTRIBUTES
	 */
	Num_T mNumerator;
	Den_T mDenominator;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	BasicRational(Num_T aNumerator, Den_T aDenominator)
	: mNumerator( aNumerator ),
	mDenominator( aDenominator )
	{
		simplif();
	}


	BasicRational(const std::string & aNumerator, Den_T aDenominator)
	: mNumerator( sep::string_to< Num_T >(aNumerator, std::dec) ),
	mDenominator( aDenominator )
	{
		simplif();
	}

	BasicRational(Num_T aNumerator, const std::string & aDenominator)
	: mNumerator( aNumerator ),
	mDenominator( sep::string_to< Num_T >(aDenominator, std::dec) )
	{
		simplif();
	}

	BasicRational(const std::string & aNumerator,
			const std::string & aDenominator)
	: mNumerator( sep::string_to< Num_T >(aNumerator  , std::dec) ),
	mDenominator( sep::string_to< Den_T >(aDenominator, std::dec) )
	{
		simplif();
	}

	BasicRational(const std::string & aRational)
	: mNumerator( 0 ),
	mDenominator( 1 )
	{
		fromString(this, aRational);

		simplif();
	}

	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	BasicRational(const BasicRational & aRational)
	: mNumerator  ( aRational.mNumerator ),
	mDenominator( aRational.mDenominator )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~BasicRational()
	{
		//!! NOTHING
	}


	inline static void fromString(BasicRational * rop, const std::string & aValue)
	{
		std::string::size_type pos = aValue.find('/');
		if( pos != std::string::npos)
		{
			rop->mNumerator = sep::string_to< Num_T >(
					aValue.substr(0, pos), std::dec);
			rop->mDenominator = sep::string_to< Num_T >(
					aValue.substr(pos+1), std::dec);
		}
		else if( (pos = aValue.find('.')) != std::string::npos )
		{
			rop->mNumerator = sep::string_to< Num_T >(
					std::string(aValue).erase(pos, 1), std::dec);

			rop->mDenominator = Integer::ipow(10, aValue.size() - (pos + 1));
		}
		else
		{
			rop->mNumerator = sep::string_to< Num_T >(aValue, std::dec);
			rop->mDenominator = 1;
		}
	}

	/**
	 * GETTER - SETTER
	 * ThisNumberClass::mValue
	 */
	inline Den_T gcd(Den_T a, Den_T b)
	{
		Den_T tmp;
		while( b != 0 )
		{
			tmp = b;
			b = a % b;
			a = tmp;
		}

		return( a );
	}

	inline bool simplif()
	{
		if( mDenominator != 1 )
		{
			Den_T d = gcd((mNumerator < 0) ? (-mNumerator) : mNumerator,
					mDenominator);

			if( (d != 0) && (d != 1) )
			{
				mNumerator   = static_cast< Num_T >( mNumerator   / d );
				mDenominator = static_cast< Den_T >( mDenominator / d );
			}
		}

		return( true );
	}


	/**
	 * GETTER - SETTER
	 * ThisNumberClass::mValue
	 */
	inline Num_T rawNumerator() const
	{
		return( mNumerator );
	}

	inline Den_T rawDenominator() const
	{
		return( mDenominator );
	}


	inline void setValue(Num_T aNumerator, Den_T aDenominator)
	{
		mNumerator   = aNumerator;
		mDenominator = aDenominator;

		simplif();
	}

	inline void setValue(Num_T aValue)
	{
		mNumerator   = aValue;
		mDenominator = 1;
	}


	/**
	 * CONVERSION
	 */
	inline virtual avm_float_t toFloat() const
	{
		return( static_cast< avm_float_t >( mNumerator / mDenominator ) );
	}


	/**
	 * COMPARISON
	 * OPERATOR
	 */
	// operator==
	inline bool operator==(const BasicRational & other) const
	{
		return( ( mDenominator == other.mDenominator ) ?
				(mNumerator == other.mNumerator) :
				(mNumerator * other.mDenominator ==
						mDenominator * other.mNumerator) );
	}

	inline bool operator==(avm_integer_t aValue) const
	{
		return( mNumerator == mDenominator * aValue );
	}

	// operator!=
	inline bool operator!=(const BasicRational & other) const
	{
		return( ! operator==(other) );
	}

	inline bool operator!=(avm_integer_t aValue) const
	{
		return( mNumerator != mDenominator * aValue );
	}

	// operator<
	inline bool operator<(const BasicRational & other) const
	{
		return( ( mDenominator == other.mDenominator ) ?
				(mNumerator < other.mNumerator) :
				(mNumerator * other.mDenominator <
						mDenominator * other.mNumerator) );
	}

	inline bool operator<(avm_integer_t aValue) const
	{
		return( mNumerator < mDenominator * aValue );
	}

	// operator<=
	inline bool operator<=(const BasicRational & other) const
	{
		return( ( mDenominator == other.mDenominator ) ?
				(mNumerator <= other.mNumerator) :
				(mNumerator * other.mDenominator <=
						mDenominator * other.mNumerator) );
	}

	inline bool operator<=(avm_integer_t aValue) const
	{
		return( mNumerator <= mDenominator * aValue );
	}

	// operator>
	inline bool operator>(const BasicRational & other) const
	{
		return( ( mDenominator == other.mDenominator ) ?
				(mNumerator > other.mNumerator) :
				(mNumerator * other.mDenominator >
						mDenominator * other.mNumerator) );
	}

	inline bool operator>(avm_integer_t aValue) const
	{
		return( mNumerator > mDenominator * aValue );
	}

	// operator>=
	inline bool operator>=(const BasicRational & other) const
	{
		return( ( mDenominator == other.mDenominator ) ?
				(mNumerator >= other.mNumerator) :
				(mNumerator * other.mDenominator >=
						mDenominator * other.mNumerator) );
	}

	inline bool operator>=(avm_integer_t aValue) const
	{
		return( mNumerator > mDenominator * aValue );
	}


	/**
	 * ARITHMETIC
	 * OPERATOR
	 */
	// operator+
	inline BasicRational operator+(const BasicRational & other)
	{
		return( BasicRational((mNumerator * other.mDenominator) +
					(mDenominator * other.mNumerator) ,
				mDenominator * other.mDenominator) );
	}

	inline BasicRational operator+(avm_integer_t aValue)
	{
		return( BasicRational(mNumerator + mDenominator * aValue ,
				mDenominator) );
	}

	// operator-
	inline BasicRational & operator-()
	{
		return( BasicRational(- mNumerator , mDenominator) );
	}


	inline BasicRational operator-(avm_integer_t aValue)
	{
		return( BasicRational(mNumerator - mDenominator * aValue ,
				mDenominator) );
	}

	inline BasicRational operator-(const BasicRational & other)
	{
		return( BasicRational((mNumerator * other.mDenominator) -
					(mDenominator * other.mNumerator) ,
				mDenominator * other.mDenominator) );
	}

	// operator*
	inline BasicRational operator*(const BasicRational & other)
	{
		return( BasicRational(mNumerator * other.mNumerator ,
				mDenominator * other.mDenominator) );
	}

	inline BasicRational & operator*(avm_integer_t aValue)
	{
		return( BasicRational(mNumerator * aValue , mDenominator) );
	}

	// operator/
	inline BasicRational operator/(const BasicRational & other)
	{
		return( BasicRational(mNumerator * other.mDenominator ,
				mDenominator * other.mNumerator) );
	}

	inline BasicRational operator/(avm_integer_t aValue)
	{
		return( BasicRational(mNumerator , mDenominator * aValue) );
	}


	/**
	 * math function
	 */
	inline void set_pow(avm_uinteger_t anExponent)
	{
		mNumerator   = Integer::ipow(mNumerator, anExponent);
		mDenominator = Integer::ipow(mDenominator, anExponent);
	}

};


class Rational :
		public Number,
		public GenericNumberClass<
				BasicRational< avm_integer_t , avm_integer_t > , Rational >
{

	AVM_DECLARE_CLONABLE_CLASS( Rational )


	/**
	 * TYPEDEF
	 */
public:
	typedef  BasicRational< avm_integer_t , avm_integer_t >  RawValueType;

private:
	typedef GenericNumberClass< RawValueType , Rational >  ThisNumberClass;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	Rational(const RawValueType & aValue)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aValue) )
	{
		//!! NOTHING
	}

	// Integer / Integer
	Rational(const Integer & aNumerator, const Integer & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator.getValue(), aDenominator.getValue()) )
	{
		//!! NOTHING
	}

	Rational(avm_integer_t aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	Rational(avm_integer_t aNumerator, avm_uinteger_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	Rational(avm_uinteger_t aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	Rational(avm_uinteger_t aNumerator, avm_uinteger_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	Rational(const Integer & aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator.getValue(), 1) )
	{
		//!! NOTHING
	}

	// avm_integer_t  i.e.  avm_int64_t
	Rational(avm_integer_t aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

	// avm_uinteger_t  i.e.  avm_uint64_t
	Rational(avm_uinteger_t aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

#ifdef _AVM_NEED_INT64_T_OVERLOADS_

	// long
	Rational(long aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

	// unsigned long
	Rational(unsigned long aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

#endif /* _AVM_NEED_INT64_T_OVERLOADS_ */

	// int32_t
	Rational(int aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

	// uint32_t
	Rational(unsigned int aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, 1) )
	{
		//!! NOTHING
	}

	// std::string / avm_integer_t
	Rational(const std::string & aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	// avm_integer_t / std::string
	Rational(avm_integer_t aNumerator, const std::string & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	// std::string / std::string
	Rational(const std::string & aNumerator, const std::string & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		//!! NOTHING
	}

	// std::string
	Rational(const std::string & aRational)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aRational) )
	{
		//!! NOTHING
	}


	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	Rational(const Rational & aRational)
	: Number( aRational ),
	ThisNumberClass( aRational )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~Rational()
	{
		//!! NOTHING
	}


	/**
	 * GETTER - SETTER
	 * ThisNumberClass::mValue
	 */
	inline Integer getNumerator() const
	{
		return( Integer( ThisNumberClass::mValue.rawNumerator() ) );
	}

	inline Integer getDenominator() const
	{
		return( Integer( ThisNumberClass::mValue.rawDenominator() ) );
	}


	inline Integer::RawValueType rawNumerator() const
	{
		return( ThisNumberClass::mValue.rawNumerator() );
	}

	inline Integer::RawValueType rawDenominator() const
	{
		return( ThisNumberClass::mValue.rawDenominator() );
	}


	inline void setValue(avm_integer_t aNumerator, avm_integer_t aDenominator)
	{
		ThisNumberClass::mValue = RawValueType(aNumerator, aDenominator);
	}

	inline void setValue(avm_integer_t aValue)
	{
		ThisNumberClass::mValue = RawValueType(aValue, 1);
	}


	/**
	 * BASICS TESTS
	 */
	virtual inline int sign() const
	{
		return( (ThisNumberClass::mValue.rawNumerator() < 0) ? -1 :
				(ThisNumberClass::mValue.rawNumerator() > 0) );
	}

	virtual inline bool strictlyPositive() const
	{
		return( ThisNumberClass::mValue.rawNumerator() > 0 );
	}

	virtual inline bool strictlyNegative() const
	{
		return( ThisNumberClass::mValue.rawNumerator() < 0 );
	}

	virtual inline bool isZero() const
	{
		return( ThisNumberClass::mValue.rawNumerator() == 0 );
	}

	virtual inline bool isOne() const
	{
		return( ThisNumberClass::mValue.rawNumerator() ==
				ThisNumberClass::mValue.rawDenominator() );
	}

	virtual inline bool isNegativeOne() const
	{
		return( (ThisNumberClass::mValue.rawNumerator() ==
				ThisNumberClass::mValue.rawDenominator()) &&
				strictlyNegative() );
	}


	/**
	 * CONVERSION
	 */
	inline virtual bool isInt32() const
	{
		return( (ThisNumberClass::mValue.rawDenominator() == 1) &&
				(static_cast< avm_integer_t >(AVM_NUMERIC_MIN_INT) <=
						ThisNumberClass::mValue.rawNumerator()) &&
				(ThisNumberClass::mValue.rawNumerator() <=
						static_cast< avm_integer_t >(AVM_NUMERIC_MAX_INT)) );
	}

	inline virtual avm_int32_t toInt32() const
	{
		return( static_cast< avm_int32_t >(
				ThisNumberClass::mValue.rawNumerator() ) );
	}

	inline virtual bool isInt64() const
	{
		return( (ThisNumberClass::mValue.rawDenominator() == 1) &&
				(static_cast< avm_integer_t >(AVM_NUMERIC_MIN_LONG) <=
						ThisNumberClass::mValue.rawNumerator()) &&
				(ThisNumberClass::mValue.rawNumerator() <=
						static_cast< avm_integer_t >(AVM_NUMERIC_MAX_LONG)) );
	}

	inline virtual avm_int64_t toInt64() const
	{
		return( static_cast< avm_int64_t >(
				ThisNumberClass::mValue.rawNumerator() ) );
	}


	inline virtual bool isInteger() const
	{
		return( ThisNumberClass::mValue.rawDenominator() == 1 );
	}

	inline virtual avm_integer_t toInteger() const
	{
		if( isInteger() )
		{
			return( ThisNumberClass::mValue.rawNumerator() );
		}
		else
		{
			return( static_cast< avm_integer_t >( toFloat() ) );
		}
	}


	inline virtual bool isPosInteger() const
	{
		return( (ThisNumberClass::mValue.rawDenominator() == 1) &&
				(ThisNumberClass::mValue.rawNumerator() >= 0) );
	}


	inline virtual bool isUInteger() const
	{
		return( (ThisNumberClass::mValue.rawDenominator() == 1) &&
				(ThisNumberClass::mValue.rawNumerator() >= 0) );
	}

	inline virtual avm_uinteger_t toUInteger() const
	{
		if( isUInteger() )
		{
			return( static_cast< avm_uinteger_t >(
					ThisNumberClass::mValue.rawNumerator() ) );
		}
		else if( toFloat() >= 0 )
		{
			return( static_cast< avm_uinteger_t >( toFloat() ) );
		}

		return( static_cast< avm_uinteger_t >( -1 ) );
	}


	inline virtual bool isRational() const
	{
		return( true );
	}

	virtual avm_integer_t toDenominator() const
	{
		return( ThisNumberClass::mValue.rawDenominator() );
	}

	virtual avm_integer_t toNumerator() const
	{
		return( ThisNumberClass::mValue.rawNumerator() );
	}


	inline virtual bool isFloat() const
	{
		return( true );
	}

	inline virtual avm_float_t toFloat() const
	{
		return( static_cast< avm_float_t >(
				ThisNumberClass::mValue.rawNumerator() /
				ThisNumberClass::mValue.rawDenominator()) );
	}


	inline virtual bool isReal() const
	{
		return( true );
	}

	inline virtual avm_real_t toReal() const
	{
		return( static_cast< avm_real_t >(
				ThisNumberClass::mValue.rawNumerator() /
				ThisNumberClass::mValue.rawDenominator()) );
	}


	/**
	 * math function
	 */
	inline void set_pow(avm_uinteger_t anExponent)
	{
		ThisNumberClass::mValue.set_pow( anExponent );
	}


	/**
	 * Serialization
	 */
	inline void toStream(OutStream & os) const
	{
		os << TAB << rawNumerator();
		if( rawDenominator() != 1 )
		{
			os << "/" << rawDenominator();
		}
		AVM_DEBUG_REF_COUNTER(os);
		os << EOL_FLUSH;
	}

	virtual std::string str() const
	{
		if( rawDenominator() != 1 )
		{
			return( OSS() << rawNumerator() << '/' << rawDenominator() );
		}
		else
		{
			return( OSS() << rawNumerator() );
		}
	}

	inline virtual std::string strNum(
			avm_uint8_t precision = AVM_MUMERIC_PRECISION) const
	{
		if( rawDenominator() != 1 )
		{
			return( OSS() << rawNumerator() << '/' << rawDenominator() );
		}
		else
		{
			return( OSS() << rawNumerator() );
		}
	}

	inline virtual std::string strNumerator(
			avm_uint8_t precision = AVM_MUMERIC_PRECISION) const
	{
		return( OSS() << rawNumerator() );
	}

	inline virtual std::string strDenominator(
			avm_uint8_t precision = AVM_MUMERIC_PRECISION) const
	{
		return( OSS() << rawDenominator() );
	}

};


} /* namespace sep */

#endif /* FML_NUMERIC_BASIC_RATIONALIMPL_H_ */