/*
 * reserved comment block
 * DO NOT REMOVE OR ALTER!
 */
/*
 * Copyright 1999-2005 The Apache Software Foundation.
 *
 * 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.
 */

package com.sun.org.apache.xerces.internal.impl.dv.xs;

import java.math.BigDecimal;

import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.Duration;
import javax.xml.datatype.XMLGregorianCalendar;

import com.sun.org.apache.xerces.internal.impl.Constants;
import com.sun.org.apache.xerces.internal.jaxp.datatype.DatatypeFactoryImpl;
import com.sun.org.apache.xerces.internal.xs.datatypes.XSDateTime;

/**
 * This is the base class of all date/time datatype validators.
 * It implements common code for parsing, validating and comparing datatypes.
 * Classes that extend this class, must implement parse() method.
 *
 * REVISIT: There are many instance variables, which would cause problems
 *          when we support grammar caching. A grammar is possibly used by
 *          two parser instances at the same time, then the same simple type
 *          decl object can be used to validate two strings at the same time.
 *          -SG
 *
 * @xerces.internal
 *
 * @author Elena Litani
 * @author Len Berman
 * @author Gopal Sharma, SUN Microsystems Inc.
 *
 */
public abstract class AbstractDateTimeDV extends TypeValidator {

    //debugging
    private static final boolean DEBUG = false;
    //define shared variables for date/time
    //define constants to be used in assigning default values for
    //all date/time excluding duration
    protected final static int YEAR = 2000;
    protected final static int MONTH = 01;
    protected final static int DAY = 01;
    protected static final DatatypeFactory datatypeFactory = new DatatypeFactoryImpl();

    @Override
    public short getAllowedFacets() {
        return (XSSimpleTypeDecl.FACET_PATTERN | XSSimpleTypeDecl.FACET_WHITESPACE | XSSimpleTypeDecl.FACET_ENUMERATION | XSSimpleTypeDecl.FACET_MAXINCLUSIVE | XSSimpleTypeDecl.FACET_MININCLUSIVE | XSSimpleTypeDecl.FACET_MAXEXCLUSIVE | XSSimpleTypeDecl.FACET_MINEXCLUSIVE);
    }//getAllowedFacets()

    // distinguishes between identity and equality for date/time values
    // ie: two values representing the same "moment in time" but with different
    // remembered timezones are now equal but not identical.
    @Override
    public boolean isIdentical(Object value1, Object value2) {
        if (!(value1 instanceof DateTimeData) || !(value2 instanceof DateTimeData)) {
            return false;
        }

        DateTimeData v1 = (DateTimeData) value1;
        DateTimeData v2 = (DateTimeData) value2;

        // original timezones must be the same in addition to date/time values
        // being 'equal'
        if ((v1.timezoneHr == v2.timezoneHr) && (v1.timezoneMin == v2.timezoneMin)) {
            return v1.equals(v2);
        }

        return false;
    }//isIdentical()

    // the parameters are in compiled form (from getActualValue)
    @Override
    public int compare(Object value1, Object value2) {
        return compareDates(((DateTimeData) value1),
                ((DateTimeData) value2), true);
    }//compare()

