/*

  * #%L

  * IOUtils.java - mongodb-async-driver - Allanbank Consulting, Inc.

  * %%

  * Copyright (C) 2011 - 2014 Allanbank Consulting, Inc.

  * %%

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  * 

  *      http://www.apache.org/licenses/LICENSE-2.0

  * 

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  * #L%

  */

 package com.allanbank.mongodb.util;

 import java.io.Closeable;

 import java.io.IOException;

 import java.util.Arrays;

 import java.util.logging.Level;

 import com.allanbank.mongodb.util.log.Log;

 import com.allanbank.mongodb.util.log.LogFactory;

 /**

  * IOUtils provides helper methods for dealing with I/O operations.

  * 

  * @api.no This class is <b>NOT</b> part of the drivers API. This class may be

  *         mutated in incompatible ways between any two releases of the driver.

  * @copyright 2012-2013, Allanbank Consulting, Inc., All Rights Reserved

  */

 public final class IOUtils {

     /** Base64 encoding array according to RFC 2045. */

     private static final char[] BASE_64_CHARS = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"

             + "abcdefghijklmnopqrstuvwxyz0123456789+/").toCharArray();

     /**

      * The mapping from a character (ascii) value to the corresponding Base64

      * (RFC-2045) 6-bit value.

      */

     private static final byte CHAR_TO_BASE_64_BITS[] = { -1, -1, -1, -1, -1,

             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

             -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59,

             60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

             10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1,

             -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,

             38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 };

     /** The mapping from a character (ascii) value to a nibble hex encoded. */

     private static final byte[] CHAR_TO_HEX_NIBBLE;

     /** Hex encoding characters. */

     private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();

     /** The logger for the {@link IOUtils}. */

     private static final Log LOG = LogFactory.getLog(IOUtils.class);

     static {

         CHAR_TO_HEX_NIBBLE = new byte[128];

         Arrays.fill(CHAR_TO_HEX_NIBBLE, (byte) -1);

         CHAR_TO_HEX_NIBBLE['0'] = 0;

         CHAR_TO_HEX_NIBBLE['1'] = 1;

         CHAR_TO_HEX_NIBBLE['2'] = 2;

         CHAR_TO_HEX_NIBBLE['3'] = 3;

         CHAR_TO_HEX_NIBBLE['4'] = 4;

         CHAR_TO_HEX_NIBBLE['5'] = 5;

         CHAR_TO_HEX_NIBBLE['6'] = 6;

         CHAR_TO_HEX_NIBBLE['7'] = 7;

         CHAR_TO_HEX_NIBBLE['8'] = 8;

         CHAR_TO_HEX_NIBBLE['9'] = 9;

         CHAR_TO_HEX_NIBBLE['a'] = 0xa;

         CHAR_TO_HEX_NIBBLE['b'] = 0xb;

         CHAR_TO_HEX_NIBBLE['c'] = 0xc;

         CHAR_TO_HEX_NIBBLE['d'] = 0xd;

         CHAR_TO_HEX_NIBBLE['e'] = 0xe;

         CHAR_TO_HEX_NIBBLE['f'] = 0xf;

         CHAR_TO_HEX_NIBBLE['A'] = 0xA;

         CHAR_TO_HEX_NIBBLE['B'] = 0xB;

         CHAR_TO_HEX_NIBBLE['C'] = 0xC;

         CHAR_TO_HEX_NIBBLE['D'] = 0xD;

         CHAR_TO_HEX_NIBBLE['E'] = 0xE;

         CHAR_TO_HEX_NIBBLE['F'] = 0xF;

     }

     /**

      * Converts the Base64 (RFC 2045) String into a byte array.

      * 

      * @param base64

      *            The Base64 string to convert.

      * @return The byte[] version.

      */

     public static byte[] base64ToBytes(final String base64) {

         final int base64Length = base64.length();

         final int numGroups = base64Length / 4;

         if ((4 * numGroups) != base64Length) {

             throw new IllegalArgumentException(

                     "String length must be a multiple of four.");

         }

         int missingBytesInLastGroup = 0;

         int numFullGroups = numGroups;

         if (base64Length != 0) {

             if (base64.charAt(base64Length - 1) == '=') {

                 missingBytesInLastGroup++;

                 numFullGroups--;

             }

             if (base64.charAt(base64Length - 2) == '=') {

                 missingBytesInLastGroup++;

             }

         }

         final byte[] result = new byte[(3 * numGroups)

                 - missingBytesInLastGroup];

         // Translate all 4 character groups from base64 to byte array elements

         int base64Index = 0;

         int resultIndex = 0;

         for (int i = 0; i < numFullGroups; i++) {

             final int b1 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             final int b2 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             final int b3 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             final int b4 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             result[resultIndex++] = (byte) ((b1 << 2) + (b2 >> 4));

             result[resultIndex++] = (byte) ((b2 << 4) + (b3 >> 2));

             result[resultIndex++] = (byte) ((b3 << 6) + b4);

         }

         // Translate partial group, if present

         if (missingBytesInLastGroup != 0) {

             final int b1 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             final int b2 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                     base64.charAt(base64Index++));

             result[resultIndex++] = (byte) ((b1 << 2) + (b2 >> 4));

             if (missingBytesInLastGroup == 1) {

                 final int b3 = alphabetToBits(CHAR_TO_BASE_64_BITS,

                         base64.charAt(base64Index++));

                 result[resultIndex++] = (byte) ((b2 << 4) + (b3 >> 2));

             }

         }

         return result;

     }

     /**

      * Closes the {@link Closeable} and logs any error.

      * 

      * @param closeable

      *            The connection to close.

      */

     public static void close(final Closeable closeable) {

         if (closeable != null) {

             close(closeable, Level.FINE, "I/O Exception closing: "

                     + closeable.getClass().getSimpleName());

         }

     }

     /**

      * Closes the {@link Closeable} and logs any error.

      * 

      * @param closeable

      *            The connection to close.

      * @param level

      *            The level to log on a failure.

      * @param message

      *            The message to log on a failure.

      */

     public static void close(final Closeable closeable, final Level level,

             final String message) {

         if (closeable != null) {

             try {

                 closeable.close();

             }

             catch (final IOException ignored) {

                 LOG.log(level, message);

             }

         }

     }

     /**

      * Converts the hex string to bytes.

      * 

      * @param hex

      *            The HEX string to convert.

      * @return The byte[] version.

      */

     public static byte[] hexToBytes(final String hex) {

         final String trimmed = hex.trim();

         final int length = trimmed.length();

         if ((length & 1) == 1) {

             throw new IllegalArgumentException(

                     "A hex string must be an even number of characters: '"

                             + trimmed + "'");

         }

         final byte[] bytes = new byte[length >> 1];

         for (int i = 0; i < length; i += 2) {

             final int v1 = alphabetToBits(CHAR_TO_HEX_NIBBLE, trimmed.charAt(i));

             final int v2 = alphabetToBits(CHAR_TO_HEX_NIBBLE,

                     trimmed.charAt(i + 1));

             bytes[i >> 1] = (byte) (((v1 << 4) & 0xF0) + (v2 & 0x0F));

         }

         return bytes;

     }

     /**

      * Converts the byte array into a Base64 (RFC 2045) string.

      * 

      * @param bytes

      *            The bytes to convert.

      * @return The string version.

      */

     public static String toBase64(final byte[] bytes) {

         final int length = bytes.length;

         // Create a buffer with the maximum possible length.

         final StringBuffer result = new StringBuffer(4 * ((length + 2) / 3));

         // Handle each 3 byte group.

         int index = 0;

         final int numGroups = length / 3;

         for (int i = 0; i < numGroups; i++) {

             final int byte0 = bytes[index++] & 0xff;

             final int byte1 = bytes[index++] & 0xff;

             final int byte2 = bytes[index++] & 0xff;

             result.append(BASE_64_CHARS[byte0 >> 2]);

             result.append(BASE_64_CHARS[((byte0 << 4) & 0x3f) | (byte1 >> 4)]);

             result.append(BASE_64_CHARS[((byte1 << 2) & 0x3f) | (byte2 >> 6)]);

             result.append(BASE_64_CHARS[byte2 & 0x3f]);

         }

         // Partial group with padding.

         final int numBytesInLastGroup = length - (3 * numGroups);

         if (numBytesInLastGroup > 0) {

             final int byte0 = bytes[index++] & 0xff;

             result.append(BASE_64_CHARS[byte0 >> 2]);

             if (numBytesInLastGroup == 1) {

                 result.append(BASE_64_CHARS[(byte0 << 4) & 0x3f]);

                 result.append("==");

             }

             else {

                 final int byte1 = bytes[index++] & 0xff;

                 result.append(BASE_64_CHARS[((byte0 << 4) & 0x3f)

                         | (byte1 >> 4)]);

                 result.append(BASE_64_CHARS[(byte1 << 2) & 0x3f]);

                 result.append('=');

             }

         }

         return result.toString();

     }

     /**

      * Converts the byte array into a HEX string.

      * 

      * @param bytes

      *            The bytes to convert.

      * @return The string version.

      */

     public static String toHex(final byte[] bytes) {

         final StringBuilder builder = new StringBuilder(bytes.length * 2);

         for (final byte b : bytes) {

             builder.append(HEX_CHARS[(b >> 4) & 0xF]);

             builder.append(HEX_CHARS[b & 0xF]);

         }

         return builder.toString();

     }

     /**

      * Uses the provided alphabet to convert the character to a set of bits.

      * 

      * @param alphabet

      *            The alphabet for the conversion.

      * @param c

      *            The character to convert.

      * @return The bits for the character from the alphabet.

      * @throws IllegalArgumentException

      *             If the character is not in the alphabet.

      */

     private static int alphabetToBits(final byte[] alphabet, final char c) {

         int v = -1;

         if (c < alphabet.length) {

             v = alphabet[c];

         }

         if (v < 0) {

             throw new IllegalArgumentException(

                     "Invalid character in the encoded string: '" + c + "'.");

         }

         return v;

     }

     /**

      * Stop creation of a new IOUtils.

      */

     private IOUtils() {

         // Nothing.

     }

 }