/*

 *  This file is part of the KDE libraries

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

 *  Copyright (C) 2004 Apple Computer, Inc.

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include "config.h"

#include "date_object.h"

#include "date_object.lut.h"

#include "internal.h"

#if HAVE(ERRNO_H)

#include <errno.h>

#endif

#if HAVE(SYS_PARAM_H)

#include <sys/param.h>

#endif

#if HAVE(SYS_TIME_H)

#include <sys/time.h>

#endif

#if HAVE(SYS_TIMEB_H)

#include <sys/timeb.h>

#endif

#include <ctype.h>

#include <float.h>

#include <limits.h>

#include <locale.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "error_object.h"

#include "operations.h"

#include "DateMath.h"

#include <wtf/MathExtras.h>

#include <wtf/StringExtras.h>

#if PLATFORM(MAC)

    #include <CoreFoundation/CoreFoundation.h>

#endif

namespace KJS {

static double parseDate(const UString&);

static double timeClip(double);

inline int gmtoffset(const GregorianDateTime& t)

{

    return t.utcOffset;

}

/**

 * @internal

 *

 * Class to implement all methods that are properties of the

 * Date object

 */

class DateObjectFuncImp : public InternalFunctionImp {

public:

    DateObjectFuncImp(ExecState *, FunctionPrototype *, int i, int len, const Identifier& );

    virtual JSValue *callAsFunction(ExecState *, JSObject *thisObj, const List &args);

    enum { Parse, UTC };

private:

    int id;

};

#if PLATFORM(MAC)

static CFDateFormatterStyle styleFromArgString(const UString& string, CFDateFormatterStyle defaultStyle)

{

    if (string == "short")

        return kCFDateFormatterShortStyle;

    if (string == "medium")

        return kCFDateFormatterMediumStyle;

    if (string == "long")

        return kCFDateFormatterLongStyle;

    if (string == "full")

        return kCFDateFormatterFullStyle;

    return defaultStyle;

}

static UString formatLocaleDate(ExecState *exec, double time, bool includeDate, bool includeTime, const List &args)

{

    CFDateFormatterStyle dateStyle = (includeDate ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);

    CFDateFormatterStyle timeStyle = (includeTime ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);

    bool useCustomFormat = false;

    UString customFormatString;

    UString arg0String = args[0]->toString(exec);

    if (arg0String == "custom" && !args[1]->isUndefined()) {

        useCustomFormat = true;

        customFormatString = args[1]->toString(exec);

    } else if (includeDate && includeTime && !args[1]->isUndefined()) {

        dateStyle = styleFromArgString(arg0String, dateStyle);

        timeStyle = styleFromArgString(args[1]->toString(exec), timeStyle);

    } else if (includeDate && !args[0]->isUndefined()) {

        dateStyle = styleFromArgString(arg0String, dateStyle);

    } else if (includeTime && !args[0]->isUndefined()) {

        timeStyle = styleFromArgString(arg0String, timeStyle);

    }

    CFLocaleRef locale = CFLocaleCopyCurrent();

    CFDateFormatterRef formatter = CFDateFormatterCreate(0, locale, dateStyle, timeStyle);

    CFRelease(locale);

    if (useCustomFormat) {

        CFStringRef customFormatCFString = CFStringCreateWithCharacters(0, (UniChar *)customFormatString.data(), customFormatString.size());

        CFDateFormatterSetFormat(formatter, customFormatCFString);

        CFRelease(customFormatCFString);

    }

    CFStringRef string = CFDateFormatterCreateStringWithAbsoluteTime(0, formatter, time - kCFAbsoluteTimeIntervalSince1970);

    CFRelease(formatter);

    // We truncate the string returned from CFDateFormatter if it's absurdly long (> 200 characters).

    // That's not great error handling, but it just won't happen so it doesn't matter.

    UChar buffer[200];

    const size_t bufferLength = sizeof(buffer) / sizeof(buffer[0]);

    size_t length = CFStringGetLength(string);

    assert(length <= bufferLength);

    if (length > bufferLength)

        length = bufferLength;

    CFStringGetCharacters(string, CFRangeMake(0, length), reinterpret_cast<UniChar *>(buffer));

    CFRelease(string);

    return UString(buffer, length);

}

#elif PLATFORM(SYMBIAN)

_LIT( KDateFormat, "%F%*E %*N %*D %Y" );

//Wdy, DD-Mon-YYYY HH:MM:SS GMT

_LIT( KTimeFormat, "%*E,%D%*N%Y %1-%2-%3 0%H%:1%T%:2%S% GMT" );

