/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qplatformdefs.h"

#include "private/qdatetime_p.h"

#include "qdatastream.h"

#include "qset.h"

#include "qlocale.h"

#include "qdatetime.h"

#include "qregexp.h"

#include "qdebug.h"

#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)

#include <qt_windows.h>

#endif

#ifndef Q_WS_WIN

#include <locale.h>

#endif

#include <time.h>

#if defined(Q_OS_WINCE)

#include "qfunctions_wince.h"

#endif

//#define QDATETIMEPARSER_DEBUG

#if defined (QDATETIMEPARSER_DEBUG) && !defined(QT_NO_DEBUG_STREAM)

#  define QDTPDEBUG qDebug() << QString("%1:%2").arg(__FILE__).arg(__LINE__)

#  define QDTPDEBUGN qDebug

#else

#  define QDTPDEBUG if (false) qDebug()

#  define QDTPDEBUGN if (false) qDebug

#endif

#if defined(Q_WS_MAC)

#include <private/qcore_mac_p.h>

#endif

#if defined(Q_OS_SYMBIAN)

#include <e32std.h>

#endif

QT_BEGIN_NAMESPACE

enum {

    FIRST_YEAR = -4713,

    FIRST_MONTH = 1,

    FIRST_DAY = 2,  // ### Qt 5: make FIRST_DAY = 1, by support jd == 0 as valid

    SECS_PER_DAY = 86400,

    MSECS_PER_DAY = 86400000,

    SECS_PER_HOUR = 3600,

    MSECS_PER_HOUR = 3600000,

    SECS_PER_MIN = 60,

    MSECS_PER_MIN = 60000,

    JULIAN_DAY_FOR_EPOCH = 2440588 // result of julianDayFromGregorianDate(1970, 1, 1)

};

static inline QDate fixedDate(int y, int m, int d)

{

    QDate result(y, m, 1);

    result.setDate(y, m, qMin(d, result.daysInMonth()));

    return result;

}

static inline uint julianDayFromGregorianDate(int year, int month, int day)

