package org.litesoft.codec;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.charstreams.*;

/**
 * Implementation that supports an encoding model of encoded Deltas from one
 * character to the next with a Time based "Random" starting character.
 */
public class StringCodecVersion0 implements StringCodec {
    private final MillisecTimeSource mMillisecTimeSource;

    public StringCodecVersion0( MillisecTimeSource pMillisecTimeSource ) {
        mMillisecTimeSource = MillisecTimeSource.deNull( pMillisecTimeSource );
    }

    public StringCodecVersion0() {
        this( null );
    }

    /**
     * Encode the String.
     *
     * @return null if null passed in, "" if "" passed in, otherwise the Encoded String.
     */
    public final String encode( String pUnencoded ) {
        if ( pUnencoded == null ) {
            return null;
        }
        if ( pUnencoded.length() == 0 ) {
            return "";
        }
        return createHelper( new CharSourceFromSequence( pUnencoded ), getInitialCharacter() ).encode();
    }

    /**
     * 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 pEncoded ) {
        if ( pEncoded == null ) {
            return null;
        }
        if ( pEncoded.length() == 0 ) {
            return "";
        }
        CharSource zCS = new CharSourceFromSequence( pEncoded );
        return createHelper( zCS, zCS.getRequired() ).decode();
    }

    protected char getInitialCharacter() {
        return SixBitCodec.encode( (int) (63 & mMillisecTimeSource.now()) );
    }

    protected int determinePerCharacterAdjustment( char pInitialCharacter ) {
        return (pInitialCharacter & 7) + 1;
    }

    protected Helper createHelper( CharSource pCharSource, char pInitialCharacter ) {
        return new Helper( pCharSource, pInitialCharacter, determinePerCharacterAdjustment( pInitialCharacter ) );
    }

    protected static class Helper {
        protected final StringBuilder mSB = new StringBuilder();
        protected final CharSource mCharSource;
        protected final int mPerCharAdjustment;
        protected int mLastClearTextChar;
        protected int mDeltaRunning = 0;
        protected int mCharDeltasRemaining = 0;

        public Helper( CharSource pCharSource, char pFirstChar, int pPerCharAdjustment ) {
            mCharSource = pCharSource;
            mPerCharAdjustment = pPerCharAdjustment;
            mLastClearTextChar = pFirstChar;
        }

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

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

        private void encode( int chr ) {
            int zDelta = (chr - mLastClearTextChar) + mPerCharAdjustment;
            if ( zDelta < 0 ) {
                LLencode( -zDelta, 'a' );
            } else {
                LLencode( zDelta, 'A' );
            }
            mLastClearTextChar = chr;
        }

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

        private int addFactor( int pDelta, int pBase, int pDivisor ) {
            int zDelta = 0;
            while ( pDelta >= pDivisor ) {
                zDelta++;
                pDelta -= pDivisor;
            }
            LLencodeChar( zDelta, pBase );
            return pDelta;
        }

        private void LLencodeChar( int pDelta, int pBase ) {
            mSB.append( (pDelta == 0) ? '0' : (char) (pBase + (pDelta - 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 pChar ) {
            if ( mCharDeltasRemaining > 0 ) {
                Integer delta = LLdecode( pChar );
                if ( delta == null ) {
                    return false;
                }
                mDeltaRunning = (mDeltaRunning * 27) + delta;
                if ( --mCharDeltasRemaining == 0 ) {
                    if ( !LLdecodeChar( mDeltaRunning ) ) {
                        return false;
                    }
                    mDeltaRunning = 0;
                }
                return true;
            }
            if ( ('2' <= pChar) && (pChar <= '4') ) {
                mCharDeltasRemaining = pChar - '0';
                return true;
            }
            return LLdecodeChar( LLdecode( pChar ) );
        }

        private boolean LLdecodeChar( Integer pDelta ) {
            if ( pDelta == null ) {
                return false;
            }
            mLastClearTextChar += pDelta - mPerCharAdjustment;
            mSB.append( (char) mLastClearTextChar );
            return true;
        }

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