_LIT( KDateUTCVariant, "%F%*E %*D %*N %Y" );

_LIT( KLocaleDate, "%E,%D%N%Y %1 %2 %3" );

_LIT( KLocaleTime, "%-B%:0%J%:1%T%:2%S%+B" );

_LIT( KLocaleDateTime, "%E,%D%N%Y  %1 %2, %3%-B%:0%J%:1%T%:2%S%+B" );

static UString formatLocaleDate(KJS::ExecState *exec, time_t t_, bool includeDate, bool includeTime, const KJS::List &args)

{

  TBuf<256> buf;

  struct tm* t = localtime( &t_ );

  TTime tt( TDateTime(t->tm_year + 1900, TMonth(t->tm_mon), t->tm_mday-1,

         t->tm_hour, t->tm_min, t->tm_sec, 0) );

  if( includeDate && includeTime )

    tt.FormatL( buf, KLocaleDateTime );

  else if( includeDate )

    tt.FormatL( buf, KLocaleDate );

  else if( includeTime )

    tt.FormatL( buf, KLocaleTime );

  const UChar *p = (const UChar*)buf.Ptr();

  return UString( p, buf.Length() );

}

#else

enum LocaleDateTimeFormat { LocaleDateAndTime, LocaleDate, LocaleTime };

static JSCell* formatLocaleDate(const GregorianDateTime& gdt, const LocaleDateTimeFormat format)

{

    static const char* formatStrings[] = {"%#c", "%#x", "%X"};

    // Offset year if needed

    struct tm localTM = gdt;

    int year = gdt.year + 1900;

    bool yearNeedsOffset = year < 1900 || year > 2038;

    if (yearNeedsOffset) {

        localTM.tm_year = equivalentYearForDST(year) - 1900;

     }

    // Do the formatting

    const int bufsize=128;

    char timebuffer[bufsize];

    size_t ret = strftime(timebuffer, bufsize, formatStrings[format], &localTM);

    if ( ret == 0 )

        return jsString("");

    // Copy original into the buffer

    if (yearNeedsOffset && format != LocaleTime) {

        static const int yearLen = 5;   // FIXME will be a problem in the year 10,000

        char yearString[yearLen];

        snprintf(yearString, yearLen, "%d", localTM.tm_year + 1900);

        char* yearLocation = strstr(timebuffer, yearString);

        snprintf(yearString, yearLen, "%d", year);

        strncpy(yearLocation, yearString, yearLen - 1);

    }

    return jsString(timebuffer);

}

#endif // PLATFORM(WIN_OS)

static UString formatDate(const GregorianDateTime &t)

{

    char buffer[100];

    snprintf(buffer, sizeof(buffer), "%s %s %02d %04d",

        weekdayName[(t.weekDay + 6) % 7],

        monthName[t.month], t.monthDay, t.year + 1900);

    return buffer;

}

static UString formatDateUTCVariant(const GregorianDateTime &t)

{

    char buffer[100];

    snprintf(buffer, sizeof(buffer), "%s, %02d %s %04d",

        weekdayName[(t.weekDay + 6) % 7],

        t.monthDay, monthName[t.month], t.year + 1900);

    return buffer;

}

static UString formatTime(const GregorianDateTime &t, bool utc)

{

    char buffer[100];

    if (utc) {

        snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d GMT", t.hour, t.minute, t.second);

    } else {

        int offset = abs(gmtoffset(t));

        char tzname[70];

        struct tm gtm = t;

        strftime(tzname, sizeof(tzname), "%Z", &gtm);

        if (tzname) {

            snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d GMT%c%02d%02d (%s)",

                t.hour, t.minute, t.second,

                gmtoffset(t) < 0 ? '-' : '+', offset / (60*60), (offset / 60) % 60, tzname);

        } else {

            snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d GMT%c%02d%02d",

                t.hour, t.minute, t.second,

                gmtoffset(t) < 0 ? '-' : '+', offset / (60*60), (offset / 60) % 60);

        }

    }

    return UString(buffer);

}

// Converts a list of arguments sent to a Date member function into milliseconds, updating

// ms (representing milliseconds) and t (representing the rest of the date structure) appropriately.

//

// Format of member function: f([hour,] [min,] [sec,] [ms])

static void fillStructuresUsingTimeArgs(ExecState *exec, const List &args, int maxArgs, double *ms, GregorianDateTime *t)

