// 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;
  
  
  /***
   * Decodes BASE-64 data
   * @author enigma
   */
  public class Base64Decoder implements Plugin {
  
      public String getName() {
          return "BASE-64 Decoder";
      }
  
      public String getDescription() {
          return "Decodes BASE-64 text to original data";
      }
  
      public boolean usesKey() {
          return false;
      }
  
      public boolean isInformational() {
          return false;
      }
  
      /***
        * Convert a Base64 character to its 6 bit value as defined by the mapping.
        * @param c Base64 character to decode
        * @return int representation of 6 bit value
        */
      private int mapCharToInt( char c ) {
          if ( c >= 'A' && c <= 'Z' ) {
              return c - 'A';
          }
          
          if ( c >= 'a' && c <= 'z' ) {
              return ( c - 'a' ) + Base64Encoder.LOWER_CASE_A_VALUE;
          }
          
          if ( c >= '0' && c <= '9' ) {
              return ( c - '0' ) + Base64Encoder.ZERO_VALUE;
          }
          
          if ( c == '+' ) {
              return Base64Encoder.PLUS_VALUE;
          }
          
          if ( c == '/' ) {
              return Base64Encoder.SLASH_VALUE;
          }
          
          throw new IllegalArgumentException( c + " is not a valid Base64 character." );
      }
      
      /***
        * Simple class to wrap around the String input to ignore all of the
          * non-Base64 characters in the input.  Note that although '=' is
          * a valid character, it does not contribute to the total number
          * of output bytes, and is therefore ignored
          */
      private class StringWrapper {
  
          /***
            * The input String to be decoded
            */
          private int[] mString;
          
          /***
            * Current position in the String
              */
          private int mIndex = 0;
  
          /***
            * Total number of Base64 characters in the input
              */
          private int mUsefulLength;
          
          /***
            * @param c Character to be examined
              * @return Whether or not the character is a Base64 character
              */
          private boolean isUsefulChar( int i ) {
              char c = (char) i;
             return ( c >= 'A' && c <= 'Z' ) ||
                    ( c >= 'a' && c <= 'z' ) ||
                        ( c >= '0' && c <= '9' ) ||
                        ( c == '+' ) ||
                    ( c == '/' );
         }
 
         /***
           * Create the wrapper and determine the number of Base64 characters in
             * the input
           * @param s Input String to be decoded
             */
         public StringWrapper( int[] in ) {
             mString = in;
             mUsefulLength = 0;
             for( int i = 0; i < in.length; i++ ) {
                 if( isUsefulChar( mString[i] ) ){
                     mUsefulLength++;
                 }
             }
         }
         
         /***
           * @return Total number of Base64 characters in the input.  Does
             * not include '='
             */
         public int getUsefulLength() {
             return mUsefulLength;
         }
         
         /***
           * Traverse the String until hitting the next Base64 character.
           * Assumes that there is still another valid Base64 character
             * left in the String.
             */
         public char getNextUsefulChar() {
             char result = '_';  // Start with a non-Base64 character
             while ( !isUsefulChar( result ) ) {
                 result = (char) mString[mIndex++];
             }
             
             return result;
         }
     }
 
     /***
       * Bit mask for one byte worth of bits in Base64 encoding.
       * Equivalent to binary value 11111111b.
       */
     private static final int EIGHT_BIT_MASK = 0xFF;
 
     public int[] doAction(int[] in, int[] key) {
         // Create a wrapper around the input to screen out non-Base64 characters
         StringWrapper wrapper = new StringWrapper( in );
         // A Base64 byte array is 75% the size of its String representation
         int byteArrayLength = wrapper.getUsefulLength() * 3 / 4;
         
         int result[] = new int[ byteArrayLength ];
         
         int byteTriplet = 0;        
         int byteIndex = 0;
         
         // Continue until we have less than 4 full characters left to
         // decode in the input.
         while ( byteIndex + 2 < byteArrayLength ) {
             
             // Package a set of four characters into a byte triplet
             // Each character contributes 6 bits of useful information
             byteTriplet = mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
             
             // Grab a normal byte (eight bits) out of the byte triplet
             // and put it in the byte array
             result[ byteIndex + 2 ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
             byteTriplet >>= 8;
             result[ byteIndex + 1 ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
             byteTriplet >>= 8;
             result[ byteIndex ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
             byteIndex += 3;
         }
         
         // Check if we have one byte left to decode
         if ( byteIndex == byteArrayLength - 1 ) {
             // Take out the last two characters from the String
             byteTriplet = mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
             
             // Remove the padded zeros
             byteTriplet >>= 4;
             result[ byteIndex ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
         }
 
         // Check if we have two bytes left to decode
         if ( byteIndex == byteArrayLength - 2 ) {
             // Take out the last three characters from the String
             byteTriplet = mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
             byteTriplet <<= 6;
             byteTriplet |= mapCharToInt( wrapper.getNextUsefulChar() );
         
             // Remove the padded zeros
             byteTriplet >>= 2;
             result[ byteIndex + 1 ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
             byteTriplet >>= 8;
             result[ byteIndex ] = (byte)( byteTriplet & EIGHT_BIT_MASK );
         }
         
         return result;
     }
 
 }