/*

 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)

 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

 * Copyright (C) 2009 Google Inc. All rights reserved.

 *

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is Mozilla Communicator client code, released

 * March 31, 1998.

 *

 * The Initial Developer of the Original Code is

 * Netscape Communications Corporation.

 * Portions created by the Initial Developer are Copyright (C) 1998

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *

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

 * either of the GNU General Public License Version 2 or later (the "GPL"),

 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 */

#ifndef DateMath_h

#define DateMath_h

#include <math.h>

#include <string.h>

#include <time.h>

#include <wtf/CurrentTime.h>

#include <wtf/Noncopyable.h>

#include <wtf/UnusedParam.h>

namespace WTF {

void initializeDates();

int equivalentYearForDST(int year);

// Not really math related, but this is currently the only shared place to put these.  

double parseDateFromNullTerminatedCharacters(const char* dateString);

double timeClip(double);

inline double jsCurrentTime()

{

    // JavaScript doesn't recognize fractions of a millisecond.

    return floor(WTF::currentTimeMS());

}

const char * const weekdayName[7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };

const char * const monthName[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

const double hoursPerDay = 24.0;

const double minutesPerHour = 60.0;

const double secondsPerHour = 60.0 * 60.0;

const double secondsPerMinute = 60.0;

const double msPerSecond = 1000.0;

const double msPerMinute = 60.0 * 1000.0;

const double msPerHour = 60.0 * 60.0 * 1000.0;

const double msPerDay = 24.0 * 60.0 * 60.0 * 1000.0;

const double msPerMonth = 2592000000.0;

// Returns the number of days from 1970-01-01 to the specified date.

double dateToDaysFrom1970(int year, int month, int day);

int msToYear(double ms);

int dayInYear(double ms, int year);

int monthFromDayInYear(int dayInYear, bool leapYear);

int dayInMonthFromDayInYear(int dayInYear, bool leapYear);

} // namespace WTF

using WTF::dateToDaysFrom1970;

using WTF::dayInMonthFromDayInYear;

using WTF::dayInYear;

using WTF::minutesPerHour;

using WTF::monthFromDayInYear;

using WTF::msPerDay;

using WTF::msPerSecond;

using WTF::msToYear;

using WTF::secondsPerMinute;

#if USE(JSC)

namespace JSC {

class ExecState;

struct GregorianDateTime;

void msToGregorianDateTime(ExecState*, double, bool outputIsUTC, GregorianDateTime&);

double gregorianDateTimeToMS(ExecState*, const GregorianDateTime&, double, bool inputIsUTC);

double getUTCOffset(ExecState*);

double parseDateFromNullTerminatedCharacters(ExecState*, const char* dateString);

// Intentionally overridding the default tm of the system.

// The members of tm differ on various operating systems.

struct GregorianDateTime : Noncopyable {

    GregorianDateTime()

        : second(0)

        , minute(0)

        , hour(0)

        , weekDay(0)

        , monthDay(0)

        , yearDay(0)

        , month(0)

        , year(0)

        , isDST(0)

        , utcOffset(0)

        , timeZone(0)

    {

    }

    ~GregorianDateTime()

    {

        delete [] timeZone;

    }

    GregorianDateTime(ExecState* exec, const tm& inTm)

        : second(inTm.tm_sec)

        , minute(inTm.tm_min)

        , hour(inTm.tm_hour)

        , weekDay(inTm.tm_wday)

        , monthDay(inTm.tm_mday)

        , yearDay(inTm.tm_yday)

        , month(inTm.tm_mon)

        , year(inTm.tm_year)

        , isDST(inTm.tm_isdst)

    {

        UNUSED_PARAM(exec);

#if HAVE(TM_GMTOFF)

        utcOffset = static_cast<int>(inTm.tm_gmtoff);

#else

        utcOffset = static_cast<int>(getUTCOffset(exec) / WTF::msPerSecond + (isDST ? WTF::secondsPerHour : 0));

#endif

#if HAVE(TM_ZONE)

        int inZoneSize = strlen(inTm.tm_zone) + 1;

        timeZone = new char[inZoneSize];

        strncpy(timeZone, inTm.tm_zone, inZoneSize);

#else

        timeZone = 0;

#endif

    }

    operator tm() const

    {

        tm ret;

        memset(&ret, 0, sizeof(ret));

        ret.tm_sec   =  second;

        ret.tm_min   =  minute;

        ret.tm_hour  =  hour;

        ret.tm_wday  =  weekDay;

        ret.tm_mday  =  monthDay;

        ret.tm_yday  =  yearDay;

        ret.tm_mon   =  month;

        ret.tm_year  =  year;

        ret.tm_isdst =  isDST;

#if HAVE(TM_GMTOFF)

        ret.tm_gmtoff = static_cast<long>(utcOffset);

#endif

#if HAVE(TM_ZONE)

        ret.tm_zone = timeZone;

#endif

        return ret;

    }

    void copyFrom(const GregorianDateTime& rhs)

    {

        second = rhs.second;

        minute = rhs.minute;

        hour = rhs.hour;

        weekDay = rhs.weekDay;

        monthDay = rhs.monthDay;

        yearDay = rhs.yearDay;

        month = rhs.month;

        year = rhs.year;

        isDST = rhs.isDST;

        utcOffset = rhs.utcOffset;

        if (rhs.timeZone) {

            int inZoneSize = strlen(rhs.timeZone) + 1;

            timeZone = new char[inZoneSize];

            strncpy(timeZone, rhs.timeZone, inZoneSize);

        } else

            timeZone = 0;

    }

    int second;

    int minute;

    int hour;

    int weekDay;

    int monthDay;

    int yearDay;

    int month;

    int year;

    int isDST;

    int utcOffset;

    char* timeZone;

};

static inline int gmtoffset(const GregorianDateTime& t)

{

    return t.utcOffset;

}

} // namespace JSC

#endif // USE(JSC)

#endif // DateMath_h