/*
    * To change this template, choose Tools | Templates
    * and open the template in the editor.
    */
   package net.sf.zel.nr;
   
   import java.math.BigDecimal;
   import java.math.BigInteger;
   import javax.annotation.concurrent.Immutable;
  import net.sf.zel.nr.ExtendedNumber.Type;
  
  /**
   *
   * @author zoly
   */
  @Immutable
  public final class OperableGNUBigInteger extends OperableGNUNumber
  {
      private static final long serialVersionUID = -8692670876118317710L;
      /**
       * The pointer is a 64 bit pointer to support 64 bit jvms
       */
      private transient long pointer;
  
      public static final OperableGNUBigInteger ZERO = new OperableGNUBigInteger("0");
      public static final OperableGNUBigInteger ONE = new OperableGNUBigInteger("1");
  
      public OperableGNUBigInteger(final String number)
      {
          pointer = allocateGMP(number);
      }
  
      public OperableGNUBigInteger(final byte[] bytes)
      {
          pointer = allocateGMP(toString(bytes, 10));
      }
  
      private OperableGNUBigInteger(final long pointer)
      {
          this.pointer = pointer;
      }
  
      @Override
      protected void finalize() throws Throwable
      {
          try
          {
              super.finalize();
          }
          finally
          {
          freeGMP(pointer);
          }
      }
  
      private static native long allocateGMP(String number);
  
      private static native void freeGMP(long pointer);
  
      @Override
      public OperableNumber zero()
      {
          return ZERO;
      }
  
      private static native byte[] toByteArray(String number)
              throws IllegalArgumentException;
  
      private static native String toString(byte number[], int base);
  
      private static native String toString(long pointer, int base);
  
      /**
       * @experimental     
       */
      private static native byte[] add(byte a[], byte b[]);
  
      private static native long add(long a, long b);
  
      private static native long substract(long a, long b);
  
      private static native long multiply(long a, long b);
  
      private static native long divide(long a, long b);
  
      private static native long mod(long a, long b);
  
      @Override
      public OperableNumber add(OperableNumber addend)
      {
          return new OperableGNUBigInteger(add(this.pointer, addend.gnuBigIntegerValue().pointer));
      }
  
      @Override
      public OperableNumber subtract(OperableNumber subtrahend)
      {
          return new OperableGNUBigInteger(substract(this.pointer, subtrahend.gnuBigIntegerValue().pointer));
      }
  
     @Override
     public OperableNumber multiply(OperableNumber multiplier)
     {
         return new OperableGNUBigInteger(multiply(this.pointer, multiplier.gnuBigIntegerValue().pointer));
     }
 
     @Override
     public OperableNumber divide(OperableNumber divisor)
     {
         return new OperableGNUBigInteger(divide(this.pointer, divisor.gnuBigIntegerValue().pointer));
     }
 
     @Override
     public OperableNumber mod(OperableNumber divisor)
     {
         return new OperableGNUBigInteger(mod(this.pointer, divisor.gnuBigIntegerValue().pointer));
     }
 
     @Override
     public Type getType()
     {
         return OperableNumber.Type.INTEGER;
     }
 
     @Override
     public BigDecimal bigDecimalValue()
     {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public BigInteger bigIntegerValue()
     {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
     @Override
     public OperableGNUBigInteger gnuBigIntegerValue()
     {
         return this;
     }
 
     @Override
     public int intValue()
     {
         return Integer.parseInt(toString());
     }
 
     @Override
     public long longValue()
     {
         return Long.parseLong(toString());
     }
 
     @Override
     public float floatValue()
     {
         return Float.parseFloat(toString());
     }
 
     @Override
     public double doubleValue()
     {
         return Double.parseDouble(toString());
     }
 
     @Override
     public String toString()
     {
         return toString(this.pointer, 10);
     }
 
     /**
      * TODO: current simplistic implementation. need native implementation
      * and cast the parameter to OperableGNUBIGInteger
      * @param o
      * @return
      */
 
     @Override
     public int compareTo(final Object o)
     {
         double other = ((OperableNumber) o).doubleValue();
         double thisVal = doubleValue();
         if ( thisVal > other)
         {
             return 1;
         } else if (thisVal == other)
         {
             return 0;
         } else
         {
             return -1;
         }
     }
 
     @Override
     public OperableGNUBigFloat gnuBigFloatValue()
     {
         return new OperableGNUBigFloat(toString());
     }
 
     @Override
     public int getPrecision()
     {
         return 0;
     }
 
     @Override
     public OperableNumber create(String val)
     {
         if ("0".equals(val))
             return ZERO;
         else
             return new OperableGNUBigInteger(val);
     }
 
     @Override
     public ExtendedNumber one()
     {
         return ONE;
     }
 
     @Override
     public OperableNumber convert(ExtendedNumber val)
     {
        return new OperableGNUBigInteger(val.toString());
     }
 
 }