/*

 * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.util;

import java.io.FilterOutputStream;

import java.io.InputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import java.nio.charset.StandardCharsets;

import jdk.internal.HotSpotIntrinsicCandidate;

/**

 * This class consists exclusively of static methods for obtaining

 * encoders and decoders for the Base64 encoding scheme. The

 * implementation of this class supports the following types of Base64

 * as specified in

 * <a href="http://www.ietf.org/rfc/rfc4648.txt">RFC 4648</a> and

 * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>.

 *

 * <ul>

 * <li><a id="basic"><b>Basic</b></a>

 * <p> Uses "The Base64 Alphabet" as specified in Table 1 of

 *     RFC 4648 and RFC 2045 for encoding and decoding operation.

 *     The encoder does not add any line feed (line separator)

 *     character. The decoder rejects data that contains characters

 *     outside the base64 alphabet.</p></li>

 *

 * <li><a id="url"><b>URL and Filename safe</b></a>

 * <p> Uses the "URL and Filename safe Base64 Alphabet" as specified

 *     in Table 2 of RFC 4648 for encoding and decoding. The

 *     encoder does not add any line feed (line separator) character.

 *     The decoder rejects data that contains characters outside the

 *     base64 alphabet.</p></li>

 *

 * <li><a id="mime"><b>MIME</b></a>

 * <p> Uses "The Base64 Alphabet" as specified in Table 1 of

 *     RFC 2045 for encoding and decoding operation. The encoded output

 *     must be represented in lines of no more than 76 characters each

 *     and uses a carriage return {@code '\r'} followed immediately by

 *     a linefeed {@code '\n'} as the line separator. No line separator

 *     is added to the end of the encoded output. All line separators

 *     or other characters not found in the base64 alphabet table are

 *     ignored in decoding operation.</p></li>

 * </ul>

 *

 * <p> Unless otherwise noted, passing a {@code null} argument to a

 * method of this class will cause a {@link java.lang.NullPointerException

 * NullPointerException} to be thrown.

 *

 * @author  Xueming Shen

 * @since   1.8

 */

public class Base64 {

    private Base64() {}

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#basic">Basic</a> type base64 encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getEncoder() {

         return Encoder.RFC4648;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#url">URL and Filename safe</a> type base64

     * encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getUrlEncoder() {

         return Encoder.RFC4648_URLSAFE;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#mime">MIME</a> type base64 encoding scheme.

     *

     * @return  A Base64 encoder.

     */

    public static Encoder getMimeEncoder() {

        return Encoder.RFC2045;

    }

    /**

     * Returns a {@link Encoder} that encodes using the

     * <a href="#mime">MIME</a> type base64 encoding scheme

     * with specified line length and line separators.

     *

     * @param   lineLength

     *          the length of each output line (rounded down to nearest multiple

     *          of 4). If the rounded down line length is not a positive value,

     *          the output will not be separated in lines

     * @param   lineSeparator

     *          the line separator for each output line

     *

     * @return  A Base64 encoder.

     *

     * @throws  IllegalArgumentException if {@code lineSeparator} includes any

     *          character of "The Base64 Alphabet" as specified in Table 1 of

     *          RFC 2045.

     */

    public static Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) {

         Objects.requireNonNull(lineSeparator);

         int[] base64 = Decoder.fromBase64;

         for (byte b : lineSeparator) {

             if (base64[b & 0xff] != -1)

                 throw new IllegalArgumentException(

                     "Illegal base64 line separator character 0x" + Integer.toString(b, 16));

         }

         // round down to nearest multiple of 4

         lineLength &= ~0b11;

         if (lineLength <= 0) {

             return Encoder.RFC4648;

         }

         return new Encoder(false, lineSeparator, lineLength, true);

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#basic">Basic</a> type base64 encoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getDecoder() {

         return Decoder.RFC4648;

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#url">URL and Filename safe</a> type base64

     * encoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getUrlDecoder() {

         return Decoder.RFC4648_URLSAFE;

    }

    /**

     * Returns a {@link Decoder} that decodes using the

     * <a href="#mime">MIME</a> type base64 decoding scheme.

     *

     * @return  A Base64 decoder.

     */

    public static Decoder getMimeDecoder() {

         return Decoder.RFC2045;

    }

    /**

     * This class implements an encoder for encoding byte data using

     * the Base64 encoding scheme as specified in RFC 4648 and RFC 2045.

     *

     * <p> Instances of {@link Encoder} class are safe for use by

     * multiple concurrent threads.

     *

     * <p> Unless otherwise noted, passing a {@code null} argument to

     * a method of this class will cause a

     * {@link java.lang.NullPointerException NullPointerException} to

     * be thrown.

     * <p> If the encoded byte output of the needed size can not

     *     be allocated, the encode methods of this class will

     *     cause an {@link java.lang.OutOfMemoryError OutOfMemoryError}

     *     to be thrown.

     *

     * @see     Decoder

     * @since   1.8

     */

    public static class Encoder {

        private final byte[] newline;

        private final int linemax;

        private final boolean isURL;

        private final boolean doPadding;

        private Encoder(boolean isURL, byte[] newline, int linemax, boolean doPadding) {

            this.isURL = isURL;

            this.newline = newline;

            this.linemax = linemax;

            this.doPadding = doPadding;

        }

        /**

         * This array is a lookup table that translates 6-bit positive integer

         * index values into their "Base64 Alphabet" equivalents as specified

         * in "Table 1: The Base64 Alphabet" of RFC 2045 (and RFC 4648).

         */

        private static final char[] toBase64 = {

            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'

        };

        /**

         * It's the lookup table for "URL and Filename safe Base64" as specified

         * in Table 2 of the RFC 4648, with the '+' and '/' changed to '-' and

         * '_'. This table is used when BASE64_URL is specified.

         */

        private static final char[] toBase64URL = {

            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',

            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'

        };

        private static final int MIMELINEMAX = 76;

        private static final byte[] CRLF = new byte[] {'\r', '\n'};

        static final Encoder RFC4648 = new Encoder(false, null, -1, true);

        static final Encoder RFC4648_URLSAFE = new Encoder(true, null, -1, true);

        static final Encoder RFC2045 = new Encoder(false, CRLF, MIMELINEMAX, true);

        /**

         * Calculates the length of the encoded output bytes.

         *

         * @param srclen length of the bytes to encode

         * @param throwOOME if true, throws OutOfMemoryError if the length of

         *                  the encoded bytes overflows; else returns the

         *                  length

         * @return length of the encoded bytes, or -1 if the length overflows

         *

         */

            int len = 0;

            try {

                if (doPadding) {

                    len = Math.multiplyExact(4, (Math.addExact(srclen, 2) / 3));

                } else {

                    int n = srclen % 3;

                    len = Math.addExact(Math.multiplyExact(4, (srclen / 3)), (n == 0 ? 0 : n + 1));

                }

                if (linemax > 0) {                             // line separators

                    len = Math.addExact(len, (len - 1) / linemax * newline.length);

                }

            } catch (ArithmeticException ex) {

                if (throwOOME) {

                    throw new OutOfMemoryError("Encoded size is too large");

                } else {

                    // let the caller know that encoded bytes length

                    // is too large

                    len = -1;

                }

            }

            return len;

        }

        /**

         * Encodes all bytes from the specified byte array into a newly-allocated

         * byte array using the {@link Base64} encoding scheme. The returned byte

         * array is of the length of the resulting bytes.

         *

         * @param   src

         *          the byte array to encode

         * @return  A newly-allocated byte array containing the resulting

         *          encoded bytes.

         */

        public byte[] encode(byte[] src) {

            byte[] dst = new byte[len];

            int ret = encode0(src, 0, src.length, dst);

            if (ret != dst.length)

                 return Arrays.copyOf(dst, ret);

            return dst;

        }

        /**

         * Encodes all bytes from the specified byte array using the

         * {@link Base64} encoding scheme, writing the resulting bytes to the

         * given output byte array, starting at offset 0.

         *

         * <p> It is the responsibility of the invoker of this method to make

         * sure the output byte array {@code dst} has enough space for encoding

         * all bytes from the input byte array. No bytes will be written to the

         * output byte array if the output byte array is not big enough.

         *

         * @param   src

         *          the byte array to encode

         * @param   dst

         *          the output byte array

         * @return  The number of bytes written to the output byte array

         *

         * @throws  IllegalArgumentException if {@code dst} does not have enough

         *          space for encoding all input bytes.

         */

        public int encode(byte[] src, byte[] dst) {

            if (dst.length < len || len == -1)

                throw new IllegalArgumentException(

                    "Output byte array is too small for encoding all input bytes");

            return encode0(src, 0, src.length, dst);

        }

        /**

         * Encodes the specified byte array into a String using the {@link Base64}

         * encoding scheme.

         *

         * <p> This method first encodes all input bytes into a base64 encoded

         * byte array and then constructs a new String by using the encoded byte

         * array and the {@link java.nio.charset.StandardCharsets#ISO_8859_1

         * ISO-8859-1} charset.

         *

         * <p> In other words, an invocation of this method has exactly the same

         * effect as invoking

         * {@code new String(encode(src), StandardCharsets.ISO_8859_1)}.

         *

         * @param   src

         *          the byte array to encode

         * @return  A String containing the resulting Base64 encoded characters

         */

        @SuppressWarnings("deprecation")

        public String encodeToString(byte[] src) {

            byte[] encoded = encode(src);

            return new String(encoded, 0, 0, encoded.length);

        }

        /**

         * Encodes all remaining bytes from the specified byte buffer into

         * a newly-allocated ByteBuffer using the {@link Base64} encoding

         * scheme.

         *

         * Upon return, the source buffer's position will be updated to

         * its limit; its limit will not have been changed. The returned

         * output buffer's position will be zero and its limit will be the

         * number of resulting encoded bytes.

         *

         * @param   buffer

         *          the source ByteBuffer to encode

         * @return  A newly-allocated byte buffer containing the encoded bytes.

         */

        public ByteBuffer encode(ByteBuffer buffer) {

            byte[] dst = new byte[len];

            int ret = 0;

            if (buffer.hasArray()) {

                ret = encode0(buffer.array(),

                              buffer.arrayOffset() + buffer.position(),

                              buffer.arrayOffset() + buffer.limit(),

                              dst);

                buffer.position(buffer.limit());

            } else {

                byte[] src = new byte[buffer.remaining()];

                buffer.get(src);

                ret = encode0(src, 0, src.length, dst);

            }

            if (ret != dst.length)

                 dst = Arrays.copyOf(dst, ret);

            return ByteBuffer.wrap(dst);

        }

        /**

         * Wraps an output stream for encoding byte data using the {@link Base64}

         * encoding scheme.

         *

         * <p> It is recommended to promptly close the returned output stream after

         * use, during which it will flush all possible leftover bytes to the underlying

         * output stream. Closing the returned output stream will close the underlying

         * output stream.

         *

         * @param   os

         *          the output stream.

         * @return  the output stream for encoding the byte data into the

         *          specified Base64 encoded format

         */

        public OutputStream wrap(OutputStream os) {

            Objects.requireNonNull(os);

            return new EncOutputStream(os, isURL ? toBase64URL : toBase64,

                                       newline, linemax, doPadding);

        }

        /**

         * Returns an encoder instance that encodes equivalently to this one,

         * but without adding any padding character at the end of the encoded

         * byte data.

         *

         * <p> The encoding scheme of this encoder instance is unaffected by

         * this invocation. The returned encoder instance should be used for

         * non-padding encoding operation.

         *

         * @return an equivalent encoder that encodes without adding any

         *         padding character at the end

         */

        public Encoder withoutPadding() {

            if (!doPadding)

                return this;

            return new Encoder(isURL, newline, linemax, false);

        }

        @HotSpotIntrinsicCandidate

        private void encodeBlock(byte[] src, int sp, int sl, byte[] dst, int dp, boolean isURL) {

            char[] base64 = isURL ? toBase64URL : toBase64;

            for (int sp0 = sp, dp0 = dp ; sp0 < sl; ) {

                int bits = (src[sp0++] & 0xff) << 16 |

                           (src[sp0++] & 0xff) <<  8 |

                           (src[sp0++] & 0xff);

                dst[dp0++] = (byte)base64[(bits >>> 18) & 0x3f];

                dst[dp0++] = (byte)base64[(bits >>> 12) & 0x3f];

                dst[dp0++] = (byte)base64[(bits >>> 6)  & 0x3f];

                dst[dp0++] = (byte)base64[bits & 0x3f];

            }

        }

        private int encode0(byte[] src, int off, int end, byte[] dst) {

            char[] base64 = isURL ? toBase64URL : toBase64;

            int sp = off;

            int slen = (end - off) / 3 * 3;

            int sl = off + slen;

            if (linemax > 0 && slen  > linemax / 4 * 3)

                slen = linemax / 4 * 3;

            int dp = 0;

            while (sp < sl) {

                int sl0 = Math.min(sp + slen, sl);

                encodeBlock(src, sp, sl0, dst, dp, isURL);

                int dlen = (sl0 - sp) / 3 * 4;

                dp += dlen;

                sp = sl0;

                if (dlen == linemax && sp < end) {

                    for (byte b : newline){

                        dst[dp++] = b;

                    }

                }

            }

            if (sp < end) {               // 1 or 2 leftover bytes

                int b0 = src[sp++] & 0xff;

                dst[dp++] = (byte)base64[b0 >> 2];

                if (sp == end) {

                    dst[dp++] = (byte)base64[(b0 << 4) & 0x3f];

                    if (doPadding) {

                        dst[dp++] = '=';

                        dst[dp++] = '=';

                    }

                } else {

                    int b1 = src[sp++] & 0xff;

                    dst[dp++] = (byte)base64[(b0 << 4) & 0x3f | (b1 >> 4)];

                    dst[dp++] = (byte)base64[(b1 << 2) & 0x3f];

                    if (doPadding) {

                        dst[dp++] = '=';

                    }

                }

            }

            return dp;

        }

    }