{

    double milliseconds = 0;

    int idx = 0;

    int numArgs = args.size();

    // JS allows extra trailing arguments -- ignore them

    if (numArgs > maxArgs)

        numArgs = maxArgs;

    // hours

    if (maxArgs >= 4 && idx < numArgs) {

        t->hour = 0;

        milliseconds += args[idx++]->toInt32(exec) * msPerHour;

    }

    // minutes

    if (maxArgs >= 3 && idx < numArgs) {

        t->minute = 0;

        milliseconds += args[idx++]->toInt32(exec) * msPerMinute;

    }

    // seconds

    if (maxArgs >= 2 && idx < numArgs) {

        t->second = 0;

        milliseconds += args[idx++]->toInt32(exec) * msPerSecond;

    }

    // milliseconds

    if (idx < numArgs) {

        milliseconds += roundValue(exec, args[idx]);

    } else {

        milliseconds += *ms;

    }

    *ms = milliseconds;

}

// Converts a list of arguments sent to a Date member function into years, months, and milliseconds, updating

// ms (representing milliseconds) and t (representing the rest of the date structure) appropriately.

//

// Format of member function: f([years,] [months,] [days])

static void fillStructuresUsingDateArgs(ExecState *exec, const List &args, int maxArgs, double *ms, GregorianDateTime *t)

{

    int idx = 0;

    int numArgs = args.size();

    // JS allows extra trailing arguments -- ignore them

    if (numArgs > maxArgs)

        numArgs = maxArgs;

    // years

    if (maxArgs >= 3 && idx < numArgs)

        t->year = args[idx++]->toInt32(exec) - 1900;

    // months

    if (maxArgs >= 2 && idx < numArgs)

        t->month = args[idx++]->toInt32(exec);

    // days

    if (idx < numArgs) {

        t->monthDay = 0;

        *ms += args[idx]->toInt32(exec) * msPerDay;

    }

}

// ------------------------------ DateInstance ------------------------------

const ClassInfo DateInstance::info = {"Date", 0, 0, 0};

DateInstance::DateInstance(JSObject *proto)

  : JSWrapperObject(proto)

{

}

bool DateInstance::getTime(GregorianDateTime &t, int &offset) const

{

    double milli = internalValue()->getNumber();

    if (isNaN(milli))

        return false;

    msToGregorianDateTime(milli, false, t);

    offset = gmtoffset(t);

    return true;

}

bool DateInstance::getUTCTime(GregorianDateTime &t) const

{

    double milli = internalValue()->getNumber();

    if (isNaN(milli))

        return false;

    msToGregorianDateTime(milli, true, t);

    return true;

}

bool DateInstance::getTime(double &milli, int &offset) const

{

    milli = internalValue()->getNumber();

    if (isNaN(milli))

        return false;

    GregorianDateTime t;

    msToGregorianDateTime(milli, false, t);

    offset = gmtoffset(t);

    return true;

}

bool DateInstance::getUTCTime(double &milli) const

{

    milli = internalValue()->getNumber();

    if (isNaN(milli))

        return false;

    return true;

}

static inline bool isTime_tSigned()

{

    time_t minusOne = (time_t)(-1);

    return minusOne < 0;

}

// ------------------------------ DatePrototype -----------------------------

const ClassInfo DatePrototype::info = {"Date", &DateInstance::info, &dateTable, 0};