    /**
     * Compare algorithm described in dateDime (3.2.7). Duration datatype
     * overwrites this method
     *
     * @param date1 normalized date representation of the first value
     * @param date2 normalized date representation of the second value
     * @param strict
     * @return less, greater, less_equal, greater_equal, equal
     */
    protected short compareDates(DateTimeData date1, DateTimeData date2, boolean strict) {
        if (date1.utc == date2.utc) {
            return compareOrder(date1, date2);
        }
        short c1, c2;

        DateTimeData tempDate = new DateTimeData(null, this);

        if (date1.utc == 'Z') {

            //compare date1<=date1<=(date2 with time zone -14)
            //
            cloneDate(date2, tempDate); //clones date1 value to global temporary storage: fTempDate
            tempDate.timezoneHr = 14;
            tempDate.timezoneMin = 0;
            tempDate.utc = '+';
            normalize(tempDate);
            c1 = compareOrder(date1, tempDate);
            if (c1 == LESS_THAN) {
                return c1;
            }

            //compare date1>=(date2 with time zone +14)
            //
            cloneDate(date2, tempDate); //clones date1 value to global temporary storage: tempDate
            tempDate.timezoneHr = -14;
            tempDate.timezoneMin = 0;
            tempDate.utc = '-';
            normalize(tempDate);
            c2 = compareOrder(date1, tempDate);
            if (c2 == GREATER_THAN) {
                return c2;
            }

            return INDETERMINATE;
        } else if (date2.utc == 'Z') {

            //compare (date1 with time zone -14)<=date2
            //
            cloneDate(date1, tempDate); //clones date1 value to global temporary storage: tempDate
            tempDate.timezoneHr = -14;
            tempDate.timezoneMin = 0;
            tempDate.utc = '-';
            if (DEBUG) {
                System.out.println("tempDate=" + dateToString(tempDate));
            }
            normalize(tempDate);
            c1 = compareOrder(tempDate, date2);
            if (DEBUG) {
                System.out.println("date=" + dateToString(date2));
                System.out.println("tempDate=" + dateToString(tempDate));
            }
            if (c1 == LESS_THAN) {
                return c1;
            }

            //compare (date1 with time zone +14)<=date2
            //
            cloneDate(date1, tempDate); //clones date1 value to global temporary storage: tempDate
            tempDate.timezoneHr = 14;
            tempDate.timezoneMin = 0;
            tempDate.utc = '+';
            normalize(tempDate);
            c2 = compareOrder(tempDate, date2);
            if (DEBUG) {
                System.out.println("tempDate=" + dateToString(tempDate));
            }
            if (c2 == GREATER_THAN) {
                return c2;
            }

            return INDETERMINATE;
        }
        return INDETERMINATE;

    }

    /**
     * Given normalized values, determines order-relation between give date/time
     * objects.
     *
     * @param date1 date/time object
     * @param date2 date/time object
     * @return 0 if date1 and date2 are equal, a value less than 0 if date1 is
     * less than date2, a value greater than 0 if date1 is greater than date2
     */
    protected short compareOrder(DateTimeData date1, DateTimeData date2) {
        if (date1.position < 1) {
            if (date1.year < date2.year) {
                return -1;
            }
            if (date1.year > date2.year) {
                return 1;
            }
        }
        if (date1.position < 2) {
            if (date1.month < date2.month) {
                return -1;
            }
            if (date1.month > date2.month) {
                return 1;
            }
        }
        if (date1.day < date2.day) {
            return -1;
        }
        if (date1.day > date2.day) {
            return 1;
        }
        if (date1.hour < date2.hour) {
            return -1;
        }
        if (date1.hour > date2.hour) {
            return 1;
        }
        if (date1.minute < date2.minute) {
            return -1;
        }
        if (date1.minute > date2.minute) {
            return 1;
        }
        if (date1.second < date2.second) {
            return -1;
        }
        if (date1.second > date2.second) {
            return 1;
        }
        if (date1.utc < date2.utc) {
            return -1;
        }
        if (date1.utc > date2.utc) {
            return 1;
        }
        return 0;
    }

