/*

 * 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.SECONDS_PER_DAY;

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

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

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

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

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

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

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

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

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

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

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

import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectStreamException;

import java.io.Serializable;

import java.time.chrono.ChronoLocalDate;

import java.time.chrono.Era;

import java.time.chrono.IsoChronology;

import java.time.format.DateTimeFormatter;

import java.time.format.DateTimeParseException;

import java.time.temporal.ChronoField;

import java.time.temporal.ChronoUnit;

import java.time.temporal.Temporal;

import java.time.temporal.TemporalAccessor;

import java.time.temporal.TemporalAdjuster;

import java.time.temporal.TemporalAmount;

import java.time.temporal.TemporalField;

import java.time.temporal.TemporalQuery;

import java.time.temporal.TemporalUnit;

import java.time.temporal.UnsupportedTemporalTypeException;

import java.time.temporal.ValueRange;

import java.time.zone.ZoneOffsetTransition;

import java.time.zone.ZoneRules;

import java.util.Objects;

/**

 * A date without a time-zone in the ISO-8601 calendar system,

 * such as {@code 2007-12-03}.

 * <p>

 * {@code LocalDate} is an immutable date-time object that represents a date,

 * often viewed as year-month-day. Other date fields, such as day-of-year,

 * day-of-week and week-of-year, can also be accessed.

 * For example, the value "2nd October 2007" can be stored in a {@code LocalDate}.

 * <p>

 * This class does not store or represent a time or time-zone.

 * Instead, it is a description of the date, as used for birthdays.

 * It cannot represent an instant on the time-line without additional information

 * such as an offset or time-zone.

 * <p>

 * The ISO-8601 calendar system is the modern civil calendar system used today

 * in most of the world. It is equivalent to the proleptic Gregorian calendar

 * system, in which today's rules for leap years are applied for all time.

 * For most applications written today, the ISO-8601 rules are entirely suitable.

 * However, any application that makes use of historical dates, and requires them

 * to be accurate will find the ISO-8601 approach unsuitable.

 *

 * This class is immutable and thread-safe.

 *

 * @since 1.8

 */

