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

import org.litesoft.commonfoundation.base.*;

public class BrainDeadSymmetricEncryptor extends AbstractSymmetricEncryptor
{
    public static final SymmetricEncryptor INSTANCE = new BrainDeadSymmetricEncryptor();

    public String getIdentifierAndVersion()
    {
        return "BDSE-1";
    }

    protected Helper createHelper( String pText )
    {
        return new MyHelper( pText );
    }

    private static class MyHelper extends Helper
    {
        public MyHelper( String pText )
        {
            super( pText );
        }

        public String done()
        {
            return toString();
        }

        public void encode( int pChar )
        {
            if ( (pChar == ' ') || (('a' <= pChar) && (pChar <= 'z')) )
            {
                mSB.append( (char) encodeAlpha( pChar, 0 ) );
                return;
            }
            if ( ('A' <= pChar) && (pChar <= 'Z') )
            {
                mSB.append( (char) encodeAlpha( pChar + ASCII_CASE_DELTA, 46 ) );
                return;
            }
            int at = OTHER_SRC.indexOf( pChar );
            if ( at != -1 )
            {
                mSB.append( ALPHA_SRC.charAt( at ) );
                mLastIndexIntoAS = at;
                return;
            }
            mSB.append( (char) 96 );
            char[] zDigits = Hex.to4Chars( (char) pChar );
            for ( char zDigit : zDigits )
            {
                encode( zDigit );
            }
        }

        private int encodeAlpha( int pChar, int pReturnOffset )
        {
            int at = ALPHA_SRC.indexOf( pChar, mLastIndexIntoAS + 1 );
            if ( at == -1 )
            {
                pReturnOffset += ALPHA_SRC.length() - mLastIndexIntoAS;
                at = ALPHA_SRC.indexOf( pChar, mLastIndexIntoAS = 0 );
            }
            int rv = at - mLastIndexIntoAS;
            mLastIndexIntoAS = at;
            return rv + pReturnOffset;
        }

        private static final int ASCII_CASE_DELTA = 'a' - 'A';

        private int mLastIndexIntoAS = -1;
        // ......................................1234567-101234567-201234567-301234567-40123456
        private static final String ALPHA_SRC = "quickly the brown fox jumped over a lazy goose";
        private static final String OTHER_SRC = "9876543 210 /:,.; ? - + () @  $   %   '  !  \"";

        // last from ALPHA_SRC initialized to 0.
        // 1-46 is the amount to add to the index of the last from ALPHA_SRC into ALPHA_SRC
        // 47-92 is the amount to add to the index of the last from ALPHA_SRC into ALPHA_SRC - Capitalized
        // 96 indicates that the next 4 characters are encrypted hex for the character.
        // 'a' - 'z' (97-122) are positional from the index into ALPHA_SRC in OTHER_SRC

        public void decode( int pChar )
        {
            mSB.append( LLdecode( pChar ) );
        }

        private char LLdecode( int pChar )
        {
            if ( ('a' <= pChar) && (pChar <= 'z') )
            {
                int at = mLastIndexIntoAS = ALPHA_SRC.indexOf( pChar );
                if ( at != -1 )
                {
                    char rv = OTHER_SRC.charAt( at );
                    if ( rv != ' ' )
                    {
                        return rv;
                    }
                }
            }
            else if ( pChar == 96 )
            {
                char[] zDigits = new char[4];
                for ( int i = 0; i < zDigits.length; i++ )
                {
                    int zChar = read();
                    if ( zChar == -1 )
                    {
                        throw new DecryptFailureException( (char) pChar, this.getClass() );
                    }
                    zDigits[i] = LLdecode( zChar );
                }
                try
                {
                    return Hex.from4Chars( zDigits );
                }
                catch ( IllegalArgumentException e )
                {
                    // fall thru
                }
            }
            else
            {
                boolean zCaseChange = false;
                if ( (47 <= pChar) && (pChar <= 92) )
                {
                    zCaseChange = true;
                    pChar -= 46;
                }
                if ( (1 <= pChar) && (pChar <= 46) )
                {
                    if ( (mLastIndexIntoAS += pChar) >= ALPHA_SRC.length() )
                    {
                        mLastIndexIntoAS -= ALPHA_SRC.length();
                    }
                    char rv = ALPHA_SRC.charAt( mLastIndexIntoAS );
                    return !zCaseChange ? rv : (char) (rv - ASCII_CASE_DELTA);
                }
            }
            throw new DecryptFailureException( (char) pChar, this.getClass() );
        }
    }
    //
    //public static void main( String argv[] )
    //        throws Exception
    //{
    //    BrainDeadSymmetricEncryptor zBrainDeadSymmetricEncryptor = new BrainDeadSymmetricEncryptor();
    //    System.out.println( HexStringCodec.toHex(
    //            (zBrainDeadSymmetricEncryptor.getIdentifierAndVersion() + ":" + zBrainDeadSymmetricEncryptor.encrypt( argv[0] )).getBytes() ) );
    //}
}