package com.temp.common.shared.utils;

/**
 * Convert Integer value to/from a very tight string representation
 */
public class IntegerCodec {
    public static String encodePositive( int pValue ) {
        if ( pValue < 0 ) {
            throw new IllegalArgumentException( "Negative values not supported: " + pValue );
        }
        if ( pValue < 32 ) {
            return Character.toString( SixBitCodec.encode( pValue ) );
        }
        return new Encoder( pValue ).encode( 0, 32 );
    }

    public static int decodePositive( String pValue ) {
        return decodePositive( new CharSource( pValue ) );
    }

    public static int decodePositive( CharSource pValue ) {
        return toInt( new Decoder( pValue ).decode( 0, 32 ) );
    }

    public static String encodeSigned( int pValue ) {
        if ( 0 <= pValue ) {
            if ( pValue < 16 ) {
                return Character.toString( SixBitCodec.encode( pValue ) );
            }
            return new Encoder( pValue ).encode( 0, 16 );
        }

        return new Encoder( Math.abs( (long) pValue ) ).encode( 16, 16 );
    }

    public static int decodeSigned( String pValue ) {
        return decodeSigned( new CharSource( pValue ) );
    }

    public static int decodeSigned( CharSource pValue ) {
        return toInt( new Decoder( pValue ).decode( 16, 16 ) );
    }

    private static int toInt( long pValue ) {
        if ( (Integer.MIN_VALUE <= pValue) && (pValue <= Integer.MAX_VALUE) ) {
            return (int) pValue;
        }
        throw new IllegalArgumentException( "Resulting value (" + pValue + ") is outside the acceptable Integer Range" );
    }

    private static class Encoder {
        private long mValue;

        Encoder( long pValue ) {
            mValue = pValue;
        }

        public String encode( int pNegativeBit, int pFirstCharLimit ) {
            StringBuilder sb = new StringBuilder();
            int bits = extractBits( pFirstCharLimit - 1, pFirstCharLimit );
            sb.append( SixBitCodec.encode( bits | pNegativeBit ) );
            while ( (bits & 32) != 0 ) {
                bits = extractBits( 31, 32 );
                sb.append( SixBitCodec.encode( bits ) );
            }
            return sb.toString();
        }

        private int extractBits( int pBits, int pDivisor ) {
            int rv = (int) (mValue & pBits);
            if ( (mValue /= pDivisor) > 0 ) {
                rv |= 32;
            }
            return rv;
        }
    }

    private static class Decoder {
        private CharSource mValue;

        Decoder( CharSource pValue ) {
            mValue = pValue;
        }

        public long decode( int pNegativeBit, long pMultiplier ) {
            int bits = SixBitCodec.decode( mValue.getRequired() );
            boolean negative = ((bits & pNegativeBit) != 0);
            if ( negative ) {
                bits -= pNegativeBit;
            }
            long result = (bits & 31);
            while ( (bits & 32) != 0 ) {
                bits = SixBitCodec.decode( mValue.getRequired() );
                result += (bits & 31) * pMultiplier;
                pMultiplier *= 32;
            }
            return negative ? -result : result;
        }
    }
}