    /**
     * Parses time hh:mm:ss.sss and time zone if any
     *
     * @param start
     * @param end
     * @param data
     * @exception RuntimeException
     */
    protected void getTime(String buffer, int start, int end, DateTimeData data) throws RuntimeException {

        int stop = start + 2;

        //get hours (hh)
        data.hour = parseInt(buffer, start, stop);

        //get minutes (mm)

        if (buffer.charAt(stop++) != ':') {
            throw new RuntimeException("Error in parsing time zone");
        }
        start = stop;
        stop = stop + 2;
        data.minute = parseInt(buffer, start, stop);

        //get seconds (ss)
        if (buffer.charAt(stop++) != ':') {
            throw new RuntimeException("Error in parsing time zone");
        }

        //find UTC sign if any
        int sign = findUTCSign(buffer, start, end);

        //get seconds (ms)
        start = stop;
        stop = sign < 0 ? end : sign;
        data.second = parseSecond(buffer, start, stop);

        //parse UTC time zone (hh:mm)
        if (sign > 0) {
            getTimeZone(buffer, data, sign, end);
        }
    }

    /**
     * Parses date CCYY-MM-DD
     *
     * @param buffer
     * @param start start position
     * @param end end position
     * @param date
     * @exception RuntimeException
     */
    protected int getDate(String buffer, int start, int end, DateTimeData date) throws RuntimeException {

        start = getYearMonth(buffer, start, end, date);

        if (buffer.charAt(start++) != '-') {
            throw new RuntimeException("CCYY-MM must be followed by '-' sign");
        }
        int stop = start + 2;
        date.day = parseInt(buffer, start, stop);
        return stop;
    }

    /**
     * Parses date CCYY-MM
     *
     * @param buffer
     * @param start start position
     * @param end end position
     * @param date
     * @exception RuntimeException
     */
    protected int getYearMonth(String buffer, int start, int end, DateTimeData date) throws RuntimeException {

        if (buffer.charAt(0) == '-') {
            // REVISIT: date starts with preceding '-' sign
            //          do we have to do anything with it?
            //
            start++;
        }
        int i = indexOf(buffer, start, end, '-');
        if (i == -1) {
            throw new RuntimeException("Year separator is missing or misplaced");
        }
        int length = i - start;
        if (length < 4) {
            throw new RuntimeException("Year must have 'CCYY' format");
        } else if (length > 4 && buffer.charAt(start) == '0') {
            throw new RuntimeException("Leading zeros are required if the year value would otherwise have fewer than four digits; otherwise they are forbidden");
        }
        date.year = parseIntYear(buffer, i);
        if (buffer.charAt(i) != '-') {
            throw new RuntimeException("CCYY must be followed by '-' sign");
        }
        start = ++i;
        i = start + 2;
        date.month = parseInt(buffer, start, i);
        return i; //fStart points right after the MONTH
    }

    /**
     * Shared code from Date and YearMonth datatypes. Finds if time zone sign is
     * present
     *
     * @param end
     * @param date
     * @exception RuntimeException
     */
    protected void parseTimeZone(String buffer, int start, int end, DateTimeData date) throws RuntimeException {

        //fStart points right after the date

        if (start < end) {
            if (!isNextCharUTCSign(buffer, start, end)) {
                throw new RuntimeException("Error in month parsing");
            } else {
                getTimeZone(buffer, date, start, end);
            }
        }
    }

    /**
     * Parses time zone: 'Z' or {+,-} followed by hh:mm
     *
     * @param data
     * @param sign
     * @exception RuntimeException
     */
    protected void getTimeZone(String buffer, DateTimeData data, int sign, int end) throws RuntimeException {
        data.utc = buffer.charAt(sign);

        if (buffer.charAt(sign) == 'Z') {
            if (end > (++sign)) {
                throw new RuntimeException("Error in parsing time zone");
            }
            return;
        }
        if (sign <= (end - 6)) {

            int negate = buffer.charAt(sign) == '-' ? -1 : 1;
            //parse hr
            int stop = ++sign + 2;
            data.timezoneHr = negate * parseInt(buffer, sign, stop);
            if (buffer.charAt(stop++) != ':') {
                throw new RuntimeException("Error in parsing time zone");
            }

            //parse min
            data.timezoneMin = negate * parseInt(buffer, stop, stop + 2);

            if (stop + 2 != end) {
                throw new RuntimeException("Error in parsing time zone");
            }
            if (data.timezoneHr != 0 || data.timezoneMin != 0) {
                data.normalized = false;
            }
        } else {
            throw new RuntimeException("Error in parsing time zone");
        }
        if (DEBUG) {
            System.out.println("time[hh]=" + data.timezoneHr + " time[mm]=" + data.timezoneMin);
        }
    }