{

    // Gregorian calendar starting from October 15, 1582

    // Algorithm from Henry F. Fliegel and Thomas C. Van Flandern

    return (1461 * (year + 4800 + (month - 14) / 12)) / 4

           + (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12

           - (3 * ((year + 4900 + (month - 14) / 12) / 100)) / 4

           + day - 32075;

}

static uint julianDayFromDate(int year, int month, int day)

{

    if (year < 0)

        ++year;

    if (year > 1582 || (year == 1582 && (month > 10 || (month == 10 && day >= 15)))) {

        return julianDayFromGregorianDate(year, month, day);

    } else if (year < 1582 || (year == 1582 && (month < 10 || (month == 10 && day <= 4)))) {

        // Julian calendar until October 4, 1582

        // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering

        int a = (14 - month) / 12;

        return (153 * (month + (12 * a) - 3) + 2) / 5

               + (1461 * (year + 4800 - a)) / 4

               + day - 32083;

    } else {

        // the day following October 4, 1582 is October 15, 1582

        return 0;

    }

}

static void getDateFromJulianDay(uint julianDay, int *year, int *month, int *day)

{

    int y, m, d;

    if (julianDay >= 2299161) {

        // Gregorian calendar starting from October 15, 1582

        // This algorithm is from Henry F. Fliegel and Thomas C. Van Flandern

        qulonglong ell, n, i, j;

        ell = qulonglong(julianDay) + 68569;

        n = (4 * ell) / 146097;

        ell = ell - (146097 * n + 3) / 4;

        i = (4000 * (ell + 1)) / 1461001;

        ell = ell - (1461 * i) / 4 + 31;

        j = (80 * ell) / 2447;

        d = ell - (2447 * j) / 80;

        ell = j / 11;

        m = j + 2 - (12 * ell);

        y = 100 * (n - 49) + i + ell;

    } else {

        // Julian calendar until October 4, 1582

        // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering

        julianDay += 32082;

        int dd = (4 * julianDay + 3) / 1461;

        int ee = julianDay - (1461 * dd) / 4;

        int mm = ((5 * ee) + 2) / 153;

        d = ee - (153 * mm + 2) / 5 + 1;

        m = mm + 3 - 12 * (mm / 10);

        y = dd - 4800 + (mm / 10);

        if (y <= 0)

            --y;

    }

    if (year)

        *year = y;

    if (month)

        *month = m;

    if (day)

        *day = d;

}

static const char monthDays[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

#ifndef QT_NO_TEXTDATE

static const char * const qt_shortMonthNames[] = {

    "Jan", "Feb", "Mar", "Apr", "May", "Jun",

    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

#endif

#ifndef QT_NO_DATESTRING

static QString fmtDateTime(const QString& f, const QTime* dt = 0, const QDate* dd = 0);

#endif

/*****************************************************************************

  QDate member functions

 *****************************************************************************/

/*!

    \since 4.5

    \enum QDate::MonthNameType

    This enum describes the types of the string representation used

    for the month name.

    \value DateFormat This type of name can be used for date-to-string formatting.

    \value StandaloneFormat This type is used when you need to enumerate months or weekdays.

           Usually standalone names are represented in singular forms with

           capitalized first letter.

*/

/*!

    \class QDate

    \reentrant

    \brief The QDate class provides date functions.

    A QDate object contains a calendar date, i.e. year, month, and day

    numbers, in the Gregorian calendar. (see \l{QDate G and J} {Use of

    Gregorian and Julian Calendars} for dates prior to 15 October

    1582). It can read the current date from the system clock. It

    provides functions for comparing dates, and for manipulating

    dates. For example, it is possible to add and subtract days,

    months, and years to dates.

    A QDate object is typically created either by giving the year,

    month, and day numbers explicitly. Note that QDate interprets two

    digit years as is, i.e., years 0 - 99. A QDate can also be

    constructed with the static function currentDate(), which creates

    a QDate object containing the system clock's date.  An explicit

    date can also be set using setDate(). The fromString() function

    returns a QDate given a string and a date format which is used to

    interpret the date within the string.

    The year(), month(), and day() functions provide access to the

    year, month, and day numbers. Also, dayOfWeek() and dayOfYear()

    functions are provided. The same information is provided in

    textual format by the toString(), shortDayName(), longDayName(),

    shortMonthName(), and longMonthName() functions.

    QDate provides a full set of operators to compare two QDate

    objects where smaller means earlier, and larger means later.

    You can increment (or decrement) a date by a given number of days

    using addDays(). Similarly you can use addMonths() and addYears().

    The daysTo() function returns the number of days between two

    dates.

    The daysInMonth() and daysInYear() functions return how many days

    there are in this date's month and year, respectively. The

    isLeapYear() function indicates whether a date is in a leap year.

    \section1

    \target QDate G and J

    \section2 Use of Gregorian and Julian Calendars

    QDate uses the Gregorian calendar in all locales, beginning

    on the date 15 October 1582. For dates up to and including 4

    October 1582, the Julian calendar is used.  This means there is a

    10-day gap in the internal calendar between the 4th and the 15th

    of October 1582. When you use QDateTime for dates in that epoch,

    the day after 4 October 1582 is 15 October 1582, and the dates in

    the gap are invalid.

    The Julian to Gregorian changeover date used here is the date when

    the Gregorian calendar was first introduced, by Pope Gregory

    XIII. That change was not universally accepted and some localities

    only executed it at a later date (if at all).  QDateTime

    doesn't take any of these historical facts into account. If an

    application must support a locale-specific dating system, it must

    do so on its own, remembering to convert the dates using the

    Julian day.

    \section2 No Year 0

    There is no year 0. Dates in that year are considered invalid. The

    year -1 is the year "1 before Christ" or "1 before current era."

    The day before 0001-01-01 is December 31st, 1 BCE.

    \section2 Range of Valid Dates

    The range of valid dates is from January 2nd, 4713 BCE, to

    sometime in the year 11 million CE. The Julian Day returned by

    QDate::toJulianDay() is a number in the contiguous range from 1 to

    \e{overflow}, even across QDateTime's "date holes". It is suitable

    for use in applications that must convert a QDateTime to a date in

    another calendar system, e.g., Hebrew, Islamic or Chinese.

    \sa QTime, QDateTime, QDateEdit, QDateTimeEdit, QCalendarWidget

*/

/*!

    \fn QDate::QDate()

    Constructs a null date. Null dates are invalid.

    \sa isNull(), isValid()

*/

/*!

    Constructs a date with year \a y, month \a m and day \a d.

    If the specified date is invalid, the date is not set and

    isValid() returns false. A date before 2 January 4713 B.C. is

    considered invalid.

    \warning Years 0 to 99 are interpreted as is, i.e., years

             0-99.

    \sa isValid()

*/

QDate::QDate(int y, int m, int d)

{

    setDate(y, m, d);

}

/*!

    \fn bool QDate::isNull() const

    Returns true if the date is null; otherwise returns false. A null

    date is invalid.

    \note The behavior of this function is equivalent to isValid().

    \sa isValid()

*/

/*!

    Returns true if this date is valid; otherwise returns false.

    \sa isNull()

*/

bool QDate::isValid() const

{

    return !isNull();

}

/*!

    Returns the year of this date. Negative numbers indicate years

    before 1 A.D. = 1 C.E., such that year -44 is 44 B.C.

    \sa month(), day()

*/

int QDate::year() const

{

    int y;

    getDateFromJulianDay(jd, &y, 0, 0);

    return y;

}

/*!

    Returns the number corresponding to the month of this date, using

    the following convention:

    \list

    \i 1 = "January"

    \i 2 = "February"

    \i 3 = "March"

    \i 4 = "April"

    \i 5 = "May"

    \i 6 = "June"

    \i 7 = "July"

    \i 8 = "August"

    \i 9 = "September"

    \i 10 = "October"

    \i 11 = "November"

    \i 12 = "December"

    \endlist

    \sa year(), day()

*/

int QDate::month() const

{

    int m;

    getDateFromJulianDay(jd, 0, &m, 0);

    return m;

}

/*!

    Returns the day of the month (1 to 31) of this date.

    \sa year(), month(), dayOfWeek()

*/

int QDate::day() const

{

    int d;

    getDateFromJulianDay(jd, 0, 0, &d);

    return d;

}

/*!

    Returns the weekday (1 to 7) for this date.

    \sa day(), dayOfYear(), Qt::DayOfWeek

*/

int QDate::dayOfWeek() const

{

    return (jd % 7) + 1;

}

/*!

    Returns the day of the year (1 to 365 or 366 on leap years) for

    this date.

    \sa day(), dayOfWeek()

*/

int QDate::dayOfYear() const

{

    return jd - julianDayFromDate(year(), 1, 1) + 1;

}

/*!

    Returns the number of days in the month (28 to 31) for this date.

    \sa day(), daysInYear()

*/

int QDate::daysInMonth() const

{

    int y, m, d;

    getDateFromJulianDay(jd, &y, &m, &d);

    if (m == 2 && isLeapYear(y))

        return 29;

    else

        return monthDays[m];

}

/*!

    Returns the number of days in the year (365 or 366) for this date.

    \sa day(), daysInMonth()

*/

int QDate::daysInYear() const

{

    int y, m, d;

    getDateFromJulianDay(jd, &y, &m, &d);

    return isLeapYear(y) ? 366 : 365;

}

/*!

    Returns the week number (1 to 53), and stores the year in

    *\a{yearNumber} unless \a yearNumber is null (the default).

    Returns 0 if the date is invalid.

    In accordance with ISO 8601, weeks start on Monday and the first

    Thursday of a year is always in week 1 of that year. Most years

    have 52 weeks, but some have 53.

    *\a{yearNumber} is not always the same as year(). For example, 1

    January 2000 has week number 52 in the year 1999, and 31 December

    2002 has week number 1 in the year 2003.

    \legalese

    Copyright (c) 1989 The Regents of the University of California.

    All rights reserved.

    Redistribution and use in source and binary forms are permitted

    provided that the above copyright notice and this paragraph are

    duplicated in all such forms and that any documentation,

    advertising materials, and other materials related to such

    distribution and use acknowledge that the software was developed

    by the University of California, Berkeley.  The name of the

    University may not be used to endorse or promote products derived

    from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR

    IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

    \sa isValid()

*/

int QDate::weekNumber(int *yearNumber) const

{

    if (!isValid())

        return 0;

    int year = QDate::year();

    int yday = dayOfYear() - 1;

    int wday = dayOfWeek();

    if (wday == 7)

        wday = 0;

    int w;

    for (;;) {

        int len;

        int bot;

        int top;

        len = isLeapYear(year) ? 366 : 365;

        /*

        ** What yday (-3 ... 3) does

        ** the ISO year begin on?

        */

        bot = ((yday + 11 - wday) % 7) - 3;

        /*

        ** What yday does the NEXT

        ** ISO year begin on?

        */

        top = bot - (len % 7);

        if (top < -3)

            top += 7;

        top += len;

        if (yday >= top) {

            ++year;

            w = 1;

            break;

        }

        if (yday >= bot) {

            w = 1 + ((yday - bot) / 7);

            break;

        }

        --year;

        yday += isLeapYear(year) ? 366 : 365;

    }

    if (yearNumber != 0)

        *yearNumber = year;

    return w;

}

#ifndef QT_NO_TEXTDATE

/*!

    \since 4.5

    Returns the short name of the \a month for the representation specified

    by \a type.