package com.temp.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;
        }
    }
}