/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You 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.jaxp.datatype;

import com.sun.org.apache.xerces.internal.util.DatatypeMessageFormatter;

import java.io.IOException;

import java.io.ObjectStreamException;

import java.io.Serializable;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.TimeZone;

import javax.xml.datatype.DatatypeConstants;

import javax.xml.datatype.Duration;

import javax.xml.datatype.XMLGregorianCalendar;

/**

 * <p>Immutable representation of a time span as defined in

 * the W3C XML Schema 1.0 specification.</p>

 *

 * <p>A Duration object represents a period of Gregorian time,

 * which consists of six fields (years, months, days, hours,

 * minutes, and seconds) plus a sign (+/-) field.</p>

 *

 * <p>The first five fields have non-negative (>=0) integers or null

 * (which represents that the field is not set),

 * and the seconds field has a non-negative decimal or null.

 * A negative sign indicates a negative duration.</p>

 *

 * <p>This class provides a number of methods that make it easy

 * to use for the duration datatype of XML Schema 1.0 with

 * the errata.</p>

 *

 * <h2>Order relationship</h2>

 * <p>Duration objects only have partial order, where two values A and B

 * maybe either:</p>

 * <ol>

 *  <li>A&lt;B (A is shorter than B)

 *  <li>A&gt;B (A is longer than B)

 *  <li>A==B   (A and B are of the same duration)

 *  <li>A&lt;>B (Comparison between A and B is indeterminate)

 * </ol>

 * <p>For example, 30 days cannot be meaningfully compared to one month.

 * The {@link #compare(Duration)} method implements this

 * relationship.</p>

 *

 * <p>See the {@link #isLongerThan(Duration)} method for details about

 * the order relationship among {@link Duration} objects.</p>

 *

 *

 *

 * <h2>Operations over Duration</h2>

 * <p>This class provides a set of basic arithmetic operations, such

 * as addition, subtraction and multiplication.

 * Because durations don't have total order, an operation could

 * fail for some combinations of operations. For example, you cannot

 * subtract 15 days from 1 month. See the javadoc of those methods

 * for detailed conditions where this could happen.</p>

 *

 * <p>Also, division of a duration by a number is not provided because

 * the {@link Duration} class can only deal with finite precision

 * decimal numbers. For example, one cannot represent 1 sec divided by 3.</p>

 *

 * <p>However, you could substitute a division by 3 with multiplying

 * by numbers such as 0.3 or 0.333.</p>

 *

 *

 *

 * <h2>Range of allowed values</h2>

 * <p>

 * Because some operations of {@link Duration} rely on {@link Calendar}

 * even though {@link Duration} can hold very large or very small values,

 * some of the methods may not work correctly on such {@link Duration}s.

 * The impacted methods document their dependency on {@link Calendar}.

 *

 *

 * @author <a href="mailto:Kohsuke.Kawaguchi@Sun.com">Kohsuke Kawaguchi</a>

 * @author <a href="mailto:Joseph.Fialli@Sun.com">Joseph Fialli</a>

 * @see XMLGregorianCalendar#add(Duration)

 */

