/*

 * Copyright (c) 2012, 2013, 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 *  * Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *

 *  * Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 *  * Neither the name of JSR-310 nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package java.time;

import static java.time.LocalTime.NANOS_PER_SECOND;

import static java.time.LocalTime.SECONDS_PER_DAY;

import static java.time.LocalTime.SECONDS_PER_HOUR;

import static java.time.LocalTime.SECONDS_PER_MINUTE;

import static java.time.temporal.ChronoField.NANO_OF_SECOND;

import static java.time.temporal.ChronoUnit.DAYS;

import static java.time.temporal.ChronoUnit.NANOS;

import static java.time.temporal.ChronoUnit.SECONDS;

import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectInputStream;

import java.io.Serializable;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.math.RoundingMode;

import java.time.format.DateTimeParseException;

import java.time.temporal.ChronoField;

import java.time.temporal.ChronoUnit;

import java.time.temporal.Temporal;

import java.time.temporal.TemporalAmount;

import java.time.temporal.TemporalUnit;

import java.time.temporal.UnsupportedTemporalTypeException;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Objects;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * A time-based amount of time, such as '34.5 seconds'.

 * <p>

 * This class models a quantity or amount of time in terms of seconds and nanoseconds.

 * It can be accessed using other duration-based units, such as minutes and hours.

 * In addition, the {@link ChronoUnit#DAYS DAYS} unit can be used and is treated as

 * exactly equal to 24 hours, thus ignoring daylight savings effects.

 * See {@link Period} for the date-based equivalent to this class.

 * <p>

 * A physical duration could be of infinite length.

 * For practicality, the duration is stored with constraints similar to {@link Instant}.

 * The duration uses nanosecond resolution with a maximum value of the seconds that can

 * be held in a {@code long}. This is greater than the current estimated age of the universe.

 * <p>

 * The range of a duration requires the storage of a number larger than a {@code long}.

 * To achieve this, the class stores a {@code long} representing seconds and an {@code int}

 * representing nanosecond-of-second, which will always be between 0 and 999,999,999.

 * The model is of a directed duration, meaning that the duration may be negative.

 * <p>

 * The duration is measured in "seconds", but these are not necessarily identical to

 * the scientific "SI second" definition based on atomic clocks.

 * This difference only impacts durations measured near a leap-second and should not affect

 * most applications.

 * See {@link Instant} for a discussion as to the meaning of the second and time-scales.

 *

 * <p>

 * This is a <a href="{@docRoot}/java/lang/doc-files/ValueBased.html">value-based</a>

 * class; use of identity-sensitive operations (including reference equality

 * ({@code ==}), identity hash code, or synchronization) on instances of

 * {@code Duration} may have unpredictable results and should be avoided.

 * The {@code equals} method should be used for comparisons.

 *

 * @implSpec

 * This class is immutable and thread-safe.

 *

 * @since 1.8

 */

