/*

 * Copyright (c) 1994, 2019, 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.

 */

package java.util;

import java.text.DateFormat;

import java.time.LocalDate;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.io.ObjectInputStream;

import java.lang.ref.SoftReference;

import java.time.Instant;

import sun.util.calendar.BaseCalendar;

import sun.util.calendar.CalendarDate;

import sun.util.calendar.CalendarSystem;

import sun.util.calendar.CalendarUtils;

import sun.util.calendar.Era;

import sun.util.calendar.Gregorian;

import sun.util.calendar.ZoneInfo;

/**

 * The class {@code Date} represents a specific instant

 * in time, with millisecond precision.

 * <p>

 * Prior to JDK 1.1, the class {@code Date} had two additional

 * functions.  It allowed the interpretation of dates as year, month, day, hour,

 * minute, and second values.  It also allowed the formatting and parsing

 * of date strings.  Unfortunately, the API for these functions was not

 * amenable to internationalization.  As of JDK 1.1, the

 * {@code Calendar} class should be used to convert between dates and time

 * fields and the {@code DateFormat} class should be used to format and

 * parse date strings.

 * The corresponding methods in {@code Date} are deprecated.

 * <p>

 * Although the {@code Date} class is intended to reflect

 * coordinated universal time (UTC), it may not do so exactly,

 * depending on the host environment of the Java Virtual Machine.

 * Nearly all modern operating systems assume that 1 day =

 * 24 × 60 × 60 = 86400 seconds

 * in all cases. In UTC, however, about once every year or two there

 * is an extra second, called a "leap second." The leap

 * second is always added as the last second of the day, and always

 * on December 31 or June 30. For example, the last minute of the

 * year 1995 was 61 seconds long, thanks to an added leap second.

 * Most computer clocks are not accurate enough to be able to reflect

 * the leap-second distinction.

 * <p>

 * Some computer standards are defined in terms of Greenwich mean

 * time (GMT), which is equivalent to universal time (UT).  GMT is

 * the "civil" name for the standard; UT is the

 * "scientific" name for the same standard. The

 * distinction between UTC and UT is that UTC is based on an atomic

 * clock and UT is based on astronomical observations, which for all

 * practical purposes is an invisibly fine hair to split. Because the

 * earth's rotation is not uniform (it slows down and speeds up

 * in complicated ways), UT does not always flow uniformly. Leap

 * seconds are introduced as needed into UTC so as to keep UTC within

 * 0.9 seconds of UT1, which is a version of UT with certain

 * corrections applied. There are other time and date systems as

 * well; for example, the time scale used by the satellite-based

 * global positioning system (GPS) is synchronized to UTC but is

 * <i>not</i> adjusted for leap seconds. An interesting source of

 * further information is the United States Naval Observatory (USNO):

 * <blockquote><pre>

 *     <a href="https://www.usno.navy.mil/USNO">https://www.usno.navy.mil/USNO</a>

 * </pre></blockquote>

 * <p>

 * and the material regarding "Systems of Time" at:

 * <blockquote><pre>

 *     <a href="https://www.usno.navy.mil/USNO/time/master-clock/systems-of-time">https://www.usno.navy.mil/USNO/time/master-clock/systems-of-time</a>

 * </pre></blockquote>

 * <p>

 * which has descriptions of various different time systems including

 * UT, UT1, and UTC.

 * <p>

 * In all methods of class {@code Date} that accept or return

 * year, month, date, hours, minutes, and seconds values, the

 * following representations are used:

 * <ul>

 * <li>A year <i>y</i> is represented by the integer

 *     <i>y</i>&nbsp;{@code - 1900}.

 * <li>A month is represented by an integer from 0 to 11; 0 is January,

 *     1 is February, and so forth; thus 11 is December.

 * <li>A date (day of month) is represented by an integer from 1 to 31

 *     in the usual manner.

 * <li>An hour is represented by an integer from 0 to 23. Thus, the hour

 *     from midnight to 1 a.m. is hour 0, and the hour from noon to 1

 *     p.m. is hour 12.

 * <li>A minute is represented by an integer from 0 to 59 in the usual manner.

 * <li>A second is represented by an integer from 0 to 61; the values 60 and

 *     61 occur only for leap seconds and even then only in Java

 *     implementations that actually track leap seconds correctly. Because

 *     of the manner in which leap seconds are currently introduced, it is

 *     extremely unlikely that two leap seconds will occur in the same

 *     minute, but this specification follows the date and time conventions

 *     for ISO C.

 * </ul>

 * <p>

 * In all cases, arguments given to methods for these purposes need

 * not fall within the indicated ranges; for example, a date may be

 * specified as January 32 and is interpreted as meaning February 1.

 *

 * @author  James Gosling

 * @author  Arthur van Hoff

 * @author  Alan Liu

 * @see     java.text.DateFormat

 * @see     java.util.Calendar

 * @see     java.util.TimeZone

 * @since   1.0

 */