    /**
     * Computes index of given char within StringBuffer
     *
     * @param start
     * @param end
     * @param ch character to look for in StringBuffer
     * @return index of ch within StringBuffer
     */
    protected int indexOf(String buffer, int start, int end, char ch) {
        for (int i = start; i < end; i++) {
            if (buffer.charAt(i) == ch) {
                return i;
            }
        }
        return -1;
    }

    /**
     * Validates given date/time object accoring to W3C PR Schema [D.1 ISO 8601
     * Conventions]
     *
     * @param data
     */
    protected void validateDateTime(DateTimeData data) {

        //REVISIT: should we throw an exception for not valid dates
        //          or reporting an error message should be sufficient?

        /**
         * XML Schema 1.1 - RQ-123: Allow year 0000 in date related types.
         */
        if (!Constants.SCHEMA_1_1_SUPPORT && data.year == 0) {
            throw new RuntimeException("The year \"0000\" is an illegal year value");

        }

        if (data.month < 1 || data.month > 12) {
            throw new RuntimeException("The month must have values 1 to 12");

        }

        //validate days
        if (data.day > maxDayInMonthFor(data.year, data.month) || data.day < 1) {
            throw new RuntimeException("The day must have values 1 to 31");
        }

        //validate hours
        if (data.hour > 23 || data.hour < 0) {
            if (data.hour == 24 && data.minute == 0 && data.second == 0) {
                data.hour = 0;
                if (++data.day > maxDayInMonthFor(data.year, data.month)) {
                    data.day = 1;
                    if (++data.month > 12) {
                        data.month = 1;
                        if (Constants.SCHEMA_1_1_SUPPORT) {
                            ++data.year;
                        } else if (++data.year == 0) {
                            data.year = 1;
                        }
                    }
                }
            } else {
                throw new RuntimeException("Hour must have values 0-23, unless 24:00:00");
            }
        }

        //validate
        if (data.minute > 59 || data.minute < 0) {
            throw new RuntimeException("Minute must have values 0-59");
        }

        //validate
        if (data.second >= 60 || data.second < 0) {
            throw new RuntimeException("Second must have values 0-59");

        }

        //validate
        if (data.timezoneHr > 14 || data.timezoneHr < -14) {
            throw new RuntimeException("Time zone should have range -14:00 to +14:00");
        } else {
            if ((data.timezoneHr == 14 || data.timezoneHr == -14) && data.timezoneMin != 0) {
                throw new RuntimeException("Time zone should have range -14:00 to +14:00");
            } else if (data.timezoneMin > 59 || data.timezoneMin < -59) {
                throw new RuntimeException("Minute must have values 0-59");
            }
        }

    }

    /**
     * Return index of UTC char: 'Z', '+', '-'
     *
     * @param start
     * @param end
     * @return index of the UTC character that was found
     */
    protected int findUTCSign(String buffer, int start, int end) {
        int c;
        for (int i = start; i < end; i++) {
            c = buffer.charAt(i);
            if (c == 'Z' || c == '+' || c == '-') {
                return i;
            }

        }
        return -1;
    }

    /**
     * Returns
     * <code>true</code> if the character at start is 'Z', '+' or '-'.
     */
    protected final boolean isNextCharUTCSign(String buffer, int start, int end) {
        if (start < end) {
            char c = buffer.charAt(start);
            return (c == 'Z' || c == '+' || c == '-');
        }
        return false;
    }

