package com.temp.client.foundation.pavment;

import com.temp.shared.utils.*;

/**
 * Implementation that supports an encoding model of encoded Deltas from one
 * character to the next.
 *
 * @author georgs
 */
public abstract class AbstractPlaceTokenCodecCharacterDelta implements PlaceTokenCodec {

    /**
     * Encode the String (nulls are returned as "")
     *
     * @return "" if null passed in, otherwise the Encoded String.
     */
    public final String encode( String unencoded ) {
        if ( (unencoded == null) || (unencoded.length() == 0) ) {
            return "";
        }
        char initialCharacter = SixBitCodec.encode( (int) (63 & System.currentTimeMillis()) );
        return new Helper( new CharSource( unencoded ), initialCharacter, determinePerCharacterAdjustment( initialCharacter ) ).encode();
    }

    abstract protected int determinePerCharacterAdjustment( char initialCharacter );

    /**
     * Decode the previously "encoded" data, null or bad encoding will return
     * null.
     *
     * @return null indicates that the data was either null or contained
     * unacceptable characters for decoding.
     */
    public final String decode( String encoded ) {
        if ( encoded == null ) {
            return null;
        }
        if ( encoded.length() == 0 ) {
            return "";
        }
        CharSource charSource = new CharSource( encoded );
        char initialCharacter = charSource.getRequired();
        return new Helper( charSource, initialCharacter, determinePerCharacterAdjustment( initialCharacter ) ).decode();
    }

    private static class Helper {
        protected StringBuilder mSB = new StringBuilder();

        private final CharSource charSource;
        private final int perCharAdjustment;
        private int lastClearTextChar;
        private int deltaRunning = 0;
        private int charDeltasRemaining = 0;

        public Helper( CharSource charSource, char firstChar, int perCharAdjustment ) {
            this.charSource = charSource;
            this.perCharAdjustment = perCharAdjustment;
            this.lastClearTextChar = firstChar;
        }

        public String encode() {
            mSB.append( (char) lastClearTextChar );
            while ( charSource.anyRemaining() ) {
                encode( charSource.get() );
            }
            return mSB.toString();
        }

        public String decode() {
            while ( charSource.anyRemaining() ) {
                if ( !decode( charSource.get() ) ) {
                    return null;
                }
            }
            // Check for Ran off the End!
            return (charDeltasRemaining == 0) ? mSB.toString() : null;
        }

        private void encode( int chr ) {
            int delta = (chr - lastClearTextChar) + perCharAdjustment;
            if ( delta < 0 ) {
                LLencode( -delta, 'a' );
            } else {
                LLencode( delta, 'A' );
            }
            lastClearTextChar = chr;
        }

        private void LLencode( int delta, int base ) {
            if ( div4 <= delta ) {
                mSB.append( '4' );
                delta = addFactor( delta, base, div4 );
                delta = addFactor( delta, base, div3 );
                delta = addFactor( delta, base, div2 );
            } else if ( div3 <= delta ) {
                mSB.append( '3' );
                delta = addFactor( delta, base, div3 );
                delta = addFactor( delta, base, div2 );
            } else if ( div2 <= delta ) {
                mSB.append( '2' );
                delta = addFactor( delta, base, div2 );
            }
            LLencodeChar( delta, base );
        }

        private int addFactor( int delta, int base, int divisor ) {
            int zDelta = 0;
            while ( delta >= divisor ) {
                zDelta++;
                delta -= divisor;
            }
            LLencodeChar( zDelta, base );
            return delta;
        }

        private void LLencodeChar( int delta, int base ) {
            mSB.append( (delta == 0) ? '0' : (char) (base + (delta - 1)) );
        }

        // 0 = No Change / same letter
        // A-Z = Delta: +1 to +26
        // a-z = Delta: -1 to -26
        // 2-4 = Delta: that many letters/'0' follow, witch are in base 27
        private static final int div4 = 19683; // 27 * 27 * 27;
        private static final int div3 = 729; // 27 * 27;
        private static final int div2 = 27;

        public boolean decode( int chr ) {
            if ( charDeltasRemaining > 0 ) {
                Integer delta = LLdecode( chr );
                if ( delta == null ) {
                    return false;
                }
                deltaRunning = (deltaRunning * 27) + delta;
                if ( --charDeltasRemaining == 0 ) {
                    if ( !LLdecodeChar( deltaRunning ) ) {
                        return false;
                    }
                    deltaRunning = 0;
                }
                return true;
            }
            if ( ('2' <= chr) && (chr <= '4') ) {
                charDeltasRemaining = chr - '0';
                return true;
            }
            return LLdecodeChar( LLdecode( chr ) );
        }

        private boolean LLdecodeChar( Integer delta ) {
            if ( delta == null ) {
                return false;
            }
            lastClearTextChar += delta - perCharAdjustment;
            mSB.append( (char) lastClearTextChar );
            return true;
        }

        private Integer LLdecode( int chr ) {
            if ( chr == '0' ) {
                return 0;
            }
            if ( ('a' <= chr) && (chr <= 'z') ) {
                return -(1 + (chr - 'a'));
            }
            if ( ('A' <= chr) && (chr <= 'Z') ) {
                return (1 + (chr - 'A'));
            }
            return null; // Unacceptable Char
        }
    }
}