public final class Duration

        implements TemporalAmount, Comparable<Duration>, Serializable {

    /**

     * Constant for a duration of zero.

     */

    public static final Duration ZERO = new Duration(0, 0);

    /**

     * Serialization version.

     */

    private static final long serialVersionUID = 3078945930695997490L;

    /**

     * Constant for nanos per second.

     */

    private static final BigInteger BI_NANOS_PER_SECOND = BigInteger.valueOf(NANOS_PER_SECOND);

    /**

     * The pattern for parsing.

     */

    private static final Pattern PATTERN =

            Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)D)?" +

                    "(T(?:([-+]?[0-9]+)H)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)(?:[.,]([0-9]{0,9}))?S)?)?",

                    Pattern.CASE_INSENSITIVE);

    /**

     * The number of seconds in the duration.

     */

    private final long seconds;

    /**

     * The number of nanoseconds in the duration, expressed as a fraction of the

     * number of seconds. This is always positive, and never exceeds 999,999,999.

     */

    private final int nanos;

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

    /**

     * Obtains a {@code Duration} representing a number of standard 24 hour days.

     * <p>

     * The seconds are calculated based on the standard definition of a day,

     * where each day is 86400 seconds which implies a 24 hour day.

     * The nanosecond in second field is set to zero.

     *

     * @param days  the number of days, positive or negative

     * @return a {@code Duration}, not null

     * @throws ArithmeticException if the input days exceeds the capacity of {@code Duration}

     */

    public static Duration ofDays(long days) {

        return create(Math.multiplyExact(days, SECONDS_PER_DAY), 0);

    }

    /**

     * Obtains a {@code Duration} representing a number of standard hours.

     * <p>

     * The seconds are calculated based on the standard definition of an hour,

     * where each hour is 3600 seconds.

     * The nanosecond in second field is set to zero.

     *

     * @param hours  the number of hours, positive or negative

     * @return a {@code Duration}, not null

     * @throws ArithmeticException if the input hours exceeds the capacity of {@code Duration}

     */

    public static Duration ofHours(long hours) {

        return create(Math.multiplyExact(hours, SECONDS_PER_HOUR), 0);

    }

    /**

     * Obtains a {@code Duration} representing a number of standard minutes.

     * <p>

     * The seconds are calculated based on the standard definition of a minute,

     * where each minute is 60 seconds.

     * The nanosecond in second field is set to zero.

     *

     * @param minutes  the number of minutes, positive or negative

     * @return a {@code Duration}, not null

     * @throws ArithmeticException if the input minutes exceeds the capacity of {@code Duration}

     */

    public static Duration ofMinutes(long minutes) {

        return create(Math.multiplyExact(minutes, SECONDS_PER_MINUTE), 0);

    }

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

    /**

     * Obtains a {@code Duration} representing a number of seconds.

     * <p>

     * The nanosecond in second field is set to zero.

     *

     * @param seconds  the number of seconds, positive or negative

     * @return a {@code Duration}, not null

     */

    public static Duration ofSeconds(long seconds) {

        return create(seconds, 0);

    }

    /**

     * Obtains a {@code Duration} representing a number of seconds and an

     * adjustment in nanoseconds.

     * <p>

     * This method allows an arbitrary number of nanoseconds to be passed in.

     * The factory will alter the values of the second and nanosecond in order

     * to ensure that the stored nanosecond is in the range 0 to 999,999,999.

     * For example, the following will result in the exactly the same duration:

     * <pre>

     *  Duration.ofSeconds(3, 1);

     *  Duration.ofSeconds(4, -999_999_999);

     *  Duration.ofSeconds(2, 1000_000_001);

     * </pre>

     *

     * @param seconds  the number of seconds, positive or negative

     * @param nanoAdjustment  the nanosecond adjustment to the number of seconds, positive or negative

     * @return a {@code Duration}, not null

     * @throws ArithmeticException if the adjustment causes the seconds to exceed the capacity of {@code Duration}

     */

    public static Duration ofSeconds(long seconds, long nanoAdjustment) {

        long secs = Math.addExact(seconds, Math.floorDiv(nanoAdjustment, NANOS_PER_SECOND));

        int nos = (int) Math.floorMod(nanoAdjustment, NANOS_PER_SECOND);

        return create(secs, nos);

    }

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

    /**

     * Obtains a {@code Duration} representing a number of milliseconds.

     * <p>

     * The seconds and nanoseconds are extracted from the specified milliseconds.

     *

     * @param millis  the number of milliseconds, positive or negative

     * @return a {@code Duration}, not null

     */

    public static Duration ofMillis(long millis) {

        long secs = millis / 1000;

        int mos = (int) (millis % 1000);

        if (mos < 0) {

            mos += 1000;

            secs--;

        }

        return create(secs, mos * 1000_000);

    }

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

    /**

     * Obtains a {@code Duration} representing a number of nanoseconds.

     * <p>

     * The seconds and nanoseconds are extracted from the specified nanoseconds.

     *

     * @param nanos  the number of nanoseconds, positive or negative

     * @return a {@code Duration}, not null

     */

    public static Duration ofNanos(long nanos) {

        long secs = nanos / NANOS_PER_SECOND;

        int nos = (int) (nanos % NANOS_PER_SECOND);

        if (nos < 0) {

            nos += NANOS_PER_SECOND;

            secs--;

        }

        return create(secs, nos);

    }

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

    /**

     * Obtains a {@code Duration} representing an amount in the specified unit.

     * <p>

     * The parameters represent the two parts of a phrase like '6 Hours'. For example:

     * <pre>

     *  Duration.of(3, SECONDS);

     *  Duration.of(465, HOURS);

     * </pre>

     * Only a subset of units are accepted by this method.

     * The unit must either have an {@linkplain TemporalUnit#isDurationEstimated() exact duration} or

     * be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an exception.

     *

     * @param amount  the amount of the duration, measured in terms of the unit, positive or negative

     * @param unit  the unit that the duration is measured in, must have an exact duration, not null

     * @return a {@code Duration}, not null

     * @throws DateTimeException if the period unit has an estimated duration

     * @throws ArithmeticException if a numeric overflow occurs

     */

    public static Duration of(long amount, TemporalUnit unit) {

        return ZERO.plus(amount, unit);

    }

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

    /**

     * Obtains an instance of {@code Duration} from a temporal amount.

     * <p>

     * This obtains a duration based on the specified amount.

     * A {@code TemporalAmount} represents an  amount of time, which may be

     * date-based or time-based, which this factory extracts to a duration.

     * <p>

     * The conversion loops around the set of units from the amount and uses

     * the {@linkplain TemporalUnit#getDuration() duration} of the unit to

     * calculate the total {@code Duration}.

     * Only a subset of units are accepted by this method. The unit must either

     * have an {@linkplain TemporalUnit#isDurationEstimated() exact duration}

     * or be {@link ChronoUnit#DAYS} which is treated as 24 hours.

     * If any other units are found then an exception is thrown.

     *

     * @param amount  the temporal amount to convert, not null

     * @return the equivalent duration, not null

     * @throws DateTimeException if unable to convert to a {@code Duration}

     * @throws ArithmeticException if numeric overflow occurs

     */

    public static Duration from(TemporalAmount amount) {

        Objects.requireNonNull(amount, "amount");

        Duration duration = ZERO;

        for (TemporalUnit unit : amount.getUnits()) {

            duration = duration.plus(amount.get(unit), unit);

        }

        return duration;

    }

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

    /**

     * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS}.

     * <p>

     * This will parse a textual representation of a duration, including the

     * string produced by {@code toString()}. The formats accepted are based

     * on the ISO-8601 duration format {@code PnDTnHnMn.nS} with days

     * considered to be exactly 24 hours.

     * <p>

     * The string starts with an optional sign, denoted by the ASCII negative

     * or positive symbol. If negative, the whole period is negated.

     * The ASCII letter "P" is next in upper or lower case.

     * There are then four sections, each consisting of a number and a suffix.

     * The sections have suffixes in ASCII of "D", "H", "M" and "S" for

     * days, hours, minutes and seconds, accepted in upper or lower case.

     * The suffixes must occur in order. The ASCII letter "T" must occur before

     * the first occurrence, if any, of an hour, minute or second section.

     * At least one of the four sections must be present, and if "T" is present

     * there must be at least one section after the "T".

     * The number part of each section must consist of one or more ASCII digits.

     * The number may be prefixed by the ASCII negative or positive symbol.

     * The number of days, hours and minutes must parse to an {@code long}.

     * The number of seconds must parse to an {@code long} with optional fraction.

     * The decimal point may be either a dot or a comma.

     * The fractional part may have from zero to 9 digits.

     * <p>

     * The leading plus/minus sign, and negative values for other units are

     * not part of the ISO-8601 standard.

     * <p>

     * Examples:

     * <pre>

     *    "PT20.345S" -- parses as "20.345 seconds"

     *    "PT15M"     -- parses as "15 minutes" (where a minute is 60 seconds)

     *    "PT10H"     -- parses as "10 hours" (where an hour is 3600 seconds)

     *    "P2D"       -- parses as "2 days" (where a day is 24 hours or 86400 seconds)

     *    "P2DT3H4M"  -- parses as "2 days, 3 hours and 4 minutes"

     *    "P-6H3M"    -- parses as "-6 hours and +3 minutes"

     *    "-P6H3M"    -- parses as "-6 hours and -3 minutes"

     *    "-P-6H+3M"  -- parses as "+6 hours and -3 minutes"

     * </pre>

     *

     * @param text  the text to parse, not null

     * @return the parsed duration, not null

     * @throws DateTimeParseException if the text cannot be parsed to a duration

     */

    public static Duration parse(CharSequence text) {

        Objects.requireNonNull(text, "text");

        Matcher matcher = PATTERN.matcher(text);

        if (matcher.matches()) {

            // check for letter T but no time sections

            if (!charMatch(text, matcher.start(3), matcher.end(3), 'T')) {

                boolean negate = charMatch(text, matcher.start(1), matcher.end(1), '-');

                int dayStart = matcher.start(2), dayEnd = matcher.end(2);

                int hourStart = matcher.start(4), hourEnd = matcher.end(4);

                int minuteStart = matcher.start(5), minuteEnd = matcher.end(5);

                int secondStart = matcher.start(6), secondEnd = matcher.end(6);

                int fractionStart = matcher.start(7), fractionEnd = matcher.end(7);

                if (dayStart >= 0 || hourStart >= 0 || minuteStart >= 0 || secondStart >= 0) {

                    long daysAsSecs = parseNumber(text, dayStart, dayEnd, SECONDS_PER_DAY, "days");

                    long hoursAsSecs = parseNumber(text, hourStart, hourEnd, SECONDS_PER_HOUR, "hours");

                    long minsAsSecs = parseNumber(text, minuteStart, minuteEnd, SECONDS_PER_MINUTE, "minutes");

                    long seconds = parseNumber(text, secondStart, secondEnd, 1, "seconds");

                    int nanos = parseFraction(text, fractionStart, fractionEnd, seconds < 0 ? -1 : 1);

                    try {

                        return create(negate, daysAsSecs, hoursAsSecs, minsAsSecs, seconds, nanos);

                    } catch (ArithmeticException ex) {

                        throw (DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: overflow", text, 0).initCause(ex);

                    }

                }

            }

        }

        throw new DateTimeParseException("Text cannot be parsed to a Duration", text, 0);

    }

    private static boolean charMatch(CharSequence text, int start, int end, char c) {

        return (start >= 0 && end == start + 1 && text.charAt(start) == c);

    }

    private static long parseNumber(CharSequence text, int start, int end, int multiplier, String errorText) {

        // regex limits to [-+]?[0-9]+

        if (start < 0 || end < 0) {

            return 0;

        }

        try {

            long val = Long.parseLong(text, 10, start, end);

            return Math.multiplyExact(val, multiplier);

        } catch (NumberFormatException | ArithmeticException ex) {

            throw (DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: " + errorText, text, 0).initCause(ex);

        }

    }

    private static int parseFraction(CharSequence text, int start, int end, int negate) {

        // regex limits to [0-9]{0,9}

        if (start < 0 || end < 0 || end - start == 0) {

            return 0;

        }

        try {

            int fraction = Integer.parseInt(text, 10, start, end);

            // for number strings smaller than 9 digits, interpret as if there

            // were trailing zeros

            for (int i = end - start; i < 9; i++) {

                fraction *= 10;

            }

            return fraction * negate;

        } catch (NumberFormatException | ArithmeticException ex) {

            throw (DateTimeParseException) new DateTimeParseException("Text cannot be parsed to a Duration: fraction", text, 0).initCause(ex);

        }

    }

    private static Duration create(boolean negate, long daysAsSecs, long hoursAsSecs, long minsAsSecs, long secs, int nanos) {

        long seconds = Math.addExact(daysAsSecs, Math.addExact(hoursAsSecs, Math.addExact(minsAsSecs, secs)));

        if (negate) {

            return ofSeconds(seconds, nanos).negated();

        }

        return ofSeconds(seconds, nanos);

    }

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

    /**

     * Obtains a {@code Duration} representing the duration between two temporal objects.

     * <p>

     * This calculates the duration between two temporal objects. If the objects

     * are of different types, then the duration is calculated based on the type

     * of the first object. For example, if the first argument is a {@code LocalTime}

     * then the second argument is converted to a {@code LocalTime}.

     * <p>

     * The specified temporal objects must support the {@link ChronoUnit#SECONDS SECONDS} unit.

     * For full accuracy, either the {@link ChronoUnit#NANOS NANOS} unit or the

     * {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} field should be supported.

     * <p>

     * The result of this method can be a negative period if the end is before the start.

     * To guarantee to obtain a positive duration call {@link #abs()} on the result.

     *

     * @param startInclusive  the start instant, inclusive, not null

     * @param endExclusive  the end instant, exclusive, not null

     * @return a {@code Duration}, not null

     * @throws DateTimeException if the seconds between the temporals cannot be obtained

     * @throws ArithmeticException if the calculation exceeds the capacity of {@code Duration}

     */

    public static Duration between(Temporal startInclusive, Temporal endExclusive) {

        try {

            return ofNanos(startInclusive.until(endExclusive, NANOS));

        } catch (DateTimeException | ArithmeticException ex) {

            long secs = startInclusive.until(endExclusive, SECONDS);

            long nanos;

            try {

                nanos = endExclusive.getLong(NANO_OF_SECOND) - startInclusive.getLong(NANO_OF_SECOND);

                if (secs > 0 && nanos < 0) {

                    secs++;

                } else if (secs < 0 && nanos > 0) {

                    secs--;

                }

            } catch (DateTimeException ex2) {

                nanos = 0;

            }

            return ofSeconds(secs, nanos);

        }

    }

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

    /**