/*******************************************************************************
 * 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_GMP_RATIONALIMPL_H_
#define FML_NUMERIC_GMP_RATIONALIMPL_H_

#include <gmpxx.h>

#include <fml/numeric/Number.h>

#include <fml/numeric/Integer.h>

#include <cmath>


namespace sep
{


class Rational :
		public Number,
		public GenericNumberClass< mpq_class , Rational >
{

	AVM_DECLARE_CLONABLE_CLASS( Rational )


	/**
	 * TYPEDEF
	 */
public:
	typedef  mpq_class  RawValueType;

private:
	typedef  GenericNumberClass< RawValueType , Rational >  ThisNumberClass;


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

	// mpq_t
	Rational(const mpq_t & aValue)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aValue) )
	{
		simplif();
	}

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

	// Integer::RawValueType / Integer::RawValueType
	// i.e mpz_class / mpz_class
	Rational(const Integer::RawValueType & aNumerator,
			const Integer::RawValueType & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator, aDenominator) )
	{
		simplif();
	}

	// mpz_t / mpz_t
	Rational(const mpz_t & aNumerator, const mpz_t & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer::RawValueType(aNumerator),
			Integer::RawValueType(aDenominator)) )
	{
		simplif();
	}

	// avm_integer_t / avm_integer_t  i.e.  avm_int64_t / avm_int64_t
	Rational(avm_integer_t aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer( aNumerator ).getValue(),
			Integer( aDenominator ).getValue() ) )
	{
		simplif();
	}

	// avm_integer_t / avm_uinteger_t  i.e.  avm_int64_t / avm_uint64_t
	Rational(avm_integer_t aNumerator, avm_uinteger_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer( aNumerator ).getValue(),
			Integer( aDenominator ).getValue() ) )
	{
		simplif();
	}

	// avm_uinteger_t / avm_integer_t  i.e.  avm_uint64_t / avm_int64_t
	Rational(avm_uinteger_t aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer( aNumerator ).getValue(),
			Integer( aDenominator ).getValue() ) )
	{
		simplif();
	}

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

	// std::string / avm_integer_t  i.e.  std::string / avm_int64_t
	Rational(const std::string & aNumerator, avm_integer_t aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer( aNumerator ).getValue(),
			Integer( aDenominator ).getValue() ) )
	{
		simplif();
	}

	// avm_integer_t / std::string  i.e.  avm_int64_t / std::string
	Rational(avm_integer_t aNumerator, const std::string & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer( aNumerator ).getValue(),
			Integer( aDenominator ).getValue() ) )
	{
		simplif();
	}

	// std::string / std::string
	Rational(const std::string & aNumerator, const std::string & aDenominator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(
			Integer::RawValueType(aNumerator),
			Integer::RawValueType(aDenominator) ) )
	{
		simplif();
	}

	// Integer
	Rational(const Integer & aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( aNumerator.getValue() ) )
	{
		simplif();
	}

	// Integer::RawValueType  i.e.  mpz_class
	Rational(const Integer::RawValueType & aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType(aNumerator) )
	{
		simplif();
	}

	// mpz_t
	Rational(const mpz_t & aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer::RawValueType(aNumerator) ) )
	{
		simplif();
	}

	// avm_integer_t i.e. avm_int64_t
	Rational(avm_integer_t aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer( aNumerator ).getValue() ) )
	{
		simplif();
	}

	// avm_uinteger_t i.e. avm_uint64_t
	Rational(avm_uinteger_t aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer( aNumerator ).getValue() ) )
	{
		simplif();
	}

#ifdef _AVM_NEED_INT64_T_OVERLOADS_

	// long
	Rational(long aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer::RawValueType(aNumerator) ) )
	{
		simplif();
	}

	// unsigned long
	Rational(unsigned long aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer::RawValueType(aNumerator) ) )
	{
		simplif();
	}

