package btools.util;


public class BitCoderContext
{
  private byte[] ab;
  private int idxMax;
  private int idx = -1;
  private int bits; // bits left in buffer
  private int b; // buffer word

  public static final int[] vl_values = new int[4096];
  public static final int[] vl_length = new int[4096];

  private static final int[] vc_values = new int[4096];
  private static final int[] vc_length = new int[4096];

  private static final int[] reverse_byte = new int[256];

  private static final int[] bm2bits = new int[256];

  static
  {
    // fill varbits lookup table

    BitCoderContext bc = new BitCoderContext( new byte[4] );
    for( int i=0; i<4096; i++ )
    {
      bc.reset();
      bc.bits = 14;
      bc.b = 0x1000 + i;

      int b0 = bc.getReadingBitPosition();
      vl_values[i] = bc.decodeVarBits2();
      vl_length[i] = bc.getReadingBitPosition() - b0;
    }
    for( int i=0; i<4096; i++ )
    {
      bc.reset();
      int b0 = bc.getWritingBitPosition();
      bc.encodeVarBits2( i );
      vc_values[i] = bc.b;
      vc_length[i] = bc.getWritingBitPosition() - b0;
    }
    for( int i=0; i<1024; i++ )
    {
      bc.reset();
      bc.bits = 14;
      bc.b = 0x1000 + i;

      int b0 = bc.getReadingBitPosition();
      vl_values[i] = bc.decodeVarBits2();
      vl_length[i] = bc.getReadingBitPosition() - b0;
    }
    for( int b=0; b<256; b++ )
    {
      int r = 0;
      for( int i=0; i<8; i++ )
      {
        if ( (b & (1<<i) ) != 0 ) r |= 1 << (7-i);
      }
      reverse_byte[b] = r;
    }
    for( int b=0; b<8; b++ )
    {
      bm2bits[1<<b] = b;
    }
  }


  public BitCoderContext( byte[] ab )
  {
    this.ab = ab;
    idxMax = ab.length-1;
  }

  public final void reset( byte[] ab )
  {
    this.ab = ab;
    idxMax = ab.length-1;
    reset();
  }

  public final void reset()
  {
    idx = -1;
    bits = 0;
    b = 0;
  }

  /**
   * encode a distance with a variable bit length
   * (poor mans huffman tree)
   * {@code 1 -> 0}
   * {@code 01 -> 1} + following 1-bit word ( 1..2 )
   * {@code 001 -> 3} + following 2-bit word ( 3..6 )
   * {@code 0001 -> 7} + following 3-bit word ( 7..14 ) etc.
   *
   * @see #decodeVarBits
   */
  public final void encodeVarBits2( int value )
  {
    int range = 0;
    while (value > range)
    {
      encodeBit( false );
      value -= range + 1;
      range = 2 * range + 1;
    }
    encodeBit( true );
    encodeBounded( range, value );
  }

  public final void encodeVarBits( int value )
  {
    if ( (value & 0xfff) == value )
    {
      flushBuffer();
      b |= vc_values[value] << bits;
      bits += vc_length[value];      
    }
    else
    {
      encodeVarBits2( value ); // slow fallback for large values
    }
  }

  /**
   * @see #encodeVarBits
   */
  public final int decodeVarBits2()
  {
    int range = 0;
    while (!decodeBit())
    {
      range = 2 * range + 1;
    }
    return range + decodeBounded( range );
  }

  public final int decodeVarBits()
  {
    fillBuffer();
    int b12 = b & 0xfff;
    int len = vl_length[b12];
    if ( len <= 12 )
    {
      b >>>= len;
      bits -= len;
      return vl_values[b12]; // full value lookup
    }
    if ( len <= 23 ) // // only length lookup
    {
      int len2 = len >> 1;
      b >>>= (len2+1);
      int mask = 0xffffffff >>> ( 32 - len2 );
      mask += b & mask;
      b >>>= len2;
      bits -= len;
      return mask;
    }
    if ( (b & 0xffffff) != 0 )
    {
      // here we just know len in [25..47]
      // ( fillBuffer guarantees only 24 bits! )
      b >>>= 12;
      int len3 = 1 + (vl_length[b & 0xfff]>>1);
      b >>>= len3;
      int len2 = 11 + len3;
      bits -= len2+1;
      fillBuffer();
      int mask = 0xffffffff >>> ( 32 - len2 );
      mask += b & mask;
      b >>>= len2;
      bits -= len2;
      return mask;
    }
    return decodeVarBits2(); // no chance, use the slow one
  }


