// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2001 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================

package com.adobe.xmp.impl;




/**
 * A utility class to perform base64 encoding and decoding as specified
 * in RFC-1521. See also RFC 1421.
 *
 * @version     $Revision: 1.4 $
 */
public class  Base64
{
	/** marker for invalid bytes */
	private static final byte INVALID = -1; 
	/** marker for accepted whitespace bytes */
	private static final byte WHITESPACE = -2;
	/** marker for an equal symbol */
	private static final byte EQUAL = -3;
	
	/** */
    private static byte[] base64 = {
        (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D',   //  0 to  3
        (byte) 'E', (byte) 'F', (byte) 'G', (byte) 'H',   //  4 to  7
        (byte) 'I', (byte) 'J', (byte) 'K', (byte) 'L',   //  8 to 11
        (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P',   // 11 to 15
        (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T',   // 16 to 19
        (byte) 'U', (byte) 'V', (byte) 'W', (byte) 'X',   // 20 to 23
        (byte) 'Y', (byte) 'Z', (byte) 'a', (byte) 'b',   // 24 to 27
        (byte) 'c', (byte) 'd', (byte) 'e', (byte) 'f',   // 28 to 31
        (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j',   // 32 to 35
        (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n',   // 36 to 39
        (byte) 'o', (byte) 'p', (byte) 'q', (byte) 'r',   // 40 to 43
        (byte) 's', (byte) 't', (byte) 'u', (byte) 'v',   // 44 to 47
        (byte) 'w', (byte) 'x', (byte) 'y', (byte) 'z',   // 48 to 51
        (byte) '0', (byte) '1', (byte) '2', (byte) '3',   // 52 to 55
        (byte) '4', (byte) '5', (byte) '6', (byte) '7',   // 56 to 59
        (byte) '8', (byte) '9', (byte) '+', (byte) '/'    // 60 to 63
    };
    /** */
    private static byte[] ascii = new byte[255];
    /** */
    static {
    	// not valid bytes
        for (int idx = 0; idx < 255; idx++)
		{
			ascii[idx] = INVALID;
		}
    	// valid bytes
		for (int idx = 0; idx < base64.length; idx++)
		{
			ascii[base64[idx]] = (byte) idx;
		}
		// whitespaces
		ascii[0x09] = WHITESPACE;
		ascii[0x0A] = WHITESPACE;
		ascii[0x0D] = WHITESPACE;
		ascii[0x20] = WHITESPACE;
		
		// trailing equals
		ascii[0x3d] = EQUAL;
    }

    
    /**
	 * Encode the given byte[].
	 * 
	 * @param src the source string.
	 * @return the base64-encoded data.
	 */
    public static final byte[] encode(byte[] src)
	{
    	return encode(src, 0);
	}
    	

    /**
	 * Encode the given byte[].
	 * 
	 * @param src the source string.
	 * @param lineFeed a linefeed is added after <code>linefeed</code> characters;
	 *            must be dividable by four; 0 means no linefeeds
	 * @return the base64-encoded data.
	 */
    public static final byte[] encode(byte[] src, int lineFeed)
	{
    	// linefeed must be dividable by 4
    	lineFeed = lineFeed / 4 * 4;
    	if (lineFeed < 0)
    	{
    		lineFeed = 0;
    	}
    	
		// determine code length
    	int codeLength = ((src.length + 2) / 3) * 4;
		if (lineFeed > 0)
		{
			codeLength += (codeLength - 1) / lineFeed;
		}
		
		byte[] dst = new byte[codeLength];
		int bits24;
		int bits6;
		//
		// Do 3-byte to 4-byte conversion + 0-63 to ascii printable conversion
		//
		int didx = 0;
		int sidx = 0;
		int lf = 0;
		while (sidx + 3 <= src.length)
		{
            bits24  = (src[sidx++] & 0xFF) << 16; 
            bits24 |= (src[sidx++] & 0xFF) <<  8; 
            bits24 |= (src[sidx++] & 0xFF) <<  0;
            bits6   = (bits24 & 0x00FC0000) >> 18; 
            dst[didx++] = base64[bits6];
            bits6   = (bits24 & 0x0003F000) >> 12; 
            dst[didx++] = base64[bits6];
            bits6   = (bits24 & 0x00000FC0) >>  6; 
            dst[didx++] = base64[bits6];
            bits6   = (bits24 & 0x0000003F);
            dst[didx++] = base64[bits6];
            
            lf += 4;
            if (didx < codeLength  &&  lineFeed > 0  &&  lf % lineFeed == 0)
            {
            	dst[didx++] = 0x0A;
            }
        }
        if (src.length - sidx == 2)
		{
            bits24  = (src[sidx    ] & 0xFF) << 16; 
            bits24 |= (src[sidx + 1] & 0xFF) <<  8;
            bits6 = (bits24 & 0x00FC0000) >> 18;
            dst[didx++] = base64[bits6]; 
            bits6 = (bits24 & 0x0003F000) >> 12; 
            dst[didx++] = base64[bits6]; 
            bits6 = (bits24 & 0x00000FC0) >>  6; 
            dst[didx++] = base64[bits6];
            dst[didx++] = (byte) '='; 
        }
        else if (src.length - sidx == 1)
		{
            bits24 = (src[sidx] & 0xFF) << 16;
            bits6  = (bits24 & 0x00FC0000) >> 18;
            dst[didx++] = base64[bits6];
            bits6  = (bits24 & 0x0003F000) >> 12; 
            dst[didx++] = base64[bits6];
            dst[didx++] = (byte) '='; 
            dst[didx++] = (byte) '='; 
        }
        return dst;
    }


    /**
     * Encode the given string.
     * @param src the source string.
     * @return the base64-encoded string.
     */
    public static final String encode(String src)
	{
		return new String(encode(src.getBytes()));
	}


    /**
	 * Decode the given byte[].
	 * 
	 * @param src
	 *            the base64-encoded data.
	 * @return the decoded data.
     * @throws IllegalArgumentException Thrown if the base 64 strings contains non-valid characters,
     * 		beside the bas64 chars, LF, CR, tab and space are accepted.
	 */
    public static final byte[] decode(byte[] src) throws IllegalArgumentException
	{
        //
        // Do ascii printable to 0-63 conversion.
        //
        int sidx;
        int srcLen = 0;
        for (sidx = 0; sidx < src.length; sidx++)
        {
        	byte val = ascii[src[sidx]];
        	if (val >= 0)
        	{	
        		src[srcLen++] = val;
        	}
        	else if (val == INVALID)
        	{
        		throw new IllegalArgumentException("Invalid base 64 string");
        	}
        }
    	
		//
		// Trim any padding.
		//
		while (srcLen > 0  &&  src[srcLen - 1] == EQUAL)
		{
			srcLen--;
		}
		byte[] dst = new byte[srcLen * 3 / 4];

		//
        // Do 4-byte to 3-byte conversion.
        //
        int didx;
        for (sidx = 0, didx = 0; didx < dst.length - 2; sidx += 4, didx += 3)
        {
            dst[didx    ] = (byte) (((src[sidx    ] << 2) & 0xFF)
                            | ((src[sidx + 1] >>> 4) & 0x03));
            dst[didx + 1] = (byte) (((src[sidx + 1] << 4) & 0xFF)
                            | ((src[sidx + 2] >>> 2) & 0x0F));
            dst[didx + 2] = (byte) (((src[sidx + 2] << 6) & 0xFF)
                            | ((src[sidx + 3]) & 0x3F));
        }
        if (didx < dst.length)
        {
            dst[didx]     = (byte) (((src[sidx    ] << 2) & 0xFF)
                            | ((src[sidx + 1] >>> 4) & 0x03));
        }
        if (++didx < dst.length)
        {
            dst[didx]     = (byte) (((src[sidx + 1] << 4) & 0xFF)
                            | ((src[sidx + 2] >>> 2) & 0x0F));
        }
        return dst;
    }


    /**
	 * Decode the given string.
	 * 
	 * @param src the base64-encoded string.
	 * @return the decoded string.
	 */
	public static final String decode(String src)
	{
		return new String(decode(src.getBytes()));
	}
}