#include "Complex.hh"

#include "Integer.hh"
#include "Long.hh"
#include "LargeInt.hh"
#include "Imaginary.hh"


Complex::Complex( )
{
  rValue = new Integer( );
  iValue = new Integer( );
}

Complex::Complex( SimpleNumber* rVal, SimpleNumber* iVal )
{
  rValue = rVal;
  iValue = iVal;
}

Complex::~Complex( )
{
  delete rVal;
  delete iVal;
}


NumberRep* Complex::operator+ ( const NumberRep& n ) const throws NumberException
{
  return n.addComplex( *this );
}

NumberRep* Complex::operator- ( const NumberRep& n ) const throws NumberException
{
  NumberRep *neg = -n;
  NumberRep *resp = neg->addComplex( *this );
  delete neg;
  return resp; 
}

NumberRep* Complex::operator- ( ) const throws NumberException
{
  NumberRep* rNeg = - *rValue;
  NumberRep* iNeg = - *iValue;

  return new Complex( (SimpleNumber*) rNeg, (SimpleNumber*) iNeg );
}

const SimpleNumber* Integer::getRValue( ) const
{
  return rValue;
}

const SimpleNumber* Integer::getIValue( ) const
{
  return rValue;
}

// protected:
NumberRep* Complex::addInt( const Integer& n ) const
{
  SimpleNumber* nR = rValue->addInt( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::addLong( const Long& n ) const
{
  SimpleNumber* nR = rValue->addLong( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::addLargeInt( const LargeInt& n ) const
{
  SimpleNumber* nR = rValue->addLargeInt( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::addComplex( const Complex& n ) const
{
  SimpleNumber* nR = *rValue + *n.rValue;
  SimpleNumber* nI = *iValue + *n.iValue;
  if( *nR == 0 )
    {
      delete nR;
      if( *nI == 0 )
	{
	  return nI; // Se supone nI Integer.
	}
      else
	{
	  return new Imaginary( nI );
	}
    }
  else // *nR != 0
    {
      if( *nI == 0 )
	{
	  delete nI;
	  return nR;
	}
      else
	{
	  return new Complex( nR, nI );
	}
    }
}

NumberRep* Complex::addImaginary( const Imaginary& n ) const
{
  SimpleNumber* nR = rValue->clone( );
  SimpleNumber* nI = *iValue + n.getIValue();
  if( *nI == 0 )
    {
      delete nI;
      return nR;
    }
  else
    return new Complex( nR, nI );
}

NumberRep* Complex::subsInt( const Integer& n ) const
{
  SimpleNumber* nR = rValue->subsInt( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::subsLong( const Long& n ) const
{
  SimpleNumber* nR = rValue->subsLong( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::subsLargeInt( const LargeInt& n ) const
{
  SimpleNumber* nR = rValue->subsLargeInt( n.getValue( ) );
  SimpleNumber* nI = iValue->clone( );
  if( *nR == 0 )
    {
      delete nR;
      return new Imaginary( nI );
    }
  else
    {
      return new Complex( nR, nI );
    }
}

NumberRep* Complex::subsComplex( const Complex& n ) const
{
  SimpleNumber* nR = *rValue - *n.rValue;
  SimpleNumber* nI = *iValue - *n.iValue;
  if( *nR == 0 )
    {
      delete nR;
      if( *nI == 0 )
	{
	  return nI; // Se supone nI Integer.
	}
      else
	{
	  return new Imaginary( nI );
	}
    }
  else // *nR != 0
    {
      if( *nI == 0 )
	{
	  delete nI;
	  return nR;
	}
      else
	{
	  return new Complex( nR, nI );
	}
    }
}

NumberRep* Complex::subsImaginary( const Imaginary& n ) const
{
  SimpleNumber* nR = rValue->clone( );
  SimpleNumber* nI = *iValue - n.getIValue();
  if( *nI == 0 )
    {
      delete nI;
      return nR;
    }
  else
    return new Complex( nR, nI );
}