/*

 * Copyright (c) 1996, 2017, 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.sql;

import java.time.Instant;

import java.time.LocalDateTime;

import jdk.internal.misc.SharedSecrets;

import jdk.internal.misc.JavaLangAccess;

/**

 * <P>A thin wrapper around {@code java.util.Date} that allows

 * the JDBC API to identify this as an SQL {@code TIMESTAMP} value.

 * It adds the ability

 * to hold the SQL {@code TIMESTAMP} fractional seconds value, by allowing

 * the specification of fractional seconds to a precision of nanoseconds.

 * A Timestamp also provides formatting and

 * parsing operations to support the JDBC escape syntax for timestamp values.

 *

 * <p>The precision of a Timestamp object is calculated to be either:

 * <ul>

 * <li>{@code 19 }, which is the number of characters in yyyy-mm-dd hh:mm:ss

 * <li> {@code  20 + s }, which is the number

 * of characters in the yyyy-mm-dd hh:mm:ss.[fff...] and {@code s} represents  the scale of the given Timestamp,

 * its fractional seconds precision.

 *</ul>

 *

 * <P><B>Note:</B> This type is a composite of a {@code java.util.Date} and a

 * separate nanoseconds value. Only integral seconds are stored in the

 * {@code java.util.Date} component. The fractional seconds - the nanos - are

 * separate.  The {@code Timestamp.equals(Object)} method never returns

 * {@code true} when passed an object

 * that isn't an instance of {@code java.sql.Timestamp},

 * because the nanos component of a date is unknown.

 * As a result, the {@code Timestamp.equals(Object)}

 * method is not symmetric with respect to the

 * {@code java.util.Date.equals(Object)}

 * method.  Also, the {@code hashCode} method uses the underlying

 * {@code java.util.Date}

 * implementation and therefore does not include nanos in its computation.

 * <P>

 * Due to the differences between the {@code Timestamp} class

 * and the {@code java.util.Date}

 * class mentioned above, it is recommended that code not view

 * {@code Timestamp} values generically as an instance of

 * {@code java.util.Date}.  The

 * inheritance relationship between {@code Timestamp}

 * and {@code java.util.Date} really

 * denotes implementation inheritance, and not type inheritance.

 *

 * @since 1.1

 */

public class Timestamp extends java.util.Date {

    private static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();

    /**

     * Constructs a {@code Timestamp} object initialized

     * with the given values.

     *

     * @param year the year minus 1900

     * @param month 0 to 11

     * @param date 1 to 31

     * @param hour 0 to 23

     * @param minute 0 to 59

     * @param second 0 to 59

     * @param nano 0 to 999,999,999

     * @deprecated instead use the constructor {@code Timestamp(long millis)}

     * @exception IllegalArgumentException if the nano argument is out of bounds

     */

    @Deprecated(since="1.2")

    public Timestamp(int year, int month, int date,

                     int hour, int minute, int second, int nano) {

        super(year, month, date, hour, minute, second);

        if (nano > 999999999 || nano < 0) {

            throw new IllegalArgumentException("nanos > 999999999 or < 0");

        }

        nanos = nano;

    }

    /**

     * Constructs a {@code Timestamp} object

     * using a milliseconds time value. The

     * integral seconds are stored in the underlying date value; the

     * fractional seconds are stored in the {@code nanos} field of

     * the {@code Timestamp} object.

     *

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

     *        A negative number is the number of milliseconds before

     *         January 1, 1970, 00:00:00 GMT.

     * @see java.util.Calendar

     */

    public Timestamp(long time) {

        super((time/1000)*1000);

        nanos = (int)((time%1000) * 1000000);

        if (nanos < 0) {

            nanos = 1000000000 + nanos;

            super.setTime(((time/1000)-1)*1000);

        }

    }

    /**

     * Sets this {@code Timestamp} object to represent a point in time that is

     * {@code time} milliseconds after January 1, 1970 00:00:00 GMT.

     *

     * @param time   the number of milliseconds.

     * @see #getTime

     * @see #Timestamp(long time)

     * @see java.util.Calendar

     */