    /**

     * This class implements a decoder for decoding byte data using the

     * Base64 encoding scheme as specified in RFC 4648 and RFC 2045.

     *

     * <p> The Base64 padding character {@code '='} is accepted and

     * interpreted as the end of the encoded byte data, but is not

     * required. So if the final unit of the encoded byte data only has

     * two or three Base64 characters (without the corresponding padding

     * character(s) padded), they are decoded as if followed by padding

     * character(s). If there is a padding character present in the

     * final unit, the correct number of padding character(s) must be

     * present, otherwise {@code IllegalArgumentException} (

     * {@code IOException} when reading from a Base64 stream) is thrown

     * during decoding.

     *

     * <p> Instances of {@link Decoder} class are safe for use by

     * multiple concurrent threads.

     *

     * <p> Unless otherwise noted, passing a {@code null} argument to

     * a method of this class will cause a

     * {@link java.lang.NullPointerException NullPointerException} to

     * be thrown.

     * <p> If the decoded byte output of the needed size can not

     *     be allocated, the decode methods of this class will

     *     cause an {@link java.lang.OutOfMemoryError OutOfMemoryError}

     *     to be thrown.

     *

     * @see     Encoder

     * @since   1.8

     */

    public static class Decoder {

        private final boolean isURL;

        private final boolean isMIME;

        private Decoder(boolean isURL, boolean isMIME) {

            this.isURL = isURL;

            this.isMIME = isMIME;

        }

        /**

         * Lookup table for decoding unicode characters drawn from the