#endif /* _AVM_NEED_INT64_T_OVERLOADS_ */

	// int32_t
	Rational(int aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer::RawValueType(aNumerator) ) )
	{
		simplif();
	}

	// uint32_t
	Rational(unsigned int aNumerator)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( Integer::RawValueType(aNumerator) ) )
	{
		simplif();
	}

	// std::string
	Rational(const std::string & aRational)
	: Number( CLASS_KIND_T( Rational ) ),
	ThisNumberClass( RawValueType( ) )
	{
		fromString(ThisNumberClass::mValue, aRational);

		simplif();
	}


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


	inline static void fromString(RawValueType & rop, const std::string & aValue)
	{
		std::string::size_type pos = aValue.find('/');
		if( pos != std::string::npos)
		{
			rop = RawValueType( aValue );
		}
		else if( (pos = aValue.find('.')) != std::string::npos )
		{
			Integer aNumer( std::string(aValue).erase(pos, 1) );

			Integer aDenom = Integer::pow(10, aValue.size() - (pos + 1));

			rop = RawValueType( aNumer.getValue(), aDenom.getValue() );
		}
		else
		{
			rop = RawValueType( aValue );
		}
	}


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


	/**
	 * GETTER - SETTER
	 * ThisNumberClass::mValue
	 */
	bool simplif()
	{
		ThisNumberClass::mValue.canonicalize();

		return( true );
	}


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

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


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

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


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


	inline void setValue(avm_integer_t aValue)
	{
		ThisNumberClass::mValue = RawValueType( Integer( aValue ).getValue() );
	}


	/**
	 * BASICS TESTS
	 */
	virtual inline int sign() const
	{
		return( mpq_sgn(ThisNumberClass::mValue.get_mpq_t()) );
	}

	virtual inline bool isZero() const
	{
		return( sign() == 0 );
	}

	virtual inline bool isOne() const
	{
		return( mpq_cmp_si(
				ThisNumberClass::mValue.get_mpq_t(), 1, 1) == 0 );
	}

	virtual inline bool isNegativeOne() const
	{
		return( mpq_cmp_si(
				ThisNumberClass::mValue.get_mpq_t(), -1, 1) == 0 );
	}


	/**
	 * CONVERSION
	 */
#define MPQ_IS_INTEGER( MPQ_NUM,  MPQ_DEN, INF, SUP)   \
	(mpz_cmp_si(MPQ_DEN.get_mpz_t(), 1  ) == 0) &&   \
	(mpz_cmp_si(MPQ_NUM.get_mpz_t(), INF) >= 0) &&   \
	(mpz_cmp_ui(MPQ_NUM.get_mpz_t(), SUP) <= 0)

#define MPQ_IS_POSITIVE_INTEGER(MPQ_NUM,  MPQ_DEN, SUP)          \
	(sign() >= 0)                                            &&  \
	(mpz_cmp_si(MPQ_DEN.get_mpz_t(), 1  ) == 0)              &&  \
	(mpz_cmp_ui(MPQ_NUM.get_mpz_t(), MPQ_NUM.get_ui()) == 0) &&  \
	(mpz_cmp_ui(MPQ_NUM.get_mpz_t(), SUP) <= 0)


	inline virtual bool isInt32() const
	{
		return( MPQ_IS_INTEGER(rawNumerator(), rawDenominator(),
				AVM_NUMERIC_MIN_INT32, AVM_NUMERIC_MAX_INT32) );
	}

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

	inline virtual bool isInt64() const
	{
		return( MPQ_IS_INTEGER(rawNumerator(), rawDenominator(),
				AVM_NUMERIC_MIN_INT64, AVM_NUMERIC_MAX_INT64) );
	}

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


	inline virtual bool isInteger() const
	{
		return( MPQ_IS_INTEGER(rawNumerator(), rawDenominator(),
				AVM_NUMERIC_MIN_INTEGER, AVM_NUMERIC_MAX_INTEGER) );
	}

	inline virtual avm_integer_t toInteger() const
	{
		return( rawNumerator().get_si() );
	}


	inline virtual bool isPosInteger() const
	{
		return( MPQ_IS_POSITIVE_INTEGER(rawNumerator(),
				rawDenominator(), AVM_NUMERIC_MAX_UINTEGER) );
	}


	inline virtual bool isUInteger() const
	{
		return( MPQ_IS_POSITIVE_INTEGER(rawNumerator(),
				rawDenominator(), AVM_NUMERIC_MAX_UINTEGER) );
	}

	inline virtual avm_uinteger_t toUInteger() const
	{
		return( static_cast< avm_uinteger_t >( rawNumerator().get_ui() ) );
	}


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

	virtual avm_integer_t toDenominator() const
	{
		return( rawDenominator().get_si() );
	}

	virtual avm_integer_t toNumerator() const
	{
		return( rawNumerator().get_si() );
	}


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

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


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

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


	/**
	 * math function
	 */
	inline void set_pow(avm_uinteger_t anExponent)
	{
//		RawValueType mpResult;
//
//		mpq_pow_ui( mpResult.get_mpq_t(),
//				ThisNumberClass::mValue.get_mpq_t(), anExponent );
//
//		ThisNumberClass::mValue = mpResult;

		mpz_pow_ui( mpq_numref(ThisNumberClass::mValue.get_mpq_t()),
				mpq_numref(ThisNumberClass::mValue.get_mpq_t()), anExponent );

		mpz_pow_ui( mpq_denref(ThisNumberClass::mValue.get_mpq_t()),
				mpq_denref(ThisNumberClass::mValue.get_mpq_t()), 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_GMP_RATIONALIMPL_H_ */