    public void setTime(long time) {

        super.setTime((time/1000)*1000);

        nanos = (int)((time%1000) * 1000000);

        if (nanos < 0) {

            nanos = 1000000000 + nanos;

            super.setTime(((time/1000)-1)*1000);

        }

    }

    /**

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

     * represented by this {@code Timestamp} object.

     *

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

     *          represented by this date.

     * @see #setTime

     */

    public long getTime() {

        long time = super.getTime();

        return (time + (nanos / 1000000));

    }

    /**

     * @serial

     */

    private int nanos;

    /**

     * Converts a {@code String} object in JDBC timestamp escape format to a

     * {@code Timestamp} value.

     *

     * @param s timestamp in format {@code yyyy-[m]m-[d]d hh:mm:ss[.f...]}.  The

     * fractional seconds may be omitted. The leading zero for {@code mm}

     * and {@code dd} may also be omitted.

     *

     * @return corresponding {@code Timestamp} value

     * @exception java.lang.IllegalArgumentException if the given argument

     * does not have the format {@code yyyy-[m]m-[d]d hh:mm:ss[.f...]}

     */

    public static Timestamp valueOf(String s) {

        final int YEAR_LENGTH = 4;

        final int MONTH_LENGTH = 2;

        final int DAY_LENGTH = 2;

        final int MAX_MONTH = 12;

        final int MAX_DAY = 31;

        int year = 0;

        int month = 0;

        int day = 0;

        int hour;

        int minute;

        int second;

        int a_nanos = 0;

        int firstDash;

        int secondDash;

        int dividingSpace;

        int firstColon;

        int secondColon;

        int period;

        String formatError = "Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]";

        if (s == null) throw new java.lang.IllegalArgumentException("null string");

        // Split the string into date and time components

        s = s.trim();

        dividingSpace = s.indexOf(' ');

        if (dividingSpace < 0) {

            throw new java.lang.IllegalArgumentException(formatError);

        }

        // Parse the date

        firstDash = s.indexOf('-');

        secondDash = s.indexOf('-', firstDash+1);

        // Parse the time

        firstColon = s.indexOf(':', dividingSpace + 1);

        secondColon = s.indexOf(':', firstColon + 1);

        period = s.indexOf('.', secondColon + 1);

        // Convert the date

        boolean parsedDate = false;

        if (firstDash > 0 && secondDash > 0 && secondDash < dividingSpace - 1) {

            if (firstDash == YEAR_LENGTH &&

                    (secondDash - firstDash > 1 && secondDash - firstDash <= MONTH_LENGTH + 1) &&

                    (dividingSpace - secondDash > 1 && dividingSpace - secondDash <= DAY_LENGTH + 1)) {

                 year = Integer.parseInt(s, 0, firstDash, 10);

                 month = Integer.parseInt(s, firstDash + 1, secondDash, 10);

                 day = Integer.parseInt(s, secondDash + 1, dividingSpace, 10);

                if ((month >= 1 && month <= MAX_MONTH) && (day >= 1 && day <= MAX_DAY)) {

                    parsedDate = true;

                }

            }

        }

        if (! parsedDate) {

            throw new java.lang.IllegalArgumentException(formatError);

        }

        // Convert the time; default missing nanos

        int len = s.length();

        if (firstColon > 0 && secondColon > 0 && secondColon < len - 1) {

            hour = Integer.parseInt(s, dividingSpace + 1, firstColon, 10);

            minute = Integer.parseInt(s, firstColon + 1, secondColon, 10);

            if (period > 0 && period < len - 1) {

                second = Integer.parseInt(s, secondColon + 1, period, 10);

                int nanoPrecision = len - (period + 1);

                if (nanoPrecision > 9)

                    throw new java.lang.IllegalArgumentException(formatError);

                if (!Character.isDigit(s.charAt(period + 1)))

                    throw new java.lang.IllegalArgumentException(formatError);

                int tmpNanos = Integer.parseInt(s, period + 1, len, 10);

                while (nanoPrecision < 9) {

                    tmpNanos *= 10;

                    nanoPrecision++;

                }

                a_nanos = tmpNanos;

            } else if (period > 0) {

                throw new java.lang.IllegalArgumentException(formatError);

            } else {

                second = Integer.parseInt(s, secondColon + 1, len, 10);

            }

        } else {

            throw new java.lang.IllegalArgumentException(formatError);

        }

        return new Timestamp(year - 1900, month - 1, day, hour, minute, second, a_nanos);

    }

