import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectStreamException;

import java.time.chrono.ChronoLocalDate;

import java.time.chrono.Chronology;

import java.time.temporal.TemporalAmount;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

 * A date-based amount of time, such as '2 years, 3 months and 4 days'.

 * <p>

 * This class models a quantity or amount of time in terms of years, months and days.

 * See {@link Duration} for the time-based equivalent to this class.

 * <p>

 * Durations and period differ in their treatment of daylight savings time

 * when added to {@link ZonedDateTime}. A {@code Duration} will add an exact

 * number of seconds, thus a duration of one day is always exactly 24 hours.

 * By contrast, a {@code Period} will add a conceptual day, trying to maintain

 * the local time.

 * For example, consider adding a period of one day and a duration of one day to

 * 18:00 on the evening before a daylight savings gap. The {@code Period} will add

 * the conceptual day and result in a {@code ZonedDateTime} at 18:00 the following day.

 * By contrast, the {@code Duration} will add exactly 24 hours, resulting in a

 * {@code ZonedDateTime} at 19:00 the following day (assuming a one hour DST gap).

 * <p>

 * The supported units of a period are {@link ChronoUnit#YEARS YEARS},

 * {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}.

 * All three fields are always present, but may be set to zero.

 * <p>

 * The period may be used with any calendar system.

 * The meaning of a "year" or "month" is only applied when the object is added to a date.

 * <p>

 * The months and years fields may be {@linkplain #normalized() normalized}.

 * The normalization assumes a 12 month year, so is not appropriate for all calendar systems.

        implements TemporalAmount, Serializable {

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

    private static final long serialVersionUID = -3587258372562876L;

    /**

     * The pattern for parsing.

     */

    private final static Pattern PATTERN =

            Pattern.compile("([-+]?)P(?:([-+]?[0-9]+)Y)?(?:([-+]?[0-9]+)M)?(?:([-+]?[0-9]+)D)?", Pattern.CASE_INSENSITIVE);

    /**

     * The set of supported units.

     */

    private final static List<TemporalUnit> SUPPORTED_UNITS =

            Collections.unmodifiableList(Arrays.<TemporalUnit>asList(YEARS, MONTHS, DAYS));

     * Obtains a {@code Period} representing a number of years.

     * The resulting period will have the specified years.

     * The months and days units will be zero.

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

     * @return the period of years, not null

    public static Period ofYears(int years) {

        return create(years, 0, 0);

     * Obtains a {@code Period} representing a number of months.

     * The resulting period will have the specified months.

     * The years and days units will be zero.

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

     * @return the period of months, not null

    public static Period ofMonths(int months) {

        return create(0, months, 0);

    }

    /**

     * Obtains a {@code Period} representing a number of days.

     * <p>

     * The resulting period will have the specified days.

     * The years and months units will be zero.

     *

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

     * @return the period of days, not null

     */

    public static Period ofDays(int days) {

        return create(0, 0, days);

     * Obtains a {@code Period} representing a number of years, months and days.

     * @return the period of years, months and days, not null

    public static Period of(int years, int months, int days) {

        return create(years, months, days);

     * @return the period between this date and the end date, not null

     * @see ChronoLocalDate#periodUntil(ChronoLocalDate)

    public static Period between(LocalDate startDate, LocalDate endDate) {

        return startDate.periodUntil(endDate);

     * Obtains a {@code Period} from a text string such as {@code PnYnMnD}.

     * based on the ISO-8601 period format {@code PnYnMnD}.

     * 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 three sections, each consisting of a number and a suffix.

     * At least one of the three sections must be present.

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

     * years, months and days, accepted in upper or lower case.

     * The suffixes must occur in order.

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

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

     * The number must parse to an {@code int}.

     * <p>

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

     * not part of the ISO-8601 standard.

    public static Period parse(CharSequence text) {

        Matcher matcher = PATTERN.matcher(text);

        if (matcher.matches()) {

            int negate = ("-".equals(matcher.group(1)) ? -1 : 1);

            String yearMatch = matcher.group(2);

            String monthMatch = matcher.group(3);

            String dayMatch = matcher.group(4);

            if (yearMatch != null || monthMatch != null || dayMatch != null) {

                try {

                    return create(parseNumber(text, yearMatch, negate),

                            parseNumber(text, monthMatch, negate),

                            parseNumber(text, dayMatch, negate));

                } catch (NumberFormatException ex) {

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

                }

            }

        }

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

    }

    private static int parseNumber(CharSequence text, String str, int negate) {

        if (str == null) {

            return 0;

        }

        int val = Integer.parseInt(str);

        try {

            return Math.multiplyExact(val, negate);

        } catch (ArithmeticException ex) {

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

        }

    private static Period create(int years, int months, int days) {

        if ((years | months | days) == 0) {

        return new Period(years, months, days);

    private Period(int years, int months, int days) {

     * Gets the value of the requested unit.

     * <p>

     * This returns a value for each of the three supported units,

     * {@link ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS MONTHS} and

     * {@link ChronoUnit#DAYS DAYS}.

     * All other units throw an exception.

     *

     * @param unit the {@code TemporalUnit} for which to return the value

     * @return the long value of the unit

     * @throws DateTimeException if the unit is not supported

     */

    @Override

    public long get(TemporalUnit unit) {

        if (unit == ChronoUnit.YEARS) {

            return getYears();

        } else if (unit == ChronoUnit.MONTHS) {

            return getMonths();

        } else if (unit == ChronoUnit.DAYS) {

            return getDays();

        } else {

            throw new DateTimeException("Unsupported unit: " + unit.getName());

        }

    }

    /**

     * Gets the set of units supported by this period.

     * <p>

     * The supported units are {@link ChronoUnit#YEARS YEARS},

     * {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}.

     * They are returned in the order years, months, days.

     * <p>

     * This set can be used in conjunction with {@link #get(TemporalUnit)}

     * to access the entire state of the period.

     *

     * @return a list containing the years, months and days units, not null

     */

    @Override

    public List<TemporalUnit> getUnits() {

        return SUPPORTED_UNITS;

    }

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

    /**

     * Checks if all three units of this period are zero.

     * <p>

     * A zero period has the value zero for the years, months and days units.

     * Checks if any of the three units of this period are negative.

     * This checks whether the years, months or days units are less than zero.

     * @return true if any unit of this period is negative

    public boolean isNegative() {

        return years < 0 || months < 0 || days < 0;

     * <p>

     * This returns the years unit.

     * <p>

     * The months unit is not normalized with the years unit.

     * This means that a period of "15 months" is different to a period

     * of "1 year and 3 months".

     * @return the amount of years of this period, may be negative

     * <p>

     * This returns the months unit.

     * <p>

     * The months unit is not normalized with the years unit.

     * This means that a period of "15 months" is different to a period

     * of "1 year and 3 months".

     * @return the amount of months of this period, may be negative

     * <p>

     * This returns the days unit.

     * @return the amount of days of this period, may be negative

     * This sets the amount of the years unit in a copy of this period.

     * The months and days units are unaffected.

     * <p>

     * The months unit is not normalized with the years unit.

     * This means that a period of "15 months" is different to a period

     * of "1 year and 3 months".

     * @param years  the years to represent, may be negative

        return create(years, months, days);

     * This sets the amount of the months unit in a copy of this period.

     * The years and days units are unaffected.

     * <p>

     * The months unit is not normalized with the years unit.

     * This means that a period of "15 months" is different to a period

     * of "1 year and 3 months".

     * @param months  the months to represent, may be negative

        return create(years, months, days);

     * This sets the amount of the days unit in a copy of this period.

     * The years and months units are unaffected.

     * @param days  the days to represent, may be negative

        return create(years, months, days);

     * For example, "1 year, 6 months and 3 days" plus "2 years, 2 months and 2 days"

     * returns "3 years, 8 months and 5 days".