/* Source for date_object.lut.h

   We use a negative ID to denote the "UTC" variant.

@begin dateTable 61

  toString              DateProtoFunc::ToString                 DontEnum|Function       0

  toUTCString           -DateProtoFunc::ToUTCString             DontEnum|Function       0

  toDateString          DateProtoFunc::ToDateString             DontEnum|Function       0

  toTimeString          DateProtoFunc::ToTimeString             DontEnum|Function       0

  toLocaleString        DateProtoFunc::ToLocaleString           DontEnum|Function       0

  toLocaleDateString    DateProtoFunc::ToLocaleDateString       DontEnum|Function       0

  toLocaleTimeString    DateProtoFunc::ToLocaleTimeString       DontEnum|Function       0

  valueOf               DateProtoFunc::ValueOf                  DontEnum|Function       0

  getTime               DateProtoFunc::GetTime                  DontEnum|Function       0

  getFullYear           DateProtoFunc::GetFullYear              DontEnum|Function       0

  getUTCFullYear        -DateProtoFunc::GetFullYear             DontEnum|Function       0

  toGMTString           -DateProtoFunc::ToGMTString             DontEnum|Function       0

  getMonth              DateProtoFunc::GetMonth                 DontEnum|Function       0

  getUTCMonth           -DateProtoFunc::GetMonth                DontEnum|Function       0

  getDate               DateProtoFunc::GetDate                  DontEnum|Function       0

  getUTCDate            -DateProtoFunc::GetDate                 DontEnum|Function       0

  getDay                DateProtoFunc::GetDay                   DontEnum|Function       0

  getUTCDay             -DateProtoFunc::GetDay                  DontEnum|Function       0

  getHours              DateProtoFunc::GetHours                 DontEnum|Function       0

  getUTCHours           -DateProtoFunc::GetHours                DontEnum|Function       0

  getMinutes            DateProtoFunc::GetMinutes               DontEnum|Function       0

  getUTCMinutes         -DateProtoFunc::GetMinutes              DontEnum|Function       0

  getSeconds            DateProtoFunc::GetSeconds               DontEnum|Function       0

  getUTCSeconds         -DateProtoFunc::GetSeconds              DontEnum|Function       0

  getMilliseconds       DateProtoFunc::GetMilliSeconds          DontEnum|Function       0

  getUTCMilliseconds    -DateProtoFunc::GetMilliSeconds         DontEnum|Function       0

  getTimezoneOffset     DateProtoFunc::GetTimezoneOffset        DontEnum|Function       0

  setTime               DateProtoFunc::SetTime                  DontEnum|Function       1

  setMilliseconds       DateProtoFunc::SetMilliSeconds          DontEnum|Function       1

  setUTCMilliseconds    -DateProtoFunc::SetMilliSeconds         DontEnum|Function       1

  setSeconds            DateProtoFunc::SetSeconds               DontEnum|Function       2

  setUTCSeconds         -DateProtoFunc::SetSeconds              DontEnum|Function       2

  setMinutes            DateProtoFunc::SetMinutes               DontEnum|Function       3

  setUTCMinutes         -DateProtoFunc::SetMinutes              DontEnum|Function       3

  setHours              DateProtoFunc::SetHours                 DontEnum|Function       4

  setUTCHours           -DateProtoFunc::SetHours                DontEnum|Function       4

  setDate               DateProtoFunc::SetDate                  DontEnum|Function       1

  setUTCDate            -DateProtoFunc::SetDate                 DontEnum|Function       1

  setMonth              DateProtoFunc::SetMonth                 DontEnum|Function       2

  setUTCMonth           -DateProtoFunc::SetMonth                DontEnum|Function       2

  setFullYear           DateProtoFunc::SetFullYear              DontEnum|Function       3

  setUTCFullYear        -DateProtoFunc::SetFullYear             DontEnum|Function       3

  setYear               DateProtoFunc::SetYear                  DontEnum|Function       1

  getYear               DateProtoFunc::GetYear                  DontEnum|Function       0

@end

*/

// ECMA 15.9.4

DatePrototype::DatePrototype(ExecState *, ObjectPrototype *objectProto)

  : DateInstance(objectProto)

{

    setInternalValue(jsNaN());

    // The constructor will be added later, after DateObjectImp has been built.

}

bool DatePrototype::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)

{

    return getStaticFunctionSlot<DateProtoFunc, JSObject>(exec, &dateTable, this, propertyName, slot);

}

// ------------------------------ DateProtoFunc -----------------------------

DateProtoFunc::DateProtoFunc(ExecState* exec, int i, int len, const Identifier& name)

  : InternalFunctionImp(static_cast<FunctionPrototype*>(exec->lexicalInterpreter()->builtinFunctionPrototype()), name)

  , id(abs(i))

  , utc(i < 0)

  // We use a negative ID to denote the "UTC" variant.

{

    putDirect(exec->propertyNames().length, len, DontDelete|ReadOnly|DontEnum);

}

JSValue *DateProtoFunc::callAsFunction(ExecState *exec, JSObject *thisObj, const List &args)

{

  if (!thisObj->inherits(&DateInstance::info))

    return throwError(exec, TypeError);

  DateInstance* thisDateObj = static_cast<DateInstance*>(thisObj); 

  JSValue *result = 0;

  UString s;

  JSValue *v = thisDateObj->internalValue();

  double milli = v->toNumber(exec);

  if (isNaN(milli)) {

    switch (id) {

      case ToString:

      case ToDateString:

      case ToTimeString:

      case ToGMTString:

      case ToUTCString:

      case ToLocaleString:

      case ToLocaleDateString:

      case ToLocaleTimeString:

        return jsString("Invalid Date");

      case ValueOf:

      case GetTime:

      case GetYear:

      case GetFullYear:

      case GetMonth:

      case GetDate:

      case GetDay:

      case GetHours:

      case GetMinutes:

      case GetSeconds:

      case GetMilliSeconds:

      case GetTimezoneOffset:

        return jsNaN();

    }

  }