/*

 * 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 build.tools.tzdb;

import static build.tools.tzdb.Utils.*;

import static build.tools.tzdb.LocalTime.SECONDS_PER_DAY;

import static build.tools.tzdb.ChronoField.DAY_OF_MONTH;

import static build.tools.tzdb.ChronoField.MONTH_OF_YEAR;

import static build.tools.tzdb.ChronoField.YEAR;

import java.util.Objects;

/**

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

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

 *

 * @since 1.8

 */

final class LocalDate {

    /**

     * 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 = new LocalDate(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 = new LocalDate(YEAR_MAX_VALUE, 12, 31);

    /**

     * 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 an instance of {@code LocalDate} from a year, month and day.

     * <p>

     * 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

     * @throws DateTimeException 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);

        if (dayOfMonth > 28 && dayOfMonth > lengthOfMonth(month, isLeapYear(year))) {

            if (dayOfMonth == 29) {

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

            } else {

                throw new DateTimeException("Invalid date '" + month + " " + dayOfMonth + "'");

            }

        }

        return new LocalDate(year, month, dayOfMonth);

    }

    /**

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

    }

    /**

     * Gets the year field.

     * <p>

     * This method returns the primitive {@code int} value for the year.

     * <p>

     * The year returned by this method is proleptic as per {@code get(YEAR)}.

     * To obtain the year-of-era, use {@code get(YEAR_OF_ERA}.

     *

     * @return the year, from MIN_YEAR to MAX_YEAR

     */

    public int getYear() {

        return year;

    }

    /**

     * Gets the month-of-year field as an int from 1 to 12.

     *

     * @return the month-of-year

     */

    public int getMonth() {

        return month;

    }

    /**

     * Gets the day-of-month field.

     * <p>

     * This method returns the primitive {@code int} value for the day-of-month.

     *

     * @return the day-of-month, from 1 to 31

     */

    public int getDayOfMonth() {

        return day;

    }

    /**

     * Gets the day-of-week field, which is an int from 1 to 7.

     *

     * @return the day-of-week

     */

    public int getDayOfWeek() {

        return (int)floorMod(toEpochDay() + 3, 7) + 1;

    }

    /**

     * Returns a copy of this {@code LocalDate} with the specified number of days added.

     * <p>

     * This method adds the specified amount to the days field incrementing the

     * month and year fields as necessary to ensure the result remains valid.

     * The result is only invalid if the maximum/minimum year is exceeded.

     * <p>

     * For example, 2008-12-31 plus one day would result in 2009-01-01.

     * <p>

     * This instance is immutable and unaffected by this method call.

     *

     * @param daysToAdd  the days to add, may be negative

     * @return a {@code LocalDate} based on this date with the days added, not null

     * @throws DateTimeException if the result exceeds the supported date range

     */

    public LocalDate plusDays(long daysToAdd) {

        if (daysToAdd == 0) {

            return this;

        }

        long mjDay = addExact(toEpochDay(), daysToAdd);

        return LocalDate.ofEpochDay(mjDay);

    }

    /**

     * Returns a copy of this {@code LocalDate} with the specified number of days subtracted.

     * <p>

     * This method subtracts the specified amount from the days field decrementing the

     * month and year fields as necessary to ensure the result remains valid.

     * The result is only invalid if the maximum/minimum year is exceeded.

     * <p>

     * For example, 2009-01-01 minus one day would result in 2008-12-31.

     * <p>

     * This instance is immutable and unaffected by this method call.

     *

     * @param daysToSubtract  the days to subtract, may be negative

     * @return a {@code LocalDate} based on this date with the days subtracted, not null

     * @throws DateTimeException if the result exceeds the supported date range

     */

    public LocalDate minusDays(long daysToSubtract) {

        return (daysToSubtract == Long.MIN_VALUE ? plusDays(Long.MAX_VALUE).plusDays(1) : plusDays(-daysToSubtract));

    }

    /**

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

     * <p>

     * The Epoch Day count 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.checkValidValue((int)yearEst);

        return new LocalDate(year, month, dom);

    }

    public long toEpochDay() {

        long y = year;

        long m = month;

        long total = 0;

        total += 365 * y;

        if (y >= 0) {

            total += (y + 3) / 4 - (y + 99) / 100 + (y + 399) / 400;

        } else {

            total -= y / -4 - y / -100 + y / -400;

        }

        total += ((367 * m - 362) / 12);

        total += day - 1;

        if (m > 2) {

            total--;

            if (isLeapYear(year) == false) {

                total--;

            }

        }

        return total - DAYS_0000_TO_1970;

    }

    /**

     * Compares this date to another date.

     * <p>

     * The comparison is primarily based on the date, from earliest to latest.

     * It is "consistent with equals", as defined by {@link Comparable}.

     * <p>

     * If all the dates being compared are instances of {@code LocalDate},

     * then the comparison will be entirely based on the date.

     * If some dates being compared are in different chronologies, then the

     * chronology is also considered, see {@link java.time.temporal.ChronoLocalDate#compareTo}.

     *

     * @param other  the other date to compare to, not null

     * @return the comparator value, negative if less, positive if greater

     */

    public int compareTo(LocalDate otherDate) {

        int cmp = (year - otherDate.year);

        if (cmp == 0) {

            cmp = (month - otherDate.month);

            if (cmp == 0) {

                cmp = (day - otherDate.day);

            }

        }

        return cmp;

    }

    /**

     * Checks if this date is equal to another date.

     * <p>

     * Compares this {@code LocalDate} with another ensuring that the date is the same.

     * <p>

     * Only objects of type {@code LocalDate} are compared, other types return false.

     * To compare the dates of two {@code TemporalAccessor} instances, including dates

     * in two different chronologies, use {@link ChronoField#EPOCH_DAY} as a comparator.

     *

     * @param obj  the object to check, null returns false

     * @return true if this is equal to the other date

     */

    @Override

    public boolean equals(Object obj) {

        if (this == obj) {

            return true;

        }

        if (obj instanceof LocalDate) {

            return compareTo((LocalDate) obj) == 0;

        }

        return false;

    }

    /**

     * A hash code for this date.

     *

     * @return a suitable hash code

     */

    @Override

    public int hashCode() {

        int yearValue = year;

        int monthValue = month;

        int dayValue = day;

        return (yearValue & 0xFFFFF800) ^ ((yearValue << 11) + (monthValue << 6) + (dayValue));

    }

}