class DurationImpl

        extends Duration

        implements Serializable {

    /**

     * <p>Internal array of value Fields.</p>

     */

    private static final DatatypeConstants.Field[] FIELDS = new DatatypeConstants.Field[]{

        DatatypeConstants.YEARS,

        DatatypeConstants.MONTHS,

        DatatypeConstants.DAYS,

        DatatypeConstants.HOURS,

        DatatypeConstants.MINUTES,

        DatatypeConstants.SECONDS

    };

    /**

     * TimeZone for GMT.

     */

    private static final TimeZone GMT = TimeZone.getTimeZone("GMT");

    /**

     * <p>BigDecimal value of 0.</p>

     */

    private static final BigDecimal ZERO = BigDecimal.valueOf(0);

    /**

     * BigInteger value of Integer's max value.</p>

     */

    private static final BigInteger MaxIntAsBigInt =

            BigInteger.valueOf((long) Integer.MAX_VALUE);

    /**

     * <p>Indicates the sign. -1, 0 or 1 if the duration is negative,

     * zero, or positive.</p>

     */

    protected int signum;

    /**

     * <p>Years of this <code>Duration</code>.</p>

     */

    /**

     * These were final since Duration is immutable. But new subclasses need

     * to be able to set after conversion. It won't break the immutable nature

     * of them since there's no other way to set new values to them

     */

    protected BigInteger years;

    /**

     * <p>Months of this <code>Duration</code>.</p>

     */

    protected BigInteger months;

    /**

     * <p>Days of this <code>Duration</code>.</p>

     */

    protected BigInteger days;

    /**

     * <p>Hours of this <code>Duration</code>.</p>

     */

    protected BigInteger hours;

    /**

     * <p>Minutes of this <code>Duration</code>.</p>

     */

    protected BigInteger minutes;

    /**

     * <p>Seconds of this <code>Duration</code>.</p>

     */

    protected BigDecimal seconds;

    /**

     * Returns the sign of this duration in -1,0, or 1.

     *

     * @return

     *      -1 if this duration is negative, 0 if the duration is zero,

     *      and 1 if the duration is postive.

     */

    public int getSign() {

        return signum;

    }

    /**

     * Determine the sign of the duration.

     *

     * @param isPositive Sign.

     * @return 1 if positive, -1 negative, or 0 if all fields are zero.

     */

    protected int calcSignum(boolean isPositive) {

        if ((years == null || years.signum() == 0)

             && (months == null || months.signum() == 0)

             && (days == null || days.signum() == 0)

             && (hours == null || hours.signum() == 0)

             && (minutes == null || minutes.signum() == 0)

             && (seconds == null || seconds.signum() == 0)) {

            return 0;

        }

        if (isPositive) {

            return 1;

        }

        else {

            return -1;

        }

    }

    /**

     * <p>Constructs a new Duration object by specifying each field individually.</p>

     *

     * <p>All the parameters are optional as long as at least one field is present.

     * If specified, parameters have to be zero or positive.</p>

     *

     * @param isPositive Set to <code>false</code> to create a negative duration. When the length

     *   of the duration is zero, this parameter will be ignored.

     * @param years of this <code>Duration</code>

     * @param months of this <code>Duration</code>

     * @param days of this <code>Duration</code>

     * @param hours of this <code>Duration</code>

     * @param minutes of this <code>Duration</code>

     * @param seconds of this <code>Duration</code>

     *

     * @throws IllegalArgumentException

     *    If years, months, days, hours, minutes and

     *    seconds parameters are all <code>null</code>. Or if any

     *    of those parameters are negative.

     */

    protected DurationImpl(

        boolean isPositive,

        BigInteger years,

        BigInteger months,

        BigInteger days,

        BigInteger hours,

        BigInteger minutes,

        BigDecimal seconds) {

        this.years = years;

        this.months = months;

        this.days = days;

        this.hours = hours;

        this.minutes = minutes;

        this.seconds = seconds;

        this.signum = calcSignum(isPositive);

        // sanity check

        if (years == null

            && months == null

            && days == null

            && hours == null

            && minutes == null

            && seconds == null) {

            throw new IllegalArgumentException(

            //"all the fields are null"

            DatatypeMessageFormatter.formatMessage(null, "AllFieldsNull", null)

            );

        }

        testNonNegative(years, DatatypeConstants.YEARS);

        testNonNegative(months, DatatypeConstants.MONTHS);

        testNonNegative(days, DatatypeConstants.DAYS);

        testNonNegative(hours, DatatypeConstants.HOURS);

        testNonNegative(minutes, DatatypeConstants.MINUTES);

        testNonNegative(seconds, DatatypeConstants.SECONDS);

    }

    /**

     * <p>Makes sure that the given number is non-negative. If it is not,

     * throw {@link IllegalArgumentException}.</p>

     *

     * @param n Number to test.

     * @param f Field to test.

     */

    protected static void testNonNegative(BigInteger n, DatatypeConstants.Field f) {

        if (n != null && n.signum() < 0) {

            throw new IllegalArgumentException(

                DatatypeMessageFormatter.formatMessage(null, "NegativeField", new Object[]{f.toString()})

            );

        }

    }

    /**

     * <p>Makes sure that the given number is non-negative. If it is not,

     * throw {@link IllegalArgumentException}.</p>

     *

     * @param n Number to test.

     * @param f Field to test.

     */

    protected static void testNonNegative(BigDecimal n, DatatypeConstants.Field f) {

        if (n != null && n.signum() < 0) {

            throw new IllegalArgumentException(

                DatatypeMessageFormatter.formatMessage(null, "NegativeField", new Object[]{f.toString()})

            );

        }

    }

    /**

     * <p>Constructs a new Duration object by specifying each field

     * individually.</p>

     *

     * <p>This method is functionally equivalent to

     * invoking another constructor by wrapping

     * all non-zero parameters into {@link BigInteger} and {@link BigDecimal}.

     * Zero value of int parameter is equivalent of null value of

     * the corresponding field.</p>

     *

     * @see #DurationImpl(boolean, BigInteger, BigInteger, BigInteger, BigInteger,

     *   BigInteger, BigDecimal)

     */

    protected DurationImpl(

        final boolean isPositive,

        final int years,

        final int months,

        final int days,

        final int hours,

        final int minutes,

        final int seconds) {

        this(

            isPositive,

            wrap(years),

            wrap(months),

            wrap(days),

            wrap(hours),

            wrap(minutes),

            seconds != DatatypeConstants.FIELD_UNDEFINED ? new BigDecimal(String.valueOf(seconds)) : null);

    }

        /**

         * TODO: Javadoc

         *

         * @param i int to convert to BigInteger.

         *

         * @return BigInteger representation of int.

         */

    protected static BigInteger wrap(final int i) {

        // field may not be set

        if (i == DatatypeConstants.FIELD_UNDEFINED) {

                return null;

        }

        // int -> BigInteger

        return BigInteger.valueOf(i);

    }

    /**

     * <p>Constructs a new Duration object by specifying the duration

     * in milliseconds.</p>

     *

     * @param durationInMilliSeconds

     *      The length of the duration in milliseconds.

     */

    protected DurationImpl(final long durationInMilliSeconds) {

        long l = durationInMilliSeconds;

        if (l > 0) {

            signum = 1;

        }

        else if (l < 0) {

            signum = -1;

            if (l == 0x8000000000000000L) {

                // negating 0x8000000000000000L causes an overflow

                l++;

            }

            l *= -1;

        }

        else {

            signum = 0;

        }

        // let GregorianCalendar do the heavy lifting

        GregorianCalendar gregorianCalendar = new GregorianCalendar(GMT);

        // duration is the offset from the Epoch

        gregorianCalendar.setTimeInMillis(l);

        // now find out how much each field has changed

        long int2long = 0L;

        // years

        int2long = gregorianCalendar.get(Calendar.YEAR) - 1970;

        this.years = BigInteger.valueOf(int2long);

        // months

        int2long = gregorianCalendar.get(Calendar.MONTH);

        this.months = BigInteger.valueOf(int2long);

        // days

        int2long = gregorianCalendar.get(Calendar.DAY_OF_MONTH) - 1;

        this.days = BigInteger.valueOf(int2long);

        // hours

        int2long = gregorianCalendar.get(Calendar.HOUR_OF_DAY);

        this.hours = BigInteger.valueOf(int2long);

        // minutes

        int2long = gregorianCalendar.get(Calendar.MINUTE);

        this.minutes = BigInteger.valueOf(int2long);

        // seconds & milliseconds

        int2long = (gregorianCalendar.get(Calendar.SECOND) * 1000)

        this.seconds = BigDecimal.valueOf(int2long, 3);

    }

    /**

     * Constructs a new Duration object by

     * parsing its string representation

     * "PnYnMnDTnHnMnS" as defined in XML Schema 1.0 section 3.2.6.1.

     *

     * <p>

     * The string representation may not have any leading

     * and trailing whitespaces.

     *

     * <p>

     * For example, this method parses strings like

     * "P1D" (1 day), "-PT100S" (-100 sec.), "P1DT12H" (1 days and 12 hours).

     *

     * <p>

     * The parsing is done field by field so that

     * the following holds for any lexically correct string x:

     * <pre>

     * new Duration(x).toString().equals(x)

     * </pre>

     *

     * Returns a non-null valid duration object that holds the value

     * indicated by the lexicalRepresentation parameter.

     *

     * @param lexicalRepresentation

     *      Lexical representation of a duration.

     * @throws IllegalArgumentException

     *      If the given string does not conform to the aforementioned

     *      specification.

     * @throws NullPointerException

     *      If the given string is null.

     */

    protected DurationImpl(String lexicalRepresentation)

        throws IllegalArgumentException {

        // only if I could use the JDK1.4 regular expression ....

        if (lexicalRepresentation == null) {

           throw new NullPointerException();

        }

        final String s = lexicalRepresentation;

        boolean positive;

        int[] idx = new int[1];

        int length = s.length();

        boolean timeRequired = false;

        idx[0] = 0;

        if (length != idx[0] && s.charAt(idx[0]) == '-') {

            idx[0]++;

            positive = false;

        }

        else {

            positive = true;

        }

        if (length != idx[0] && s.charAt(idx[0]++) != 'P') {

            throw new IllegalArgumentException(s); //,idx[0]-1);

        }

        // phase 1: chop the string into chunks

        // (where a chunk is '<number><a symbol>'

        //--------------------------------------

        int dateLen = 0;

        String[] dateParts = new String[3];

        int[] datePartsIndex = new int[3];

        while (length != idx[0]

               && isDigit(s.charAt(idx[0]))

               && dateLen < 3) {

            datePartsIndex[dateLen] = idx[0];

            dateParts[dateLen++] = parsePiece(s, idx);

        }

        if (length != idx[0]) {

            if (s.charAt(idx[0]++) == 'T') {

                timeRequired = true;

            }

            else {

                throw new IllegalArgumentException(s); // ,idx[0]-1);

            }

        }

        int timeLen = 0;

        String[] timeParts = new String[3];

        int[] timePartsIndex = new int[3];

        while (length != idx[0]

                             && isDigitOrPeriod(s.charAt(idx[0]))

                             && timeLen < 3) {

            timePartsIndex[timeLen] = idx[0];

            timeParts[timeLen++] = parsePiece(s, idx);

        }

        if (timeRequired && timeLen == 0) {

            throw new IllegalArgumentException(s); // ,idx[0]);

        }

        if (length != idx[0]) {

            throw new IllegalArgumentException(s); // ,idx[0]);

        }

        if (dateLen == 0 && timeLen == 0) {

            throw new IllegalArgumentException(s); // ,idx[0]);

        }

        // phase 2: check the ordering of chunks

        //--------------------------------------

        organizeParts(s, dateParts, datePartsIndex, dateLen, "YMD");

        organizeParts(s, timeParts, timePartsIndex, timeLen, "HMS");