public class Date

    implements java.io.Serializable, Cloneable, Comparable<Date>

{

    private static final BaseCalendar gcal =

                                CalendarSystem.getGregorianCalendar();

    private static BaseCalendar jcal;

    private transient long fastTime;

    /*

     * If cdate is null, then fastTime indicates the time in millis.

     * If cdate.isNormalized() is true, then fastTime and cdate are in

     * synch. Otherwise, fastTime is ignored, and cdate indicates the

     * time.

     */

    private transient BaseCalendar.Date cdate;

    // Initialized just before the value is used. See parse().

    private static int defaultCenturyStart;

    /* use serialVersionUID from modified java.util.Date for

     * interoperability with JDK1.1. The Date was modified to write

     * and read only the UTC time.

     */

    @java.io.Serial

    private static final long serialVersionUID = 7523967970034938905L;

    /**

     * Allocates a {@code Date} object and initializes it so that

     * it represents the time at which it was allocated, measured to the

     * nearest millisecond.

     *

     * @see     java.lang.System#currentTimeMillis()

     */

    public Date() {

        this(System.currentTimeMillis());

    }

    /**

     * Allocates a {@code Date} object and initializes it to

     * represent the specified number of milliseconds since the

     * standard base time known as "the epoch", namely January 1,

     * 1970, 00:00:00 GMT.

     *

     * @param   date   the milliseconds since January 1, 1970, 00:00:00 GMT.

     * @see     java.lang.System#currentTimeMillis()

     */

    public Date(long date) {

        fastTime = date;

    }

    /**

     * Allocates a {@code Date} object and initializes it so that

     * it represents midnight, local time, at the beginning of the day

     * specified by the {@code year}, {@code month}, and

     * {@code date} arguments.

     *

     * @param   year    the year minus 1900.

     * @param   month   the month between 0-11.

     * @param   date    the day of the month between 1-31.

     * @see     java.util.Calendar

     * @deprecated As of JDK version 1.1,

     * replaced by {@code Calendar.set(year + 1900, month, date)}

     * or {@code GregorianCalendar(year + 1900, month, date)}.

     */

    @Deprecated

    public Date(int year, int month, int date) {

        this(year, month, date, 0, 0, 0);

    }

    /**

     * Allocates a {@code Date} object and initializes it so that

     * it represents the instant at the start of the minute specified by

     * the {@code year}, {@code month}, {@code date},

     * {@code hrs}, and {@code min} arguments, in the local

     * time zone.

     *

     * @param   year    the year minus 1900.

     * @param   month   the month between 0-11.

     * @param   date    the day of the month between 1-31.

     * @param   hrs     the hours between 0-23.

     * @param   min     the minutes between 0-59.

     * @see     java.util.Calendar

     * @deprecated As of JDK version 1.1,

     * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min)}

     * or {@code GregorianCalendar(year + 1900, month, date, hrs, min)}.

     */

    @Deprecated

    public Date(int year, int month, int date, int hrs, int min) {

        this(year, month, date, hrs, min, 0);

    }

    /**

     * Allocates a {@code Date} object and initializes it so that

     * it represents the instant at the start of the second specified

     * by the {@code year}, {@code month}, {@code date},

     * {@code hrs}, {@code min}, and {@code sec} arguments,

     * in the local time zone.

     *

     * @param   year    the year minus 1900.

     * @param   month   the month between 0-11.

     * @param   date    the day of the month between 1-31.

     * @param   hrs     the hours between 0-23.

     * @param   min     the minutes between 0-59.

     * @param   sec     the seconds between 0-59.

     * @see     java.util.Calendar

     * @deprecated As of JDK version 1.1,

     * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min, sec)}

     * or {@code GregorianCalendar(year + 1900, month, date, hrs, min, sec)}.

     */

    @Deprecated

    public Date(int year, int month, int date, int hrs, int min, int sec) {

        int y = year + 1900;

        // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.

        if (month >= 12) {

            y += month / 12;

            month %= 12;

        } else if (month < 0) {

            y += CalendarUtils.floorDivide(month, 12);

            month = CalendarUtils.mod(month, 12);

        }

        BaseCalendar cal = getCalendarSystem(y);

        cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef());

        cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0);

        getTimeImpl();

        cdate = null;

    }

    /**

     * Allocates a {@code Date} object and initializes it so that

     * it represents the date and time indicated by the string

     * {@code s}, which is interpreted as if by the

     * {@link Date#parse} method.

     *

     * @param   s   a string representation of the date.

     * @see     java.text.DateFormat

     * @see     java.util.Date#parse(java.lang.String)

     * @deprecated As of JDK version 1.1,

     * replaced by {@code DateFormat.parse(String s)}.

     */

    @Deprecated

    public Date(String s) {

        this(parse(s));

    }

    /**

     * Return a copy of this object.

     */

    public Object clone() {

        Date d = null;

        try {

            d = (Date)super.clone();

            if (cdate != null) {

                d.cdate = (BaseCalendar.Date) cdate.clone();

            }

        } catch (CloneNotSupportedException e) {} // Won't happen

        return d;

    }

    /**

     * Determines the date and time based on the arguments. The

     * arguments are interpreted as a year, month, day of the month,

     * hour of the day, minute within the hour, and second within the

     * minute, exactly as for the {@code Date} constructor with six

     * arguments, except that the arguments are interpreted relative

     * to UTC rather than to the local time zone. The time indicated is

     * returned represented as the distance, measured in milliseconds,

     * of that time from the epoch (00:00:00 GMT on January 1, 1970).

     *

     * @param   year    the year minus 1900.

     * @param   month   the month between 0-11.

     * @param   date    the day of the month between 1-31.

     * @param   hrs     the hours between 0-23.

     * @param   min     the minutes between 0-59.

     * @param   sec     the seconds between 0-59.

     * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT for

     *          the date and time specified by the arguments.

     * @see     java.util.Calendar

     * @deprecated As of JDK version 1.1,

     * replaced by {@code Calendar.set(year + 1900, month, date, hrs, min, sec)}

     * or {@code GregorianCalendar(year + 1900, month, date, hrs, min, sec)}, using a UTC

     * {@code TimeZone}, followed by {@code Calendar.getTime().getTime()}.

     */

    @Deprecated

    public static long UTC(int year, int month, int date,

                           int hrs, int min, int sec) {

        int y = year + 1900;

        // month is 0-based. So we have to normalize month to support Long.MAX_VALUE.

        if (month >= 12) {

            y += month / 12;

            month %= 12;

        } else if (month < 0) {

            y += CalendarUtils.floorDivide(month, 12);

            month = CalendarUtils.mod(month, 12);

        }

        int m = month + 1;

        BaseCalendar cal = getCalendarSystem(y);

        BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null);

        udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0);

        // Use a Date instance to perform normalization. Its fastTime

        // is the UTC value after the normalization.

        Date d = new Date(0);

        d.normalize(udate);

        return d.fastTime;

    }

    /**

     * Attempts to interpret the string {@code s} as a representation

     * of a date and time. If the attempt is successful, the time

     * indicated is returned represented as the distance, measured in

     * milliseconds, of that time from the epoch (00:00:00 GMT on

     * January 1, 1970). If the attempt fails, an

     * {@code IllegalArgumentException} is thrown.

     * <p>

     * It accepts many syntaxes; in particular, it recognizes the IETF

     * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also

     * understands the continental U.S. time-zone abbreviations, but for

     * general use, a time-zone offset should be used: "Sat, 12 Aug 1995

     * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich

     * meridian). If no time zone is specified, the local time zone is

     * assumed. GMT and UTC are considered equivalent.

     * <p>

     * The string {@code s} is processed from left to right, looking for

     * data of interest. Any material in {@code s} that is within the

     * ASCII parenthesis characters {@code (} and {@code )} is ignored.

     * Parentheses may be nested. Otherwise, the only characters permitted

     * within {@code s} are these ASCII characters:

     * <blockquote><pre>

     * abcdefghijklmnopqrstuvwxyz

     * ABCDEFGHIJKLMNOPQRSTUVWXYZ

     * 0123456789,+-:/</pre></blockquote>

     * and whitespace characters.<p>

     * A consecutive sequence of decimal digits is treated as a decimal

     * number:<ul>

     * <li>If a number is preceded by {@code +} or {@code -} and a year

     *     has already been recognized, then the number is a time-zone

     *     offset. If the number is less than 24, it is an offset measured

     *     in hours. Otherwise, it is regarded as an offset in minutes,

     *     expressed in 24-hour time format without punctuation. A

     *     preceding {@code -} means a westward offset. Time zone offsets

     *     are always relative to UTC (Greenwich). Thus, for example,

     *     {@code -5} occurring in the string would mean "five hours west

     *     of Greenwich" and {@code +0430} would mean "four hours and

     *     thirty minutes east of Greenwich." It is permitted for the

     *     string to specify {@code GMT}, {@code UT}, or {@code UTC}

     *     redundantly-for example, {@code GMT-5} or {@code utc+0430}.

     * <li>The number is regarded as a year number if one of the

     *     following conditions is true:

     * <ul>

     *     <li>The number is equal to or greater than 70 and followed by a

     *         space, comma, slash, or end of string

     *     <li>The number is less than 70, and both a month and a day of

     *         the month have already been recognized</li>

     * </ul>

     *     If the recognized year number is less than 100, it is

     *     interpreted as an abbreviated year relative to a century of

     *     which dates are within 80 years before and 19 years after

     *     the time when the Date class is initialized.

     *     After adjusting the year number, 1900 is subtracted from

     *     it. For example, if the current year is 1999 then years in

     *     the range 19 to 99 are assumed to mean 1919 to 1999, while

     *     years from 0 to 18 are assumed to mean 2000 to 2018.  Note

     *     that this is slightly different from the interpretation of

     *     years less than 100 that is used in {@link java.text.SimpleDateFormat}.

     * <li>If the number is followed by a colon, it is regarded as an hour,

     *     unless an hour has already been recognized, in which case it is

     *     regarded as a minute.

     * <li>If the number is followed by a slash, it is regarded as a month

     *     (it is decreased by 1 to produce a number in the range {@code 0}

     *     to {@code 11}), unless a month has already been recognized, in

     *     which case it is regarded as a day of the month.

     * <li>If the number is followed by whitespace, a comma, a hyphen, or

     *     end of string, then if an hour has been recognized but not a

     *     minute, it is regarded as a minute; otherwise, if a minute has

     *     been recognized but not a second, it is regarded as a second;

     *     otherwise, it is regarded as a day of the month. </ul><p>

     * A consecutive sequence of letters is regarded as a word and treated

     * as follows:<ul>

     * <li>A word that matches {@code AM}, ignoring case, is ignored (but

     *     the parse fails if an hour has not been recognized or is less

     *     than {@code 1} or greater than {@code 12}).

     * <li>A word that matches {@code PM}, ignoring case, adds {@code 12}

     *     to the hour (but the parse fails if an hour has not been

     *     recognized or is less than {@code 1} or greater than {@code 12}).

     * <li>Any word that matches any prefix of {@code SUNDAY, MONDAY, TUESDAY,

     *     WEDNESDAY, THURSDAY, FRIDAY}, or {@code SATURDAY}, ignoring

     *     case, is ignored. For example, {@code sat, Friday, TUE}, and

     *     {@code Thurs} are ignored.

     * <li>Otherwise, any word that matches any prefix of {@code JANUARY,

     *     FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER,

     *     OCTOBER, NOVEMBER}, or {@code DECEMBER}, ignoring case, and

     *     considering them in the order given here, is recognized as

     *     specifying a month and is converted to a number ({@code 0} to

     *     {@code 11}). For example, {@code aug, Sept, april}, and

     *     {@code NOV} are recognized as months. So is {@code Ma}, which

     *     is recognized as {@code MARCH}, not {@code MAY}.

     * <li>Any word that matches {@code GMT, UT}, or {@code UTC}, ignoring

     *     case, is treated as referring to UTC.

     * <li>Any word that matches {@code EST, CST, MST}, or {@code PST},

     *     ignoring case, is recognized as referring to the time zone in

     *     North America that is five, six, seven, or eight hours west of

     *     Greenwich, respectively. Any word that matches {@code EDT, CDT,

     *     MDT}, or {@code PDT}, ignoring case, is recognized as

     *     referring to the same time zone, respectively, during daylight

     *     saving time.</ul><p>

     * Once the entire string s has been scanned, it is converted to a time

     * result in one of two ways. If a time zone or time-zone offset has been

     * recognized, then the year, month, day of month, hour, minute, and

     * second are interpreted in UTC and then the time-zone offset is

     * applied. Otherwise, the year, month, day of month, hour, minute, and

     * second are interpreted in the local time zone.

     *

     * @param   s   a string to be parsed as a date.

     * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT

     *          represented by the string argument.

     * @see     java.text.DateFormat

     * @deprecated As of JDK version 1.1,

     * replaced by {@code DateFormat.parse(String s)}.

     */

    @Deprecated

    public static long parse(String s) {

        int year = Integer.MIN_VALUE;

        int mon = -1;

        int mday = -1;

        int hour = -1;

        int min = -1;

        int sec = -1;

        int millis = -1;

        int c = -1;

        int i = 0;

        int n = -1;

        int wst = -1;

        int tzoffset = -1;

        int prevc = 0;

    syntax:

        {

            if (s == null)

                break syntax;

            int limit = s.length();

            while (i < limit) {

                c = s.charAt(i);

                i++;

                if (c <= ' ' || c == ',')

                    continue;

                if (c == '(') { // skip comments

                    int depth = 1;

                    while (i < limit) {

                        c = s.charAt(i);

                        i++;

                        if (c == '(') depth++;

                        else if (c == ')')

                            if (--depth <= 0)

                                break;

                    }

                    continue;

                }

                if ('0' <= c && c <= '9') {

                    n = c - '0';

                    while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') {

                        n = n * 10 + c - '0';

                        i++;

                    }

                    if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) {

                        // timezone offset

                        if (n < 24)

                            n = n * 60; // EG. "GMT-3"

                        else

                            n = n % 100 + n / 100 * 60; // eg "GMT-0430"

                        if (prevc == '+')   // plus means east of GMT

                            n = -n;

                        if (tzoffset != 0 && tzoffset != -1)

                            break syntax;

                        tzoffset = n;

                    } else if (n >= 70)

                        if (year != Integer.MIN_VALUE)

                            break syntax;

                        else if (c <= ' ' || c == ',' || c == '/' || i >= limit)

                            // year = n < 1900 ? n : n - 1900;

                            year = n;

                        else

                            break syntax;

                    else if (c == ':')

                        if (hour < 0)