// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.codec;

import org.litesoft.core.annotations.*;
import org.litesoft.core.util.*;

/**
 * Convert Integer value to/from a very tight string representation
 */
public class IntegerCodec
{
    public interface Primitive
    {
        public @NotNull String encode( int pValue );

        public int decode( @NotNull String pValue );

        public int decode( @NotNull CharSource pCharSource );
    }

    public static class SignedPrimitive implements Primitive
    {
        public static final SignedPrimitive INSTANCE = new SignedPrimitive();

        @Override
        public @NotNull String encode( 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 );
        }

        @Override
        public int decode( @NotNull String pValue )
        {
            return decode( new CharSource( pValue ) );
        }

        @Override
        public int decode( @NotNull CharSource pCharSource )
        {
            return toInt( new Decoder( pCharSource ).decode( 16, 16 ) );
        }
    }

    public static class Signed extends AbstractCodec<Integer>
    {
        public static final Signed INSTANCE = new Signed();

        @Override
        protected String encodeNonNull( Integer pValue )
        {
            return SignedPrimitive.INSTANCE.encode( pValue );
        }

        @Override
        protected Integer decodeNonNull( CharSource pCharSource )
        {
            return SignedPrimitive.INSTANCE.decode( pCharSource );
        }
    }

    public static class NonNegativePrimitive implements Primitive
    {
        public static final NonNegativePrimitive INSTANCE = new NonNegativePrimitive();

        @Override
        public @NotNull String encode( 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 );
        }

        @Override
        public int decode( @NotNull String pValue )
        {
            return decode( new CharSource( pValue ) );
        }

        @Override
        public int decode( @NotNull CharSource pCharSource )
        {
            return toInt( new Decoder( pCharSource ).decode( 0, 32 ) );
        }
    }

    public static class NonNegative extends AbstractCodec<Integer>
    {
        public static final NonNegative INSTANCE = new NonNegative();

        @Override
        protected String encodeNonNull( Integer pValue )
        {
            return NonNegativePrimitive.INSTANCE.encode( pValue );
        }

        @Override
        protected Integer decodeNonNull( CharSource pCharSource )
        {
            return NonNegativePrimitive.INSTANCE.decode( pCharSource );
        }
    }

    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;
        }
    }
}