alphabet

public class AlphabetHelper {

    private static final char[] PRIVATE_ALPHABET;
    private static final char[] PUBLIC_ALPHABET;

    // initialize alphabets
    static {
        final StringBuilder privateBuilder = new StringBuilder();
        final StringBuilder publicBuilder = new StringBuilder();

        // digits
        privateBuilder.append("0123456789");
        publicBuilder.append("0123456789");

        // upper case
        privateBuilder.append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
        publicBuilder.append("ABCDEFGHIJKLMNOPQRSTUVWXYZ");

        // underscore
        privateBuilder.append('_');

        // lower case
        publicBuilder.append("abcdefghijklmnopqrstuvwxyz");

        int offset;

        final List<Character> privateList = Arrays.asList(
        // convert Character[] to List<Character>
                ArrayUtils.toObject(
                // convert char[] to Character[]
                        privateBuilder.toString().toCharArray()));
        Collections.shuffle(privateList); // shuffle the list

        PRIVATE_ALPHABET = new char[privateList.size()];
        offset = 0;
        for (final Character character : privateList) {
            PRIVATE_ALPHABET[offset++] = character.charValue();
        }

        final List<Character> publicList = Arrays.asList(
        // convert Character[] to List<Character>
                ArrayUtils.toObject(
                // convert char[] to Character[]
                        publicBuilder.toString().toCharArray()));
        Collections.shuffle(publicList); // shuffle the list

        PUBLIC_ALPHABET = new char[publicList.size()];
        offset = 0;
        for (final Character character : publicList) {
            PUBLIC_ALPHABET[offset++] = character.charValue();
        }

    }

    private static final Logger LOG = LoggerFactory
            .getLogger(AlphabetHelper.class);

    public static String decode(final String encodedText) {
        if (!verify(encodedText, PUBLIC_ALPHABET)) {
            return null;
        }
        final int length = ArrayUtils.indexOf(PUBLIC_ALPHABET, encodedText
                .charAt(0));
        final BigInteger mapped = getTextAsNumber(encodedText.substring(1),
                PUBLIC_ALPHABET);
        return StringUtils.leftPad(getNumberAsText(mapped, PRIVATE_ALPHABET),
                length, PRIVATE_ALPHABET[0]);
    }

    public static String encode(final String clearText) {
        if (!verify(clearText, PRIVATE_ALPHABET)) {
            return null;
        }
        final BigInteger mapped = getTextAsNumber(clearText, PRIVATE_ALPHABET);
        return PUBLIC_ALPHABET[clearText.length()]
                + getNumberAsText(mapped, PUBLIC_ALPHABET);
    }

    private static String getNumberAsText(final BigInteger number,
            final char[] alphabet) {
        final StringBuilder builder = new StringBuilder();
        final BigInteger radix = BigInteger.valueOf(alphabet.length);
        BigInteger snapShot = number;
        while (snapShot.compareTo(BigInteger.ZERO) > 0) {
            final BigInteger[] tuple = snapShot.divideAndRemainder(radix);
            builder.append(alphabet[(int) tuple[1].longValue()]);
            snapShot = tuple[0];
        }
        final String value = builder.reverse().toString();
        LOG.info("Decoded string {} from number {}", value, number);
        return value;
    }

    private static BigInteger getTextAsNumber(final String charString,
            final char[] alphabet) {

        BigInteger value = BigInteger.ZERO;
        final char[] chars = charString.toCharArray();
        final int radix = alphabet.length;
        final int wordLength = chars.length;
        for (int i = 0; i < wordLength; i++) {
            final char c = chars[wordLength - (i + 1)];
            value = value.add(//
                    BigInteger.valueOf(radix).pow(i)
                            .multiply(
                                    BigInteger.valueOf(ArrayUtils.indexOf(
                                            alphabet, c))));
        }
        LOG.info("Decoded value {} from string {}", value, charString);
        return value;
    }

    private static boolean verify(final String candidate,
            final char[] publicAlphabet) {
        boolean result;
        if (candidate == null) {
            result = false;
        } else {
            result = true;
            for (final char ch : candidate.toCharArray()) {
                if (!ArrayUtils.contains(publicAlphabet, ch)) {
                    result = false;
                    break;
                }
            }
        }
        return result;
    }

}



public class AlphabetHelperTest {

    private Random random;
    private char[] alphabet;

    private static final Logger LOG = LoggerFactory
            .getLogger(AlphabetHelperTest.class);

    @Before
    public void setup() {
        this.random = new Random();
        this.alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_".toCharArray();
    }

    @Test
    public void testEncodeDecode() {

        for (int i = 0; i < 20; i++) {
            final String clearText =  this.getRandomString();
            // "FRTV0VN3IE7LA1U"; <-- This string always fails!!!
            final String encodedString = AlphabetHelper.encode(clearText);
            final String decodedString = AlphabetHelper.decode(encodedString);
            LOG.info("Original: {}, encoded: {}, decoded: {}", new String[] {
                    clearText, encodedString, decodedString });
            assertEquals(decodedString, clearText);
        }

    }

    private String getRandomString() {
        final int stringSize = this.random.nextInt(10) + 6;
        final StringBuilder sb = new StringBuilder();
        for (int ct = 0; ct < stringSize; ct++) {
            sb.append(this.alphabet[this.random.nextInt(this.alphabet.length)]);
        }
        return sb.toString();
    }

}