    /**

     * Formats a timestamp in JDBC timestamp escape format.

     *         {@code yyyy-mm-dd hh:mm:ss.fffffffff},

     * where {@code fffffffff} indicates nanoseconds.

     *

     * @return a {@code String} object in

     *           {@code yyyy-mm-dd hh:mm:ss.fffffffff} format

     */

    @SuppressWarnings("deprecation")

    public String toString() {

        int year = super.getYear() + 1900;

        int month = super.getMonth() + 1;

        int day = super.getDate();

        int hour = super.getHours();

        int minute = super.getMinutes();

        int second = super.getSeconds();

        int trailingZeros = 0;

        int tmpNanos = nanos;

        if (tmpNanos == 0) {

            trailingZeros = 8;

        } else {

            while (tmpNanos % 10 == 0) {

                tmpNanos /= 10;

                trailingZeros++;

            }

        }

        // 8058429: To comply with current JCK tests, we need to deal with year

        // being any number between 0 and 292278995

        int count = 10000;

        int yearSize = 4;

        do {

            if (year < count) {

                break;

            }

            yearSize++;

            count *= 10;

        } while (count < 1000000000);

        char[] buf = new char[25 + yearSize - trailingZeros];

        Date.formatDecimalInt(year, buf, 0, yearSize);

        buf[yearSize] = '-';

        Date.formatDecimalInt(month, buf, yearSize + 1, 2);

        buf[yearSize + 3] = '-';

        Date.formatDecimalInt(day, buf, yearSize + 4, 2);

        buf[yearSize + 6] = ' ';

        Date.formatDecimalInt(hour, buf, yearSize + 7, 2);

        buf[yearSize + 9] = ':';

        Date.formatDecimalInt(minute, buf, yearSize + 10, 2);

        buf[yearSize + 12] = ':';

        Date.formatDecimalInt(second, buf, yearSize + 13, 2);

        buf[yearSize + 15] = '.';

        Date.formatDecimalInt(tmpNanos, buf, yearSize + 16, 9 - trailingZeros);

        return jla.newStringUnsafe(buf);

    }

    /**

     * Gets this {@code Timestamp} object's {@code nanos} value.

     *

     * @return this {@code Timestamp} object's fractional seconds component

     * @see #setNanos

     */

    public int getNanos() {

        return nanos;

    }

    /**

     * Sets this {@code Timestamp} object's {@code nanos} field

     * to the given value.

     *

     * @param n the new fractional seconds component

     * @exception java.lang.IllegalArgumentException if the given argument

     *            is greater than 999999999 or less than 0

     * @see #getNanos

     */

    public void setNanos(int n) {

        if (n > 999999999 || n < 0) {

            throw new IllegalArgumentException("nanos > 999999999 or < 0");

        }

        nanos = n;

    }

    /**

     * Tests to see if this {@code Timestamp} object is

     * equal to the given {@code Timestamp} object.

     *

     * @param ts the {@code Timestamp} value to compare with

     * @return {@code true} if the given {@code Timestamp}

     *         object is equal to this {@code Timestamp} object;

     *         {@code false} otherwise

     */

    public boolean equals(Timestamp ts) {

        if (super.equals(ts)) {

            if  (nanos == ts.nanos) {

                return true;

            } else {

                return false;

            }

        } else {

            return false;

        }

    }

    /**

     * Tests to see if this {@code Timestamp} object is

     * equal to the given object.

     *

     * This version of the method {@code equals} has been added

     * to fix the incorrect

     * signature of {@code Timestamp.equals(Timestamp)} and to preserve backward

     * compatibility with existing class files.

     *

     * Note: This method is not symmetric with respect to the

     * {@code equals(Object)} method in the base class.

     *

     * @param ts the {@code Object} value to compare with

     * @return {@code true} if the given {@code Object} is an instance

     *         of a {@code Timestamp} that

     *         is equal to this {@code Timestamp} object;

     *         {@code false} otherwise

     */

