// Copyright (C) 2004, Brian Enigma <enigma at netninja.com>
   // This file is part of MagicCodes.
   //
   // MagicCodes is free software; you can redistribute it and/or modify
   // it under the terms of the GNU General Public License as published by
   // the Free Software Foundation; either version 2 of the License, or
   // (at your option) any later version.
   //
   // MagicCodes is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with Foobar; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  package org.ninjasoft.magiccodes.plugins;
  
  
  /***
   * Encodes data as BASE64
   * @author enigma
   */
  public class Base64Encoder implements Plugin {
      public String getName() {
          return "BASE-64 Encoder";
      }
  
      public String getDescription() {
          return "Encodes data as BASE-64 text";
      }
  
      public boolean usesKey() {
          return false;
      }
  
      public boolean isInformational() {
          return false;
      }
  
      /***
        * Byte value that maps to 'a' in Base64 encoding
        */
      final static int LOWER_CASE_A_VALUE = 26;   
  
      /***
        * Byte value that maps to '0' in Base64 encoding
        */
      final static int ZERO_VALUE = 52;
  
      /***
        * Byte value that maps to '+' in Base64 encoding
        */
      final static int PLUS_VALUE = 62;
  
      /***
        * Byte value that maps to '/' in Base64 encoding
        */
      final static int SLASH_VALUE = 63;
      
      /***
        * Bit mask for one character worth of bits in Base64 encoding.
        * Equivalent to binary value 111111b.
        */
      private final static int SIX_BIT_MASK = 63;
      
      /***
        * Convert a byte between 0 and 63 to its Base64 character equivalent
          * @param b Byte value to be converted
          * @return Base64 char value
          */
      private char mapByteToChar( byte b ) {
          if ( b < LOWER_CASE_A_VALUE ) {
              return (char)( 'A' + b );
          }
          
          if ( b < ZERO_VALUE ) {
              return (char)( 'a' + ( b - LOWER_CASE_A_VALUE ) );
          }
          
          if ( b < PLUS_VALUE ) {
              return (char)( '0' + ( b - ZERO_VALUE ) );
          }
          
          if ( b == PLUS_VALUE ) {
              return '+';
          }
          
          if ( b == SLASH_VALUE ) {
              return '/';
          }
          
          throw new IllegalArgumentException( "Byte " + new Integer( b ) + " is not a valid Base64 value" );
      }
  
      public int[] doAction(int[] in, int[] key) {
          // Base64 encoding yields a String that is 33% longer than the byte array
          int charCount = ( ( in.length * 4 ) / 3 ) + 4;
          
         // New lines will also be needed for every 76 charactesr, so allocate a
         // StringBuffer that is long enough to hold the full result without
         // having to expand later
         StringBuffer result = new StringBuffer( ( charCount * 77 ) / 76 );
         
         int byteArrayLength = in.length;
         int byteArrayIndex = 0;
         int byteTriplet = 0;
         while ( byteArrayIndex < byteArrayLength - 2 ) {
             // Build the 24 bit byte triplet from the input data
             byteTriplet = in[ byteArrayIndex++ ];
             // Each input byte contributes 8 bits to the triplet
             byteTriplet <<= 8;
             byteTriplet |= in[ byteArrayIndex++ ];
             byteTriplet <<= 8;
             byteTriplet |= in[ byteArrayIndex++ ];
 
             // Look at the lowest order six bits and remember them
             byte b4 = (byte)( SIX_BIT_MASK & byteTriplet );
             // Move the byte triplet to get the next 6 bit value
             byteTriplet >>= 6;
             byte b3 = (byte)( SIX_BIT_MASK & byteTriplet );
             byteTriplet >>= 6;
             byte b2 = (byte)( SIX_BIT_MASK & byteTriplet );
             byteTriplet >>= 6;
             byte b1 = (byte)( SIX_BIT_MASK & byteTriplet );
             
             // Add the Base64 encoded character to the result String
             result.append( mapByteToChar( b1 ) );
             result.append( mapByteToChar( b2 ) );
             result.append( mapByteToChar( b3 ) );
             result.append( mapByteToChar( b4 ) );
 
             // There are 57 bytes for every 76 characters, so wrap the line when needed
             if ( byteArrayIndex % 57 == 0 ) {
                 result.append( "\n" );
             }
         }
         
         // Check if we have one byte left over
         if ( byteArrayIndex == byteArrayLength - 1 ) {
             // Convert our one byte to an int
             byteTriplet = in[ byteArrayIndex++ ];
             // Right pad the second 6 bit value with zeros
             byteTriplet <<= 4;
             
             byte b2 = (byte)( SIX_BIT_MASK & byteTriplet );
             byteTriplet >>= 6;
             byte b1 = (byte)( SIX_BIT_MASK & byteTriplet );
             
             result.append( mapByteToChar( b1 ) );
             result.append( mapByteToChar( b2 ) );
             
             // Add "==" to the output to make it a multiple of 4 Base64 characters
             result.append( "==" );
         }
         
         // Check if we have two byte left over
         if ( byteArrayIndex == byteArrayLength - 2 ) {
             // Convert our two bytes to an int
             byteTriplet = in[ byteArrayIndex++ ];
             byteTriplet <<= 8;
             byteTriplet |= in[ byteArrayIndex++ ];
             // Right pad the third 6 bit value with zeros
             byteTriplet <<= 2;
 
             byte b3 = (byte)( SIX_BIT_MASK & byteTriplet );
             byteTriplet >>= 6;
             byte b2 = (byte)( SIX_BIT_MASK & byteTriplet );
             byteTriplet >>= 6;
             byte b1 = (byte)( SIX_BIT_MASK & byteTriplet );
 
             result.append( mapByteToChar( b1 ) );
             result.append( mapByteToChar( b2 ) );
             result.append( mapByteToChar( b3 ) );
 
             // Add "==" to the output to make it a multiple of 4 Base64 characters
             result.append( "=" );           
         }
         int resultArray[] = new int[result.length()];
         for (int i=0; i<resultArray.length; i++)
             resultArray[i] = result.charAt(i);
         return resultArray;
     }
 
 }