/*

 * Copyright (c) 2007, 2015, 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 javax.xml.bind;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.Calendar;

import java.util.GregorianCalendar;

import java.util.TimeZone;

import javax.xml.namespace.QName;

import javax.xml.namespace.NamespaceContext;

import javax.xml.datatype.DatatypeFactory;

import javax.xml.datatype.DatatypeConfigurationException;

/**

 * This class is the JAXB RI's default implementation of the

 * {@link DatatypeConverterInterface}.

 *

 * <p>

 * When client applications specify the use of the static print/parse

 * methods in {@link DatatypeConverter}, it will delegate

 * to this class.

 *

 * <p>

 * This class is responsible for whitespace normalization.

 *

 * @author <ul><li>Ryan Shoemaker, Sun Microsystems, Inc.</li></ul>

 * @since JAXB 2.1

 */

final class DatatypeConverterImpl implements DatatypeConverterInterface {

    /**

     * To avoid re-creating instances, we cache one instance.

     */

    public static final DatatypeConverterInterface theInstance = new DatatypeConverterImpl();

    protected DatatypeConverterImpl() {

    }

    public String parseString(String lexicalXSDString) {

        return lexicalXSDString;

    }

    public BigInteger parseInteger(String lexicalXSDInteger) {

        return _parseInteger(lexicalXSDInteger);

    }

    public static BigInteger _parseInteger(CharSequence s) {

        return new BigInteger(removeOptionalPlus(WhiteSpaceProcessor.trim(s)).toString());

    }

    public String printInteger(BigInteger val) {

        return _printInteger(val);

    }

    public static String _printInteger(BigInteger val) {

        return val.toString();

    }

    public int parseInt(String s) {

        return _parseInt(s);

    }

    /**

     * Faster but less robust String->int conversion.

     *

     * Note that:

     * <ol>

     *  <li>XML Schema allows '+', but {@link Integer#valueOf(String)} is not.

     *  <li>XML Schema allows leading and trailing (but not in-between) whitespaces.

     *      {@link Integer#valueOf(String)} doesn't allow any.

     * </ol>

     */

    public static int _parseInt(CharSequence s) {

        int len = s.length();

        int sign = 1;

        int r = 0;

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

            char ch = s.charAt(i);

            if (WhiteSpaceProcessor.isWhiteSpace(ch)) {

                // skip whitespace

            } else if ('0' <= ch && ch <= '9') {

                r = r * 10 + (ch - '0');

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

                sign = -1;

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

                // noop

            } else {

                throw new NumberFormatException("Not a number: " + s);

            }

        }