    /**
     * Given start and end position, parses string value
     *
     * @param buffer string to parse
     * @param start start position
     * @param end end position
     * @return return integer representation of characters
     */
    protected int parseInt(String buffer, int start, int end)
            throws NumberFormatException {
        //REVISIT: more testing on this parsing needs to be done.
        int radix = 10;
        int result = 0;
        int digit = 0;
        int limit = -Integer.MAX_VALUE;
        int multmin = limit / radix;
        int i = start;
        do {
            digit = getDigit(buffer.charAt(i));
            if (digit < 0) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            if (result < multmin) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            result *= radix;
            if (result < limit + digit) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            result -= digit;

        } while (++i < end);
        return -result;
    }

    // parse Year differently to support negative value.
    protected int parseIntYear(String buffer, int end) {
        int radix = 10;
        int result = 0;
        boolean negative = false;
        int i = 0;
        int limit;
        int multmin;
        int digit = 0;

        if (buffer.charAt(0) == '-') {
            negative = true;
            limit = Integer.MIN_VALUE;
            i++;

        } else {
            limit = -Integer.MAX_VALUE;
        }
        multmin = limit / radix;
        while (i < end) {
            digit = getDigit(buffer.charAt(i++));
            if (digit < 0) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            if (result < multmin) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            result *= radix;
            if (result < limit + digit) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
            result -= digit;
        }

        if (negative) {
            if (i > 1) {
                return result;
            } else {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
        }
        return -result;

    }

    /**
     * If timezone present - normalize dateTime [E Adding durations to
     * dateTimes]
     *
     * @param date CCYY-MM-DDThh:mm:ss+03
     */
    protected void normalize(DateTimeData date) {

        // REVISIT: we have common code in addDuration() for durations
        //          should consider reorganizing it.
        //

        //add minutes (from time zone)
        int negate = -1;

        if (DEBUG) {
            System.out.println("==>date.minute" + date.minute);
            System.out.println("==>date.timezoneMin" + date.timezoneMin);
        }
        int temp = date.minute + negate * date.timezoneMin;
        int carry = fQuotient(temp, 60);
        date.minute = mod(temp, 60, carry);

        if (DEBUG) {
            System.out.println("==>carry: " + carry);
        }
        //add hours
        temp = date.hour + negate * date.timezoneHr + carry;
        carry = fQuotient(temp, 24);
        date.hour = mod(temp, 24, carry);
        if (DEBUG) {
            System.out.println("==>date.hour" + date.hour);
            System.out.println("==>carry: " + carry);
        }

        date.day = date.day + carry;

        while (true) {
            temp = maxDayInMonthFor(date.year, date.month);
            if (date.day < 1) {
                date.day = date.day + maxDayInMonthFor(date.year, date.month - 1);
                carry = -1;
            } else if (date.day > temp) {
                date.day = date.day - temp;
                carry = 1;
            } else {
                break;
            }
            temp = date.month + carry;
            date.month = modulo(temp, 1, 13);
            date.year = date.year + fQuotient(temp, 1, 13);
            if (date.year == 0 && !Constants.SCHEMA_1_1_SUPPORT) {
                date.year = (date.timezoneHr < 0 || date.timezoneMin < 0) ? 1 : -1;
            }
        }
        date.utc = 'Z';
    }

    /**
     * @param date
     */
    protected void saveUnnormalized(DateTimeData date) {
        date.unNormYear = date.year;
        date.unNormMonth = date.month;
        date.unNormDay = date.day;
        date.unNormHour = date.hour;
        date.unNormMinute = date.minute;
        date.unNormSecond = date.second;
    }

    /**
     * Resets object representation of date/time
     *
     * @param data date/time object
     */
    protected void resetDateObj(DateTimeData data) {
        data.year = 0;
        data.month = 0;
        data.day = 0;
        data.hour = 0;
        data.minute = 0;
        data.second = 0;
        data.utc = 0;
        data.timezoneHr = 0;
        data.timezoneMin = 0;
    }

    /**
     * Given {year,month} computes maximum number of days for given month
     *
     * @param year
     * @param month
     * @return integer containg the number of days in a given month
     */
    protected int maxDayInMonthFor(int year, int month) {
        //validate days
        if (month == 4 || month == 6 || month == 9 || month == 11) {
            return 30;
        } else if (month == 2) {
            if (isLeapYear(year)) {
                return 29;
            } else {
                return 28;
            }
        } else {
            return 31;
        }
    }

    private boolean isLeapYear(int year) {

        //REVISIT: should we take care about Julian calendar?
        return ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)));
    }

    //
    // help function described in W3C PR Schema [E Adding durations to dateTimes]
    //
    protected int mod(int a, int b, int quotient) {
        //modulo(a, b) = a - fQuotient(a,b)*b
        return (a - quotient * b);
    }

    //
    // help function described in W3C PR Schema [E Adding durations to dateTimes]
    //
    protected int fQuotient(int a, int b) {

        //fQuotient(a, b) = the greatest integer less than or equal to a/b
        return (int) Math.floor((float) a / b);
    }

    //
    // help function described in W3C PR Schema [E Adding durations to dateTimes]
    //
    protected int modulo(int temp, int low, int high) {
        //modulo(a - low, high - low) + low
        int a = temp - low;
        int b = high - low;
        return (mod(a, b, fQuotient(a, b)) + low);
    }

    //
    // help function described in W3C PR Schema [E Adding durations to dateTimes]
    //
    protected int fQuotient(int temp, int low, int high) {
        //fQuotient(a - low, high - low)

        return fQuotient(temp - low, high - low);
    }

    protected String dateToString(DateTimeData date) {
        StringBuffer message = new StringBuffer(25);
        append(message, date.year, 4);
        message.append('-');
        append(message, date.month, 2);
        message.append('-');
        append(message, date.day, 2);
        message.append('T');
        append(message, date.hour, 2);
        message.append(':');
        append(message, date.minute, 2);
        message.append(':');
        append(message, date.second);
        append(message, (char) date.utc, 0);
        return message.toString();
    }

    protected final void append(StringBuffer message, int value, int nch) {
        if (value == Integer.MIN_VALUE) {
            message.append(value);
            return;
        }
        if (value < 0) {
            message.append('-');
            value = -value;
        }
        if (nch == 4) {
            if (value < 10) {
                message.append("000");
            } else if (value < 100) {
                message.append("00");
            } else if (value < 1000) {
                message.append('0');
            }
            message.append(value);
        } else if (nch == 2) {
            if (value < 10) {
                message.append('0');
            }
            message.append(value);
        } else {
            if (value != 0) {
                message.append((char) value);
            }
        }
    }

    protected final void append(StringBuffer message, double value) {
        if (value < 0) {
            message.append('-');
            value = -value;
        }
        if (value < 10) {
            message.append('0');
        }
        append2(message, value);
    }

    protected final void append2(StringBuffer message, double value) {
        final int intValue = (int) value;
        if (value == intValue) {
            message.append(intValue);
        } else {
            append3(message, value);
        }
    }

    private void append3(StringBuffer message, double value) {
        String d = String.valueOf(value);
        int eIndex = d.indexOf('E');
        if (eIndex == -1) {
            message.append(d);
            return;
        }
        int exp;
        if (value < 1) {
            // Need to convert from scientific notation of the form
            // n.nnn...E-N (N >= 4) to a normal decimal value.
            try {
                exp = parseInt(d, eIndex + 2, d.length());
            } // This should never happen.
            // It's only possible if String.valueOf(double) is broken.
            catch (Exception e) {
                message.append(d);
                return;
            }
            message.append("0.");
            for (int i = 1; i < exp; ++i) {
                message.append('0');
            }
            // Remove trailing zeros.
            int end = eIndex - 1;
            while (end > 0) {
                char c = d.charAt(end);
                if (c != '0') {
                    break;
                }
                --end;
            }
            // Now append the digits to the end. Skip over the decimal point.
            for (int i = 0; i <= end; ++i) {
                char c = d.charAt(i);
                if (c != '.') {
                    message.append(c);
                }
            }
        } else {
            // Need to convert from scientific notation of the form
            // n.nnn...EN (N >= 7) to a normal decimal value.
            try {
                exp = parseInt(d, eIndex + 1, d.length());
            } // This should never happen.
            // It's only possible if String.valueOf(double) is broken.
            catch (Exception e) {
                message.append(d);
                return;
            }
            final int integerEnd = exp + 2;
            for (int i = 0; i < eIndex; ++i) {
                char c = d.charAt(i);
                if (c != '.') {
                    if (i == integerEnd) {
                        message.append('.');
                    }
                    message.append(c);
                }
            }
            // Append trailing zeroes if necessary.
            for (int i = integerEnd - eIndex; i > 0; --i) {
                message.append('0');
            }
        }
    }

    protected double parseSecond(String buffer, int start, int end)
            throws NumberFormatException {
        int dot = -1;
        for (int i = start; i < end; i++) {
            char ch = buffer.charAt(i);
            if (ch == '.') {
                dot = i;
            } else if (ch > '9' || ch < '0') {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
        }
        if (dot == -1) {
            if (start + 2 != end) {
                throw new NumberFormatException("'" + buffer + "' has wrong format");
            }
        } else if (start + 2 != dot || dot + 1 == end) {
            throw new NumberFormatException("'" + buffer + "' has wrong format");
        }
        return Double.parseDouble(buffer.substring(start, end));
    }

    //
    //Private help functions
    //
    private void cloneDate(DateTimeData finalValue, DateTimeData tempDate) {
        tempDate.year = finalValue.year;
        tempDate.month = finalValue.month;
        tempDate.day = finalValue.day;
        tempDate.hour = finalValue.hour;
        tempDate.minute = finalValue.minute;
        tempDate.second = finalValue.second;
        tempDate.utc = finalValue.utc;
        tempDate.timezoneHr = finalValue.timezoneHr;
        tempDate.timezoneMin = finalValue.timezoneMin;
    }

    /**
     * Represents date time data
     */
    static final class DateTimeData implements XSDateTime {

        int year, month, day, hour, minute, utc;
        double second;
        int timezoneHr, timezoneMin;
        private String originalValue;
        boolean normalized = true;
        int unNormYear;
        int unNormMonth;
        int unNormDay;
        int unNormHour;
        int unNormMinute;
        double unNormSecond;
        // used for comparisons - to decide the 'interesting' portions of
        // a date/time based data type.
        int position;
        // a pointer to the type that was used go generate this data
        // note that this is not the actual simple type, but one of the
        // statically created XXXDV objects, so this won't cause any GC problem.
        final AbstractDateTimeDV type;
        private volatile String canonical;

        public DateTimeData(String originalValue, AbstractDateTimeDV type) {
            this.originalValue = originalValue;
            this.type = type;
        }

        public DateTimeData(int year, int month, int day, int hour, int minute,
                double second, int utc, String originalValue, boolean normalized, AbstractDateTimeDV type) {
            this.year = year;
            this.month = month;
            this.day = day;
            this.hour = hour;
            this.minute = minute;
            this.second = second;
            this.utc = utc;
            this.type = type;
            this.originalValue = originalValue;
        }

        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof DateTimeData)) {
                return false;
            }
            return type.compareDates(this, (DateTimeData) obj, true) == 0;
        }

        // If two DateTimeData are equals - then they should have the same
        // hashcode. This means we need to convert the date to UTC before
        // we return its hashcode.
        // The DateTimeData is unfortunately mutable - so we cannot
        // cache the result of the conversion...
        //
        @Override
        public int hashCode() {
            final DateTimeData tempDate = new DateTimeData(null, type);
            type.cloneDate(this, tempDate);
            type.normalize(tempDate);
            return type.dateToString(tempDate).hashCode();
        }

        @Override
        public String toString() {
            if (canonical == null) {
                canonical = type.dateToString(this);
            }
            return canonical;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getYear()
         */

        @Override
        public int getYears() {
            if (type instanceof DurationDV) {
                return 0;
            }
            return normalized ? year : unNormYear;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getMonth()
         */

        @Override
        public int getMonths() {
            if (type instanceof DurationDV) {
                return year * 12 + month;
            }
            return normalized ? month : unNormMonth;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getDay()
         */

        @Override
        public int getDays() {
            if (type instanceof DurationDV) {
                return 0;
            }
            return normalized ? day : unNormDay;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getHour()
         */

        @Override
        public int getHours() {
            if (type instanceof DurationDV) {
                return 0;
            }
            return normalized ? hour : unNormHour;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getMinutes()
         */

        @Override
        public int getMinutes() {
            if (type instanceof DurationDV) {
                return 0;
            }
            return normalized ? minute : unNormMinute;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getSeconds()
         */

        @Override
        public double getSeconds() {
            if (type instanceof DurationDV) {
                return day * 24 * 60 * 60 + hour * 60 * 60 + minute * 60 + second;
            }
            return normalized ? second : unNormSecond;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#hasTimeZone()
         */

        @Override
        public boolean hasTimeZone() {
            return utc != 0;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getTimeZoneHours()
         */

        @Override
        public int getTimeZoneHours() {
            return timezoneHr;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getTimeZoneMinutes()
         */

        @Override
        public int getTimeZoneMinutes() {
            return timezoneMin;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getLexicalValue()
         */

        @Override
        public String getLexicalValue() {
            return originalValue;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#normalize()
         */

        @Override
        public XSDateTime normalize() {
            if (!normalized) {
                DateTimeData dt = (DateTimeData) this.clone();
                dt.normalized = true;
                return dt;
            }
            return this;
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#isNormalized()
         */

        @Override
        public boolean isNormalized() {
            return normalized;
        }

        @Override
        public Object clone() {
            DateTimeData dt = new DateTimeData(this.year, this.month, this.day, this.hour,
                    this.minute, this.second, this.utc, this.originalValue, this.normalized, this.type);
            dt.canonical = this.canonical;
            dt.position = position;
            dt.timezoneHr = this.timezoneHr;
            dt.timezoneMin = this.timezoneMin;
            dt.unNormYear = this.unNormYear;
            dt.unNormMonth = this.unNormMonth;
            dt.unNormDay = this.unNormDay;
            dt.unNormHour = this.unNormHour;
            dt.unNormMinute = this.unNormMinute;
            dt.unNormSecond = this.unNormSecond;
            return dt;
        }

        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getXMLGregorianCalendar()
         */
        @Override
        public XMLGregorianCalendar getXMLGregorianCalendar() {
            return type.getXMLGregorianCalendar(this);
        }
        /* (non-Javadoc)
         * @see org.apache.xerces.xs.datatypes.XSDateTime#getDuration()
         */

        @Override
        public Duration getDuration() {
            return type.getDuration(this);
        }
    }

    protected XMLGregorianCalendar getXMLGregorianCalendar(DateTimeData data) {
        return null;
    }

    protected Duration getDuration(DateTimeData data) {
        return null;
    }

    protected final BigDecimal getFractionalSecondsAsBigDecimal(DateTimeData data) {
        final StringBuffer buf = new StringBuffer();
        append3(buf, data.unNormSecond);
        String value = buf.toString();
        final int index = value.indexOf('.');
        if (index == -1) {
            return null;
        }
        value = value.substring(index);
        final BigDecimal _val = new BigDecimal(value);
        if (_val.compareTo(BigDecimal.valueOf(0)) == 0) {
            return null;
        }
        return _val;
    }
}