public final class LocalDate

        implements Temporal, TemporalAdjuster, ChronoLocalDate<LocalDate>, Serializable {

    /**

     * The minimum supported {@code LocalDate}, '-999999999-01-01'.

     * This could be used by an application as a "far past" date.

     */

    public static final LocalDate MIN = LocalDate.of(Year.MIN_VALUE, 1, 1);

    /**

     * The maximum supported {@code LocalDate}, '+999999999-12-31'.

     * This could be used by an application as a "far future" date.

     */

    public static final LocalDate MAX = LocalDate.of(Year.MAX_VALUE, 12, 31);

    /**

     * Serialization version.

     */

    private static final long serialVersionUID = 2942565459149668126L;

    /**

     * The number of days in a 400 year cycle.

     */

    private static final int DAYS_PER_CYCLE = 146097;

    /**

     * The number of days from year zero to year 1970.

     * There are five 400 year cycles from year zero to 2000.

     * There are 7 leap years from 1970 to 2000.

     */

    static final long DAYS_0000_TO_1970 = (DAYS_PER_CYCLE * 5L) - (30L * 365L + 7L);

    /**

     * The year.

     */

    private final int year;

    /**

     * The month-of-year.

     */

    private final short month;

    /**

     * The day-of-month.

     */

    private final short day;

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

    /**

     * Obtains the current date from the system clock in the default time-zone.

     * <p>

     * This will query the {@link Clock#systemDefaultZone() system clock} in the default

     * time-zone to obtain the current date.

     * <p>

     * Using this method will prevent the ability to use an alternate clock for testing

     * because the clock is hard-coded.

     *

     * @return the current date using the system clock and default time-zone, not null

     */

    public static LocalDate now() {

        return now(Clock.systemDefaultZone());

    }

    /**

     * Obtains the current date from the system clock in the specified time-zone.

     * <p>

     * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.

     * Specifying the time-zone avoids dependence on the default time-zone.

     * <p>

     * Using this method will prevent the ability to use an alternate clock for testing

     * because the clock is hard-coded.

     *

     * @param zone  the zone ID to use, not null

     * @return the current date using the system clock, not null

     */

    public static LocalDate now(ZoneId zone) {

        return now(Clock.system(zone));

    }

    /**

     * Obtains the current date from the specified clock.

     * <p>

     * This will query the specified clock to obtain the current date - today.

     * Using this method allows the use of an alternate clock for testing.

     * The alternate clock may be introduced using {@link Clock dependency injection}.

     *

     * @param clock  the clock to use, not null

     * @return the current date, not null

     */

    public static LocalDate now(Clock clock) {

        Objects.requireNonNull(clock, "clock");

        // inline to avoid creating object and Instant checks

        final Instant now = clock.instant();  // called once

        ZoneOffset offset = clock.getZone().getRules().getOffset(now);

        long epochSec = now.getEpochSecond() + offset.getTotalSeconds();  // overflow caught later

        long epochDay = Math.floorDiv(epochSec, SECONDS_PER_DAY);

        return LocalDate.ofEpochDay(epochDay);

    }

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

    /**

     * Obtains an instance of {@code LocalDate} from a year, month and day.

     * <p>

     * This returns a {@code LocalDate} with the specified year, month and day-of-month.

     * The day must be valid for the year and month, otherwise an exception will be thrown.

     *

     * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

     * @param month  the month-of-year to represent, not null

     * @param dayOfMonth  the day-of-month to represent, from 1 to 31

     * @return the local date, not null

     * @throws DateTimeException if the value of any field is out of range,

     *  or if the day-of-month is invalid for the month-year

     */

    public static LocalDate of(int year, Month month, int dayOfMonth) {

        YEAR.checkValidValue(year);

        Objects.requireNonNull(month, "month");

        DAY_OF_MONTH.checkValidValue(dayOfMonth);

        return create(year, month.getValue(), dayOfMonth);

    }

    /**

     * Obtains an instance of {@code LocalDate} from a year, month and day.

     * <p>

     * This returns a {@code LocalDate} with the specified year, month and day-of-month.

     * The day must be valid for the year and month, otherwise an exception will be thrown.

     *

     * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

     * @param month  the month-of-year to represent, from 1 (January) to 12 (December)

     * @param dayOfMonth  the day-of-month to represent, from 1 to 31

     * @return the local date, not null

     * @throws DateTimeException if the value of any field is out of range,

     *  or if the day-of-month is invalid for the month-year

     */

    public static LocalDate of(int year, int month, int dayOfMonth) {

        YEAR.checkValidValue(year);

        MONTH_OF_YEAR.checkValidValue(month);

        DAY_OF_MONTH.checkValidValue(dayOfMonth);

        return create(year, month, dayOfMonth);

    }

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

    /**

     * Obtains an instance of {@code LocalDate} from a year and day-of-year.

     * <p>

     * This returns a {@code LocalDate} with the specified year and day-of-year.

     * The day-of-year must be valid for the year, otherwise an exception will be thrown.

     *

     * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

     * @param dayOfYear  the day-of-year to represent, from 1 to 366

     * @return the local date, not null

     * @throws DateTimeException if the value of any field is out of range,

     *  or if the day-of-year is invalid for the month-year

     */

    public static LocalDate ofYearDay(int year, int dayOfYear) {

        YEAR.checkValidValue(year);

        DAY_OF_YEAR.checkValidValue(dayOfYear);

        boolean leap = IsoChronology.INSTANCE.isLeapYear(year);

        if (dayOfYear == 366 && leap == false) {

            throw new DateTimeException("Invalid date 'DayOfYear 366' as '" + year + "' is not a leap year");

        }

        Month moy = Month.of((dayOfYear - 1) / 31 + 1);

        int monthEnd = moy.firstDayOfYear(leap) + moy.length(leap) - 1;

        if (dayOfYear > monthEnd) {

            moy = moy.plus(1);

        }

        int dom = dayOfYear - moy.firstDayOfYear(leap) + 1;

        return new LocalDate(year, moy.getValue(), dom);

    }

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

    /**

     * Obtains an instance of {@code LocalDate} from the epoch day count.

     * <p>

     * This returns a {@code LocalDate} with the specified epoch-day.

     * The {@link ChronoField#EPOCH_DAY EPOCH_DAY} is a simple incrementing count

     * of days where day 0 is 1970-01-01. Negative numbers represent earlier days.

     *

     * @param epochDay  the Epoch Day to convert, based on the epoch 1970-01-01

     * @return the local date, not null

     * @throws DateTimeException if the epoch days exceeds the supported date range

     */

    public static LocalDate ofEpochDay(long epochDay) {

        long zeroDay = epochDay + DAYS_0000_TO_1970;

        // find the march-based year

        zeroDay -= 60;  // adjust to 0000-03-01 so leap day is at end of four year cycle

        long adjust = 0;

        if (zeroDay < 0) {

            // adjust negative years to positive for calculation

            long adjustCycles = (zeroDay + 1) / DAYS_PER_CYCLE - 1;

            adjust = adjustCycles * 400;

            zeroDay += -adjustCycles * DAYS_PER_CYCLE;

        }

        long yearEst = (400 * zeroDay + 591) / DAYS_PER_CYCLE;

        long doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);

        if (doyEst < 0) {

            // fix estimate

            yearEst--;

            doyEst = zeroDay - (365 * yearEst + yearEst / 4 - yearEst / 100 + yearEst / 400);

        }

        yearEst += adjust;  // reset any negative year

        int marchDoy0 = (int) doyEst;

        // convert march-based values back to january-based

        int marchMonth0 = (marchDoy0 * 5 + 2) / 153;

        int month = (marchMonth0 + 2) % 12 + 1;

        int dom = marchDoy0 - (marchMonth0 * 306 + 5) / 10 + 1;

        yearEst += marchMonth0 / 10;

        // check year now we are certain it is correct

        int year = YEAR.checkValidIntValue(yearEst);

        return new LocalDate(year, month, dom);

    }

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

    /**

     * Obtains an instance of {@code LocalDate} from a temporal object.

     * <p>

     * This obtains a local date based on the specified temporal.

     * A {@code TemporalAccessor} represents an arbitrary set of date and time information,

     * which this factory converts to an instance of {@code LocalDate}.

     * <p>

     * The conversion uses the {@link TemporalQuery#localDate()} query, which relies

     * on extracting the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field.

     * <p>

     * This method matches the signature of the functional interface {@link TemporalQuery}

     * allowing it to be used as a query via method reference, {@code LocalDate::from}.

     *

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

     * @return the local date, not null

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

     */

    public static LocalDate from(TemporalAccessor temporal) {

        LocalDate date = temporal.query(TemporalQuery.localDate());

        if (date == null) {

            throw new DateTimeException("Unable to obtain LocalDate from TemporalAccessor: " + temporal.getClass());

        }

        return date;

    }

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

    /**

     * Obtains an instance of {@code LocalDate} from a text string such as {@code 2007-12-03}.

     * <p>

     * The string must represent a valid date and is parsed using

     * {@link java.time.format.DateTimeFormatter#ISO_LOCAL_DATE}.

     *

     * @param text  the text to parse such as "2007-12-03", not null

     * @return the parsed local date, not null

     * @throws DateTimeParseException if the text cannot be parsed

     */

    public static LocalDate parse(CharSequence text) {

        return parse(text, DateTimeFormatter.ISO_LOCAL_DATE);

    }

    /**

     * Obtains an instance of {@code LocalDate} from a text string using a specific formatter.

     * <p>

     * The text is parsed using the formatter, returning a date.

     *

     * @param text  the text to parse, not null

     * @param formatter  the formatter to use, not null

     * @return the parsed local date, not null

     * @throws DateTimeParseException if the text cannot be parsed

     */

    public static LocalDate parse(CharSequence text, DateTimeFormatter formatter) {

        Objects.requireNonNull(formatter, "formatter");

        return formatter.parse(text, LocalDate::from);

    }

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

    /**

     * Creates a local date from the year, month and day fields.

     *

     * @param year  the year to represent, validated from MIN_YEAR to MAX_YEAR

     * @param month  the month-of-year to represent, from 1 to 12, validated

     * @param dayOfMonth  the day-of-month to represent, validated from 1 to 31

     * @return the local date, not null

     * @throws DateTimeException if the day-of-month is invalid for the month-year

     */

    private static LocalDate create(int year, int month, int dayOfMonth) {

        if (dayOfMonth > 28) {

            int dom = 31;

            switch (month) {

                case 2:

                    dom = (IsoChronology.INSTANCE.isLeapYear(year) ? 29 : 28);

                    break;

                case 4:

                case 6:

                case 9:

                case 11:

                    dom = 30;

                    break;

            }

            if (dayOfMonth > dom) {

                if (dayOfMonth == 29) {

                    throw new DateTimeException("Invalid date 'February 29' as '" + year + "' is not a leap year");

                } else {

                    throw new DateTimeException("Invalid date '" + Month.of(month).name() + " " + dayOfMonth + "'");

                }

            }

        }

        return new LocalDate(year, month, dayOfMonth);

    }

    /**

     * Resolves the date, resolving days past the end of month.

     *

     * @param year  the year to represent, validated from MIN_YEAR to MAX_YEAR

     * @param month  the month-of-year to represent, validated from 1 to 12

     * @param day  the day-of-month to represent, validated from 1 to 31

     * @return the resolved date, not null

     */

    private static LocalDate resolvePreviousValid(int year, int month, int day) {

        switch (month) {

            case 2:

                day = Math.min(day, IsoChronology.INSTANCE.isLeapYear(year) ? 29 : 28);

                break;

            case 4:

            case 6:

            case 9:

            case 11:

                day = Math.min(day, 30);

                break;

        }

        return new LocalDate(year, month, day);

    }

    /**

     * Constructor, previously validated.

     *

     * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

     * @param month  the month-of-year to represent, not null

     * @param dayOfMonth  the day-of-month to represent, valid for year-month, from 1 to 31

     */

    private LocalDate(int year, int month, int dayOfMonth) {

        this.year = year;

        this.month = (short) month;

        this.day = (short) dayOfMonth;

    }

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

    /**

     * Checks if the specified field is supported.

     * <p>

     * This checks if this date can be queried for the specified field.

     * If false, then calling the {@link #range(TemporalField) range} and

     * {@link #get(TemporalField) get} methods will throw an exception.

     * <p>

     * If the field is a {@link ChronoField} then the query is implemented here.

     * The supported fields are:

     * <ul>

     * <li>{@code DAY_OF_WEEK}

     * <li>{@code ALIGNED_DAY_OF_WEEK_IN_MONTH}

     * <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR}

     * <li>{@code DAY_OF_MONTH}

     * <li>{@code DAY_OF_YEAR}

     * <li>{@code EPOCH_DAY}

     * <li>{@code ALIGNED_WEEK_OF_MONTH}

     * <li>{@code ALIGNED_WEEK_OF_YEAR}

     * <li>{@code MONTH_OF_YEAR}

     * <li>{@code PROLEPTIC_MONTH}

     * <li>{@code YEAR_OF_ERA}

     * <li>{@code YEAR}

     * <li>{@code ERA}

     * </ul>

     * All other {@code ChronoField} instances will return false.

     * <p>

     * If the field is not a {@code ChronoField}, then the result of this method

     * is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}

     * passing {@code this} as the argument.

     * Whether the field is supported is determined by the field.

     *

     * @param field  the field to check, null returns false

     * @return true if the field is supported on this date, false if not

     */

    @Override  // override for Javadoc

    public boolean isSupported(TemporalField field) {

        return ChronoLocalDate.super.isSupported(field);

    }

    /**

     * Gets the range of valid values for the specified field.

     * <p>

     * The range object expresses the minimum and maximum valid values for a field.

     * This date is used to enhance the accuracy of the returned range.

     * If it is not possible to return the range, because the field is not supported

     * or for some other reason, an exception is thrown.

     * <p>

     * If the field is a {@link ChronoField} then the query is implemented here.

     * The {@link #isSupported(TemporalField) supported fields} will return

     * appropriate range instances.

     * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.

     * <p>

     * If the field is not a {@code ChronoField}, then the result of this method

     * is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)}

     * passing {@code this} as the argument.

     * Whether the range can be obtained is determined by the field.