/*

 * Copyright (c) 2006, 2018, 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.

 *

 * 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 jnlp.converter.parser.xml;

import java.io.ByteArrayInputStream;

import java.io.EOFException;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.Reader;

import java.io.UnsupportedEncodingException;

public class XMLEncoding {

    /**

     * Decodes a byte stream into a String by testing for a Byte Order Mark

     * (BOM) or an XML declaration.

     * <br />

     * Detection begins by examining the first four octets of the stream for a

     * BOM. If a BOM is not found, then an encoding declaration is looked for

     * at the beginning of the stream. If the encoding still can not be

     * determined at this point, then UTF-8 is assumed.

     *

     * @param data  an array of bytes containing an encoded XML document.

     *

     * @return A string containing the decoded XML document.

     */

    public static String decodeXML(byte [] data) throws IOException {

        int start = 0;

        String encoding;

        if (data.length < BOM_LENGTH) {

            throw (new EOFException("encoding.error.not.xml"));

        }

        // no else required; successfully read stream

        int firstFour = ((0xff000000 & ((int) data[0] << 24)) |

                         (0x00ff0000 & ((int) data[1] << 16)) |

                         (0x0000ff00 & ((int) data[2] <<  8)) |

                         (0x000000ff &  (int) data[3]));

        // start by examining the first four bytes for a BOM

        switch (firstFour) {

            case EBCDIC:

                // examine the encoding declaration

                encoding = examineEncodingDeclaration(data, IBM037_ENC);

                break;

            case XML_DECLARATION:

                // assume UTF-8, but examine the encoding declaration

                encoding = examineEncodingDeclaration(data, UTF_8_ENC);

                break;

            case UTF_16BE:

                encoding = UTF_16BE_ENC;

                break;

            case UTF_16LE:

                encoding = UTF_16LE_ENC;

                break;

            case UNUSUAL_OCTET_1:

            case UNUSUAL_OCTET_2:

                throw (new UnsupportedEncodingException("encoding.error.unusual.octet"));

            case UTF_32_BE_BOM:

            case UTF_32_LE_BOM:

                encoding = UTF_32_ENC;

                break;

            default:

                int firstThree = firstFour & 0xffffff00;

                switch (firstThree) {

                    case UTF_8_BOM:

                        // the InputStreamReader class doen't properly handle

                        // the Byte Order Mark (BOM) in UTF-8 streams, so don't

                        // putback those 3 bytes.

                        start    = 3;

                        encoding = UTF_8_ENC;

                        break;

                    default:

                        int firstTwo = firstFour & 0xffff0000;

                        switch (firstTwo) {

                            case UTF_16_BE_BOM:

                            case UTF_16_LE_BOM:

                                encoding = UTF_16_ENC;

                                break;

                            default:

                                // this is probably UTF-8 without the encoding

                                // declaration

                                encoding = UTF_8_ENC;

                                break;

                        }

                        break;

                }

                break;

        }

        return (new String(data, start, data.length - start, encoding));

    }

    /**

     * [3]  S            ::= ( #x20 | #x09 | #x0d | #x0a )

     * [23] XMLDecl      ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

     * [24] VersionInfo  ::= S 'version' Eq ( '"' VersionNum '"' |

     *                                        "'" VersionNum "'" )

     * [25] Eq           ::= S? '=' S?

     * [26] VersionNum   ::= ([a-zA-Z0-9_.:] | '-')+

     * [80] EncodingDecl ::= S 'encoding' Eq ( '"' EncName '"' |

     *                                         "'" EncName "'" )

     * [81] EncName      ::= [a-zA-Z] ([a-zA-Z0-9_.] | '-')*

     */

    private static String examineEncodingDeclaration(byte [] data,

                          String    encoding) throws IOException {

        boolean loop       = false;

        boolean recognized = false;

        boolean almost     = false;

        boolean question   = false;

        boolean done       = false;

        boolean found      = false;

        int     pos        = 0;

        int     ch         = -1;

        Reader  reader     = null;

        String  result     = ((encoding != null) ? encoding : UTF_8_ENC);

        reader = new InputStreamReader(new ByteArrayInputStream(data), result);

        ch     = reader.read();

        // if this is an XML declaration, it will start with the text '<?xml'

        for (int i = 0; ((i < XML_DECL_START.length()) && (done == false)); i++) {

            if (ch != XML_DECL_START.charAt(i)) {

                // This doesn't look like an XML declaration.  This method

                // should only be called if the stream contains an XML

                // declaration in the encoding that is passed into the method.

                done = true;

                break;

            }

            // no else required; still matches

            ch = reader.read();

        }

        // there must be at least one whitespace character next.

        loop = true;

        while ((loop == true) && (done == false)) {

            switch (ch) {

                case SPACE:

                case TAB:         // intentional

                case LINEFEED:    // fall

                case RETURN:      // through

                    ch = reader.read();

                    break;

                case -1:

                    // unexpected EOF

                    done = true;

                    break;

                default:

                    // non-whitespace

                    loop = false;

                    break;

            }

        }

        // now look for the text 'encoding', but if the end of the XML

        // declaration (signified by the text '?>') comes first, then

        // assume the encoding is UTF-8

        loop = true;

        while ((loop == true) && (done == false)) {

            if (ch == -1) {

                // unexpected EOF

                done = true;

                break;

            } else if (recognized == true) {

                // this is the encoding declaration as long as the next few

                // characters are whitespace and/or the equals ('=') sign

                switch (ch) {

                    case SPACE:       // intentional

                    case TAB:         // fall

                    case LINEFEED:    // through

                    case RETURN:

                        // don't need to do anything

                        break;

                    case EQUAL:

                        if (almost == false) {

                            // got the equal, now find a quote

                            almost = true;

                        } else {

                            // this is not valid XML, so punt

                            recognized = false;

                            done       = true;

                        }

                        break;

                    case DOUBLE_QUOTE:    // intentional

                    case SINGLE_QUOTE:    // fall through

                        if (almost == true) {

                            // got the quote, so move on to get the value

                            loop = false;

                        } else {

                            // got a quote before the equal; this is not valid

                            // XML, so punt

                            recognized = false;

                            done       = true;

                        }

                        break;

                    default:

                        // non-whitespace

                        recognized = false;

                        if (almost == true) {

                            // this is not valid XML, so punt

                            done = true;

                        }

                        // no else required; this wasn't the encoding

                        // declaration

                        break;

                }

                if (recognized == false) {

                    // this isn't the encoding declaration, so go back to the

                    // top without reading the next character

                    pos = 0;

                    continue;

                }

                // no else required; still looking good

            } else if (ch == ENCODING_DECL.charAt(pos++)) {

                if (ENCODING_DECL.length() == pos) {

                    // this looks like the encoding declaration

                    recognized = true;

                }

                // no else required; this might be the encoding declaration

            } else if (ch == '?') {

                question = true;

                pos      = 0;

            } else if ((ch == '>') && (question == true)) {

                // there is no encoding declaration, so assume that the initial

                // encoding guess was correct

                done   = true;

                continue;

            } else {

                // still searching for the encoding declaration

                pos = 0;

            }

            ch = reader.read();

        }

        if (done == false) {

            StringBuilder buffer = new StringBuilder(MAX_ENC_NAME);

            if (((ch >= 'a') && (ch <= 'z')) |

                ((ch >= 'A') && (ch <= 'Z'))) {

                // add the character to the result

                buffer.append((char) ch);

                loop = true;

                while ((loop == true) && (done == false)) {

                    ch = reader.read();

                    if (((ch >= 'a') && (ch <= 'z')) ||

                        ((ch >= 'A') && (ch <= 'Z')) ||

                        ((ch >= '0') && (ch <= '9')) ||

                        (ch == '_') || (ch == '.') || (ch == '-')) {

                        // add the character to the result

                        buffer.append((char) ch);

                    } else if ((ch == DOUBLE_QUOTE) || (ch == SINGLE_QUOTE)) {

                        // finished!

                        found  = true;

                        done   = true;

                        result = buffer.toString();

                    } else {

                        // this is not a valid encoding name, so punt

                        done = true;

                    }

                }

            } else {

                // this is not a valid encoding name, so punt

                done = true;

            }

        }

        // no else required; already failed to find the encoding somewhere else

        return (result);

    }

    private static final int BOM_LENGTH   = 4;

    private static final int MAX_ENC_NAME = 512;

    private static final int SPACE        = 0x00000020;

    private static final int TAB          = 0x00000009;

    private static final int LINEFEED     = 0x0000000a;

    private static final int RETURN       = 0x0000000d;

    private static final int EQUAL        = '=';

    private static final int DOUBLE_QUOTE = '\"';

    private static final int SINGLE_QUOTE = '\'';

    private static final int UTF_32_BE_BOM   = 0x0000feff;

    private static final int UTF_32_LE_BOM   = 0xfffe0000;

    private static final int UTF_16_BE_BOM   = 0xfeff0000;

    private static final int UTF_16_LE_BOM   = 0xfffe0000;

    private static final int UTF_8_BOM       = 0xefbbbf00;

    private static final int UNUSUAL_OCTET_1 = 0x00003c00;

    private static final int UNUSUAL_OCTET_2 = 0x003c0000;

    private static final int UTF_16BE        = 0x003c003f;

    private static final int UTF_16LE        = 0x3c003f00;

    private static final int EBCDIC          = 0x4c6fa794;

    private static final int XML_DECLARATION = 0x3c3f786d;

    private static final String UTF_32_ENC   = "UTF-32";

    private static final String UTF_16_ENC   = "UTF-16";

    private static final String UTF_16BE_ENC = "UTF-16BE";

    private static final String UTF_16LE_ENC = "UTF-16LE";

    private static final String UTF_8_ENC    = "UTF-8";

    private static final String IBM037_ENC   = "IBM037";

    private static final String XML_DECL_START = "<?xml";

    private static final String ENCODING_DECL  = "encoding";

}