    public boolean equals(java.lang.Object ts) {

      if (ts instanceof Timestamp) {

        return this.equals((Timestamp)ts);

      } else {

        return false;

      }

    }

    /**

     * Indicates whether this {@code Timestamp} object is

     * earlier than the given {@code Timestamp} object.

     *

     * @param ts the {@code Timestamp} value to compare with

     * @return {@code true} if this {@code Timestamp} object is earlier;

     *        {@code false} otherwise

     */

    public boolean before(Timestamp ts) {

        return compareTo(ts) < 0;

    }

    /**

     * Indicates whether this {@code Timestamp} object is

     * later than the given {@code Timestamp} object.

     *

     * @param ts the {@code Timestamp} value to compare with

     * @return {@code true} if this {@code Timestamp} object is later;

     *        {@code false} otherwise

     */

    public boolean after(Timestamp ts) {

        return compareTo(ts) > 0;

    }

    /**

     * Compares this {@code Timestamp} object to the given

     * {@code Timestamp} object.

     *

     * @param   ts   the {@code Timestamp} object to be compared to

     *                this {@code Timestamp} object

     * @return  the value {@code 0} if the two {@code Timestamp}

     *          objects are equal; a value less than {@code 0} if this

     *          {@code Timestamp} object is before the given argument;

     *          and a value greater than {@code 0} if this

     *          {@code Timestamp} object is after the given argument.

     * @since   1.4

     */

    public int compareTo(Timestamp ts) {

        long thisTime = this.getTime();

        long anotherTime = ts.getTime();

        int i = (thisTime<anotherTime ? -1 :(thisTime==anotherTime?0 :1));

        if (i == 0) {

            if (nanos > ts.nanos) {

                    return 1;

            } else if (nanos < ts.nanos) {

                return -1;

            }

        }

        return i;

    }

    /**

     * Compares this {@code Timestamp} object to the given

     * {@code Date} object.

     *

     * @param o the {@code Date} to be compared to

     *          this {@code Timestamp} object

     * @return  the value {@code 0} if this {@code Timestamp} object

     *          and the given object are equal; a value less than {@code 0}

     *          if this  {@code Timestamp} object is before the given argument;

     *          and a value greater than {@code 0} if this

     *          {@code Timestamp} object is after the given argument.

     *

     * @since   1.5

     */

    public int compareTo(java.util.Date o) {

       if(o instanceof Timestamp) {

            // When Timestamp instance compare it with a Timestamp

            // Hence it is basically calling this.compareTo((Timestamp))o);

            // Note typecasting is safe because o is instance of Timestamp

           return compareTo((Timestamp)o);

      } else {

            // When Date doing a o.compareTo(this)

            // will give wrong results.

          Timestamp ts = new Timestamp(o.getTime());

          return this.compareTo(ts);

      }

    }

    /**

     * {@inheritDoc}

     *

     * The {@code hashCode} method uses the underlying {@code java.util.Date}

     * implementation and therefore does not include nanos in its computation.

     *

     */

    @Override

    public int hashCode() {

        return super.hashCode();

    }

    static final long serialVersionUID = 2745179027874758501L;

    private static final int MILLIS_PER_SECOND = 1000;

    /**

     * Obtains an instance of {@code Timestamp} from a {@code LocalDateTime}

     * object, with the same year, month, day of month, hours, minutes,

     * seconds and nanos date-time value as the provided {@code LocalDateTime}.

     * <p>

     * The provided {@code LocalDateTime} is interpreted as the local

     * date-time in the local time zone.

     *

     * @param dateTime a {@code LocalDateTime} to convert

     * @return a {@code Timestamp} object

     * @exception NullPointerException if {@code dateTime} is null.

     * @since 1.8

     */

    @SuppressWarnings("deprecation")

    public static Timestamp valueOf(LocalDateTime dateTime) {

        return new Timestamp(dateTime.getYear() - 1900,

                             dateTime.getMonthValue() - 1,

                             dateTime.getDayOfMonth(),