        return r * sign;

    }

    public long parseLong(String lexicalXSLong) {

        return _parseLong(lexicalXSLong);

    }

    public static long _parseLong(CharSequence s) {

        return Long.parseLong(removeOptionalPlus(WhiteSpaceProcessor.trim(s)).toString());

    }

    public short parseShort(String lexicalXSDShort) {

        return _parseShort(lexicalXSDShort);

    }

    public static short _parseShort(CharSequence s) {

        return (short) _parseInt(s);

    }

    public String printShort(short val) {

        return _printShort(val);

    }

    public static String _printShort(short val) {

        return String.valueOf(val);

    }

    public BigDecimal parseDecimal(String content) {

        return _parseDecimal(content);

    }

    public static BigDecimal _parseDecimal(CharSequence content) {

        content = WhiteSpaceProcessor.trim(content);

        if (content.length() <= 0) {

            return null;

        }

        return new BigDecimal(content.toString());

        // from purely XML Schema perspective,

        // this implementation has a problem, since

        // in xs:decimal "1.0" and "1" is equal whereas the above

        // code will return different values for those two forms.

        //

        // the code was originally using com.sun.msv.datatype.xsd.NumberType.load,

        // but a profiling showed that the process of normalizing "1.0" into "1"

        // could take non-trivial time.

        //

        // also, from the user's point of view, one might be surprised if

        // 1 (not 1.0) is returned from "1.000"

    }

    public float parseFloat(String lexicalXSDFloat) {

        return _parseFloat(lexicalXSDFloat);

    }

    public static float _parseFloat(CharSequence _val) {

        String s = WhiteSpaceProcessor.trim(_val).toString();

        /* Incompatibilities of XML Schema's float "xfloat" and Java's float "jfloat"

         * jfloat.valueOf ignores leading and trailing whitespaces,

        whereas this is not allowed in xfloat.

         * jfloat.valueOf allows "float type suffix" (f, F) to be

        appended after float literal (e.g., 1.52e-2f), whereare

        this is not the case of xfloat.

        gray zone

        ---------

         * jfloat allows ".523". And there is no clear statement that mentions

        this case in xfloat. Although probably this is allowed.

         *

         */

        if (s.equals("NaN")) {

            return Float.NaN;

        }

        if (s.equals("INF")) {

            return Float.POSITIVE_INFINITY;

        }

        if (s.equals("-INF")) {

            return Float.NEGATIVE_INFINITY;

        }

        if (s.length() == 0

                || !isDigitOrPeriodOrSign(s.charAt(0))

                || !isDigitOrPeriodOrSign(s.charAt(s.length() - 1))) {

            throw new NumberFormatException();

        }

        // these screening process is necessary due to the wobble of Float.valueOf method

        return Float.parseFloat(s);

    }

    public String printFloat(float v) {

        return _printFloat(v);

    }

    public static String _printFloat(float v) {

        if (Float.isNaN(v)) {

            return "NaN";

        }

        if (v == Float.POSITIVE_INFINITY) {

            return "INF";

        }

        if (v == Float.NEGATIVE_INFINITY) {

            return "-INF";

        }

        return String.valueOf(v);

    }

    public double parseDouble(String lexicalXSDDouble) {

        return _parseDouble(lexicalXSDDouble);

    }

    public static double _parseDouble(CharSequence _val) {

        String val = WhiteSpaceProcessor.trim(_val).toString();

        if (val.equals("NaN")) {

            return Double.NaN;

        }

        if (val.equals("INF")) {

            return Double.POSITIVE_INFINITY;

        }

        if (val.equals("-INF")) {

            return Double.NEGATIVE_INFINITY;

        }

        if (val.length() == 0

                || !isDigitOrPeriodOrSign(val.charAt(0))

                || !isDigitOrPeriodOrSign(val.charAt(val.length() - 1))) {

            throw new NumberFormatException(val);

        }

        // these screening process is necessary due to the wobble of Float.valueOf method

        return Double.parseDouble(val);

    }

    public boolean parseBoolean(String lexicalXSDBoolean) {

        Boolean b = _parseBoolean(lexicalXSDBoolean);

        return (b == null) ? false : b.booleanValue();

    }

    public static Boolean _parseBoolean(CharSequence literal) {

        if (literal == null) {

            return null;

        }

        int i = 0;

        int len = literal.length();

        char ch;

        boolean value = false;

        if (literal.length() <= 0) {

            return null;

        }

        do {

            ch = literal.charAt(i++);

        } while (WhiteSpaceProcessor.isWhiteSpace(ch) && i < len);

        int strIndex = 0;

        switch (ch) {

            case '1':

                value = true;

                break;

            case '0':

                value = false;

                break;

            case 't':

                String strTrue = "rue";

                do {

                    ch = literal.charAt(i++);

                } while ((strTrue.charAt(strIndex++) == ch) && i < len && strIndex < 3);

                if (strIndex == 3) {

                    value = true;

                } else {

                    return false;

                }

//                    throw new IllegalArgumentException("String \"" + literal + "\" is not valid boolean value.");

                break;

            case 'f':

                String strFalse = "alse";

                do {

                    ch = literal.charAt(i++);

                } while ((strFalse.charAt(strIndex++) == ch) && i < len && strIndex < 4);

                if (strIndex == 4) {

                    value = false;

                } else {

                    return false;

                }

//                    throw new IllegalArgumentException("String \"" + literal + "\" is not valid boolean value.");

                break;

        }

        if (i < len) {

            do {

                ch = literal.charAt(i++);

            } while (WhiteSpaceProcessor.isWhiteSpace(ch) && i < len);

        }

        if (i == len) {

            return value;

        } else {

            return null;

        }

//            throw new IllegalArgumentException("String \"" + literal + "\" is not valid boolean value.");

    }

    public String printBoolean(boolean val) {

        return val ? "true" : "false";

    }

    public static String _printBoolean(boolean val) {

        return val ? "true" : "false";

    }

    public byte parseByte(String lexicalXSDByte) {

        return _parseByte(lexicalXSDByte);

    }

    public static byte _parseByte(CharSequence literal) {

        return (byte) _parseInt(literal);

    }

    public String printByte(byte val) {

        return _printByte(val);

    }

    public static String _printByte(byte val) {

        return String.valueOf(val);

    }

    public QName parseQName(String lexicalXSDQName, NamespaceContext nsc) {

        return _parseQName(lexicalXSDQName, nsc);

    }

    /**

     * @return null if fails to convert.

     */

    public static QName _parseQName(CharSequence text, NamespaceContext nsc) {

        int length = text.length();

        // trim whitespace

        int start = 0;

        while (start < length && WhiteSpaceProcessor.isWhiteSpace(text.charAt(start))) {

            start++;

        }

        int end = length;

        while (end > start && WhiteSpaceProcessor.isWhiteSpace(text.charAt(end - 1))) {

            end--;

        }

        if (end == start) {

            throw new IllegalArgumentException("input is empty");

        }

        String uri;

        String localPart;

        String prefix;

        // search ':'

        int idx = start + 1;    // no point in searching the first char. that's not valid.

        while (idx < end && text.charAt(idx) != ':') {

            idx++;

        }

        if (idx == end) {

            uri = nsc.getNamespaceURI("");

            localPart = text.subSequence(start, end).toString();

            prefix = "";

        } else {

            // Prefix exists, check everything

            prefix = text.subSequence(start, idx).toString();

            localPart = text.subSequence(idx + 1, end).toString();

            uri = nsc.getNamespaceURI(prefix);

            // uri can never be null according to javadoc,

            // but some users reported that there are implementations that return null.

            if (uri == null || uri.length() == 0) // crap. the NamespaceContext interface is broken.

            // error: unbound prefix

            {

                throw new IllegalArgumentException("prefix " + prefix + " is not bound to a namespace");

            }

        }

        return new QName(uri, localPart, prefix);

    }

    public Calendar parseDateTime(String lexicalXSDDateTime) {

        return _parseDateTime(lexicalXSDDateTime);

    }

    public static GregorianCalendar _parseDateTime(CharSequence s) {

        String val = WhiteSpaceProcessor.trim(s).toString();

        return datatypeFactory.newXMLGregorianCalendar(val).toGregorianCalendar();

    }

    public String printDateTime(Calendar val) {

        return _printDateTime(val);

    }

    public static String _printDateTime(Calendar val) {

        return CalendarFormatter.doFormat("%Y-%M-%DT%h:%m:%s%z", val);

    }

    public byte[] parseBase64Binary(String lexicalXSDBase64Binary) {

        return _parseBase64Binary(lexicalXSDBase64Binary);

    }

    public byte[] parseHexBinary(String s) {

        final int len = s.length();

        // "111" is not a valid hex encoding.

        if (len % 2 != 0) {

            throw new IllegalArgumentException("hexBinary needs to be even-length: " + s);

        }

        byte[] out = new byte[len / 2];

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

            int h = hexToBin(s.charAt(i));

            int l = hexToBin(s.charAt(i + 1));

            if (h == -1 || l == -1) {

                throw new IllegalArgumentException("contains illegal character for hexBinary: " + s);

            }

            out[i / 2] = (byte) (h * 16 + l);

        }

        return out;

    }

    private static int hexToBin(char ch) {

        if ('0' <= ch && ch <= '9') {

            return ch - '0';

        }

        if ('A' <= ch && ch <= 'F') {

            return ch - 'A' + 10;

        }

        if ('a' <= ch && ch <= 'f') {

            return ch - 'a' + 10;

        }

        return -1;

    }

    private static final char[] hexCode = "0123456789ABCDEF".toCharArray();

    public String printHexBinary(byte[] data) {

        StringBuilder r = new StringBuilder(data.length * 2);

        for (byte b : data) {

            r.append(hexCode[(b >> 4) & 0xF]);

            r.append(hexCode[(b & 0xF)]);

        }

        return r.toString();

    }

    public long parseUnsignedInt(String lexicalXSDUnsignedInt) {

        return _parseLong(lexicalXSDUnsignedInt);

    }

    public String printUnsignedInt(long val) {

        return _printLong(val);

    }

    public int parseUnsignedShort(String lexicalXSDUnsignedShort) {

        return _parseInt(lexicalXSDUnsignedShort);

    }

    public Calendar parseTime(String lexicalXSDTime) {

        return datatypeFactory.newXMLGregorianCalendar(lexicalXSDTime).toGregorianCalendar();

    }

    public String printTime(Calendar val) {

        return CalendarFormatter.doFormat("%h:%m:%s%z", val);

    }

    public Calendar parseDate(String lexicalXSDDate) {

        return datatypeFactory.newXMLGregorianCalendar(lexicalXSDDate).toGregorianCalendar();

    }

    public String printDate(Calendar val) {

        return _printDate(val);

    }

    public static String _printDate(Calendar val) {

        return CalendarFormatter.doFormat((new StringBuilder("%Y-%M-%D").append("%z")).toString(),val);

    }

    public String parseAnySimpleType(String lexicalXSDAnySimpleType) {

        return lexicalXSDAnySimpleType;

//        return (String)SimpleURType.theInstance._createValue( lexicalXSDAnySimpleType, null );

    }

    public String printString(String val) {

//        return StringType.theInstance.convertToLexicalValue( val, null );

        return val;

    }

    public String printInt(int val) {

        return _printInt(val);

    }