  public final void encodeBit( boolean value )
  {
    if (bits > 31)
    {
      ab[++idx] = (byte)(b & 0xff);
      b >>>= 8;
      bits -=8;
    }
    if ( value )
    {
      b |= 1 << bits;
    }
    bits++;
  }

  public final boolean decodeBit()
  {
    if ( bits == 0 )
    {
      bits = 8;
      b = ab[++idx] & 0xff;
    }
    boolean value = ( ( b & 1 ) != 0 );
    b >>>= 1;
    bits--;
    return value;
  }

  /**
   * encode an integer in the range 0..max (inclusive).
   * For max = 2^n-1, this just encodes n bits, but in general
   * this is variable length encoding, with the shorter codes
   * for the central value range
   */
  public final void encodeBounded( int max, int value )
  {
    int im = 1; // integer mask
    while (im <= max)
    {
      if ( ( value & im ) != 0 )
      {
        encodeBit( true );
        max -= im;
      }
      else
      {
        encodeBit( false );
      }
      im <<= 1;
    }
  }

  /**
   * decode an integer in the range 0..max (inclusive).
   * @see #encodeBounded
   */
  public final int decodeBounded( int max )
  {
    int value = 0;
    int im = 1; // integer mask
    while (( value | im ) <= max)
    {
      if ( bits == 0 )
      {
        bits = 8;
        b = ab[++idx] & 0xff;
      }
      if ( ( b & 1 ) != 0 )
        value |= im;
      b >>>= 1;
      bits--;
      im <<= 1;
    }
    return value;
  }

  public final int decodeBits( int count )
  {
    fillBuffer();
    int mask = 0xffffffff >>> ( 32 - count );
    int value = b & mask;
    b >>>= count;
    bits -= count;
    return value;
  }

  public final int decodeBitsReverse( int count )
  {
    fillBuffer();
    int value = 0;
    while( count > 8 )
    {
      value = (value << 8) | reverse_byte[ b & 0xff ];
      b >>=8;
      count -=8;
      bits -=8;
      fillBuffer();
    }
    value = (value << count) | reverse_byte[ b & 0xff ] >> (8-count);
    bits -= count;
    b >>= count;
    return value;
  }

  private void fillBuffer()
  {
    while (bits < 24)
    {
      if ( idx++ < idxMax )
      {
        b |= (ab[idx] & 0xff) << bits;
      }
      bits += 8;
    }
  }

  private void flushBuffer()
  {
    while (bits > 7)
    {
      ab[++idx] = (byte)(b & 0xff);
      b >>>= 8;
      bits -=8;
    }
  }

  /**
   * flushes and closes the (write-mode) context 
   * 
   * @return the encoded length in bytes
   */
  public final int closeAndGetEncodedLength()
  {
    flushBuffer();
    if ( bits > 0 )
    {
      ab[++idx] = (byte)(b & 0xff);
    }
    return idx + 1;
  }

  /**
   * @return the encoded length in bits
   */
  public final int getWritingBitPosition()
  {
    return (idx << 3) + 8 + bits;
  }

  public final int getReadingBitPosition()
  {
    return (idx << 3) + 8 - bits;
  }

  public final void setReadingBitPosition(int pos)
  {
    idx = pos >>> 3;
    bits = (idx << 3) + 8 - pos;
    b = ab[idx] & 0xff;
    b >>>= (8-bits);
  }

  public static void main( String[] args )
  {
    byte[] ab = new byte[581969];
    BitCoderContext ctx = new BitCoderContext( ab );
    for ( int i = 0; i < 31; i++ )
    {
      ctx.encodeVarBits( (1<<i)+3 );
    }
    for ( int i = 0; i < 100000; i+=13 )
    {
      ctx.encodeVarBits( i );
    }
    ctx.closeAndGetEncodedLength();
    ctx = new BitCoderContext( ab );

    for ( int i = 0; i < 31; i++ )
    {
      int value = ctx.decodeVarBits();
      int v0 = (1<<i)+3;
      if ( !(v0 == value ) )
        throw new RuntimeException( "value mismatch value=" + value + "v0=" + v0 );
    }
    for ( int i = 0; i < 100000; i+=13 )
    {
      int value = ctx.decodeVarBits();
      if ( !(value == i ) )
        throw new RuntimeException( "value mismatch i=" + i + "v=" + value );
    }
  }
}