// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ 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 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Basic classes for manipulating time and date based data, particularly
 * that may be in strings.
 * @file ucommon/datetime.h
 */

/**
 * Example of date & time manipulation.
 * @example datetime.cpp
 */

#ifndef _UCOMMON_DATETIME_H_
#define _UCOMMON_DATETIME_H_

#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif

#ifndef _UCOMMON_NUMBERS_H_
#include <ucommon/numbers.h>
#endif

#ifndef _UCOMMON_STRING_H_
#include <ucommon/string.h>
#endif

#ifndef _MSWINDOWS_
#include <unistd.h>
#include <sys/time.h>
#endif

#include <time.h>

#define DATE_STRING_SIZE        10
#define DATE_BUFFER_SIZE        11
#define TIME_STRING_SIZE        8
#define TIME_BUFFER_SIZE        9
#define DATETIME_STRING_SIZE    19
#define DATETIME_BUFFER_SIZE    20

/**
 * Convenience type for struct tm.
 */
typedef struct tm   tm_t;

NAMESPACE_UCOMMON

#ifdef __BORLANDC__
    using std::tm;
    using std::time_t;
#endif

/**
 * The Date class uses a julian date representation of the current
 * year, month, and day.  This is then manipulated in several forms
 * and may be exported as needed.
 *
 * @author David Sugar <dyfet@ostel.com>
 * @short julian number based date class.
 */
class __EXPORT Date
{
protected:
    long julian;

    void set(long year, long month, long day);

    /**
     * A method to use to "post" any changed values when shadowing
     * a mixed object class.  This is used by DateNumber and string classes.
     */
    virtual void update(void);

public:
    /**
     * Size of date string field.
     */
    static const size_t sz_string;

    /**
     * Create a julian date from a time_t type.
     * @param value from time()
     */
    Date(time_t value);

    /**
     * Create a julian date from a local or gmt date and time.
     * @param object from DateTime::glt() or gmt().
     */
    Date(struct tm *object);

    /**
     * Create a julian date from a ISO date string of a specified size.
     * @param pointer to ISO date string.
     * @param size of date field if not null terminated.
     */
    Date(const char *pointer, size_t size = 0);

    /**
     * Create a julian date from an arbitrary year, month, and day.
     * @param year of date.
     * @param month of date (1-12).
     * @param day of month (1-31).
     */
    Date(int year, unsigned month, unsigned day);

    /**
     * Create a julian date object from another object.
     * @param object to copy.
     */
    Date(const Date& object);

    /**
     * Construct a new julian date with today's date.
     */
    Date();

    /**
     * Destroy julian date object.
     */
    virtual ~Date();

    /**
     * Get the year of the date.
     * @return year of the date
     */
    int year(void) const;

    /**
     * Get the month of the date (1-12).
     * @return month of year
     */
    unsigned month(void) const;

    /**
     * Get the day of the month of the date.
     * @return day of month
     */
    unsigned day(void) const;

    /**
     * Get the day of the week (0-7).
     * @return day of week
     */
    unsigned dow(void) const;

    /**
     * Get a ISO string representation of the date (yyyy-mm-dd).
     * @param buffer to store string.
     * @return string representation.
     */
    const char *put(char *buffer) const;

    /**
     * Get a time_t for the julian date if in time_t epoch.
     * @return time_t or -1 if out of range.
     */
    time_t timeref(void) const;

    /**
     * Get the date as a number for the object or 0 if invalid.
     * @return date as number.
     */
    long get(void) const;

    /**
     * Set (update) the date with current date.
     */
    void set(void);

    /**
     * Set the julian date based on an ISO date string of specified size.
     * @param pointer to date string field.
     * @param size of field if not null terminated.
     */
    void set(const char *pointer, size_t size = 0);

    /**
     * Check if date is valid.
     * @return true if julian date is valid.
     */
    bool is_valid(void) const;

    /**
     * Casting operator to return date as number.
     * @return julian number.
     */
    inline operator long() const
        {return get();};

    /**
     * Access julian value.
     * @return julian number of object.
     */
    inline long operator*() const
        {return get();};

    /**
     * Expression operator to return an ISO date string for the current
     * julian date.
     * @return ISO date string.
     */
    String operator()() const;

    /**
     * Increment date by one day.
     * @return instance of current date object.
     */
    Date& operator++();

    /**
     * Decrement date by one day.
     * @return instance of current date object.
     */
    Date& operator--();

    /**
     * Increment date by offset.
     * @param offset to add to julian date.
     * @return instance of current date object.
     */
    Date& operator+=(long offset);

    /**
     * Decrement date by offset.
     * @param offset to subtract from julian date.
     * @return instance of current date object.
     */
    Date& operator-=(long offset);

    /**
     * Add days to julian date in an expression.
     * @param days to add.
     * @return new date object with modified days.
     */
    Date operator+(long days);

    /**
     * Subtract days from a julian date in an expression.
     * @param days to subtract.
     * @return new date object with modified days.
     */
    Date operator-(long days);

    /**
     * Operator to compute number of days between two dates.
     * @param date offset for computation.
     * @return number of days difference.
     */
    inline long operator-(const Date &date)
        {return (julian - date.julian);};

    /**
     * Assign date from another date object.
     * @param date object to assign from.
     * @return current modified date object.
     */
    Date& operator=(const Date& date);

    /**
     * Compare julian dates if same date.
     * @param date to compare with.
     * @return true if same.
     */
    bool operator==(const Date& date) const;

    /**
     * Compare julian dates if not same date.
     * @param date to compare with.
     * @return true if not same.
     */
    bool operator!=(const Date& date) const;

    /**
     * Compare julian date if earlier than another date.
     * @param date to compare with.
     * @return true if earlier.
     */
    bool operator<(const Date& date) const;

    /**
     * Compare julian date if earlier than or equal to another date.
     * @param date to compare with.
     * @return true if earlier or same.
     */
    bool operator<=(const Date& date) const;

    /**
     * Compare julian date if later than another date.
     * @param date to compare with.
     * @return true if later.
     */
    bool operator>(const Date& date) const;

    /**
     * Compare julian date if later than or equal to another date.
     * @param date to compare with.
     * @return true if later or same.
     */
    bool operator>=(const Date& date) const;

    /**
     * Check if julian date is not valid.
     * @return true if date is invalid.
     */
    inline bool operator!() const
        {return !is_valid();};

    /**
     * Check if julian date is valid for is() expression.
     * @return true if date is valid.
     */
    inline operator bool() const
        {return is_valid();};
};

/**
 * The Time class uses a integer representation of the current
 * time.  This is then manipulated in several forms and may be
 * exported as needed.  The time object can represent an instance in
 * time (hours, minutes, and seconds) in a 24 hour period or can
 * represent a duration.  Millisecond accuracy can be offered.
 *
 * @author Marcelo Dalmas <mad@brasmap.com.br> and David Sugar <dyfet@gnutelephony.org>
 * @short Integer based time class.
 */

class __EXPORT Time
{
protected:
    long seconds;

protected:
    virtual void update(void);

public:
    void set(int hour, int minute = 0, int second = 0);

    /**
     * Constant for number of seconds in a day.
     */
    static const long c_day;

    /**
     * Constant for number of seconds in a hour.
     */
    static const long c_hour;

    /**
     * Constant for number of seconds in a week.
     */
    static const long c_week;

    /**
     * Size of time string field.
     */
    static const size_t sz_string;

    /**
     * Create a time from the time portion of a time_t.
     * @param value of time_t to use.
     */
    Time(time_t value);

    /**
     * Create a time from the time portion of a date and time object.
     * @param object from DateTime::glt() or gmt().
     */
    Time(tm_t *object);

    /**
     * Create a time from a hh:mm:ss formatted time string.
     * @param pointer to formatted time field.
     * @param size of field if not null terminated.
     */
    Time(const char *pointer, size_t size = 0);

    /**
     * Create a time from hours (0-23), minutes (0-59), and seconds (0-59).
     * @param hour of time.
     * @param minute of time.
     * @param second of time.
     */
    Time(int hour, int minute, int second);

    /**
     * Create a time object from another object.
     * @param object to copy.
     */
    Time(const Time& object);

    /**
     * Create a time from current time.
     */
    Time();

    /**
     * Destroy time object.
     */
    virtual ~Time();

    /**
     * Get current time in seconds from midnight.
     * @return seconds from midnight.
     */
    long get(void) const;

    /**
     * Get hours from midnight.
     * @return hours from midnight.
     */
    int hour(void) const;

    /**
     * Get minutes from current hour.
     * @return minutes from current hour.
     */
    int minute(void) const;

    /**
     * Get seconds from current minute.
     * @return seconds from current minute.
     */
    int second(void) const;

    /**
     * Get a hh:mm:ss formatted string for current time.
     * @param buffer to store time string in.
     * @return time string buffer or NULL if invalid.
     */
    const char *put(char *buffer) const;

    /**
     * Set (update) the time with current time.
     */
    void set(void);

    /**
     * Set time from a hh:mm:ss formatted string.
     * @param pointer to time field.
     * @param size of field if not null terminated.
     */
    void set(const char *pointer, size_t size = 0);

    /**
     * Check if time object had valid value.
     * @return true if object is valid.
     */
    bool is_valid(void) const;

    /**
     * Check if time object has valid value for is() operator.
     * @return true if object is valid.
     */
    inline operator bool() const
        {return is_valid();};

    /**
     * Check if time object has valid value for ! operator.
     * @return true if object is not valid.
     */
    inline bool operator!() const
        {return !is_valid();};

    /**
     * Get difference (in seconds) between two times.
     * @param reference time to get difference from.
     * @return difference in seconds.
     */
    long operator-(const Time &reference);

    /**
     * Add seconds to the current time, wrap if 24 hours.
     * @param seconds to add.
     * @return new time object with modified value.
     */
    Time operator+(long seconds);

    /**
     * Subtract seconds to the current time, wrap if 24 hours.
     * @param seconds to subtract.
     * @return new time object with modified value.
     */
    Time operator-(long seconds);

    /**
     * Get time in seconds.
     * @return seconds.
     */
    inline operator long()
        {return get();};

    /**
     * Get object time in seconds.
     * @return time in seconds.
     */
    inline long operator*() const
        {return get();};

    /**
     * Convert to standard 24 hour time string.
     * @return time string.
     */
    String operator()() const;

    /**
     * Incrememnt time by 1 second, wrap on 24 hour period.
     * @return modified instance of current time object.
     */
    Time& operator++();

    /**
     * Decrement time by 1 second, wrap on 24 hour period.
     * @return modified instance of current time object.
     */
    Time& operator--();

    /**
     * Assign a time as a copy of another time.
     * @param time to assign from.
     * @return time object that was assigned.
     */
    Time& operator=(const Time& time);

    /**
     * Increment time by specified seconds.  Wraps on 24 hour period.
     * @param seconds to add to current time.
     * @return modified instance of current time object.
     */
    Time& operator+=(long seconds);

    /**
     * Decrement time by specified seconds.  Wraps on 24 hour period.
     * @param seconds to subtract from current time.
     * @return modified instance of current time object.
     */
    Time& operator-=(long seconds);

    /**
     * Compare time with another time to see if same time.
     * @param time to compare with.
     * @return true if same time.
     */
    bool operator==(const Time &time) const;

    /**
     * Compare time with another time to see if not same time.
     * @param time to compare with.
     * @return true if not same time.
     */
    bool operator!=(const Time &time) const;

    /**
     * Compare time if earlier than another time.
     * @param time object to compare with.
     * @return true if earlier than object.
     */
    bool operator<(const Time &time) const;

    /**
     * Compare time if earlier than or equal to another time.
     * @param time object to compare with.
     * @return true if earlier or same as object.
     */
    bool operator<=(const Time &time) const;

    /**
     * Compare time if later than another time.
     * @param time object to compare with.
     * @return true if later than object.
     */
    bool operator>(const Time &time) const;

    /**
     * Compare time if later than or equal to another time.
     * @param time object to compare with.
     * @return true if later than or same as object.
     */
    bool operator>=(const Time &time) const;
};

/**
 * The Datetime class uses a julian date representation of the current
 * year, month, and day and a integer representation of the current
 * time.  This is then manipulated in several forms
 * and may be exported as needed.
 *
 * @author Marcelo Dalmas <mad@brasmap.com.br>
 * @short Integer based time class.
 */
class __EXPORT DateTime : public Date, public Time
{
protected:
    void update(void);

public:
    /**
     * Size of datetime string field.
     */
    static const size_t sz_string;

    /**
     * Construct a date and time from C library time_t type.
     * @param time type to make date and time from.
     */
    DateTime(time_t time);

    /**
     * Construct a date and time from C library time structure.
     * @param tm structure from C library (from glt or gmt).
     */
    DateTime(tm_t *tm);

    /**
     * Construct a date and time from ISO string buffer.
     * @param pointer to string field holding date and time.
     * @param size of field if not null terminated string.
     */
    DateTime(const char *pointer, size_t size = 0);

    /**
     * Construct a date and time object from explicit date and time values.
     * @param year of object.
     * @param month of object (1-12).
     * @param day of month of object (1-31).
     * @param hour of object (0-23).
     * @param minute of object (0-59).
     * @param second of object (0-59).
     */
    DateTime(int year, unsigned month, unsigned day,
         int hour = 0, int minute = 0, int second = 0);

    /**
     * Create a datetime object from another object.
     * @param object to copy.
     */
    DateTime(const DateTime& object);

    /**
     * Construct a new date and time object with current date and time.
     */
    DateTime();

    /**
     * Destroy date and time object.
     */
    virtual ~DateTime();

    /**
     * Get a ISO formatted date and time string for current object.
     * @param buffer to store date and time in (yyyy-mm-dd hh:mm:ss).
     * @return string buffer if object is valid.
     */
    const char *put(char *buffer) const;

    /**
     * Get C library time_t type if object in C library epoch range.
     * @return time in seconds from epoch or ~0l if out of range.
     */
    time_t get(void) const;

    /**
     * Test if object is valid.
     * @return true if object is valid.
     */
    bool is_valid(void) const;

    /**
     * Operator to compute number of days between two dates.
     * @param datetime to offset from for computation.
     * @return number of days difference.
     */
    long operator-(const DateTime &datetime);

    /**
     * Assign date and time from another datetime object.
     * @param datetime object to assign from.
     * @return assigned datetime object.
     */
    DateTime& operator=(const DateTime& datetime);

    /**
     * Add seconds to the current datetime object.  Day overflows update
     * julian date.
     * @param seconds to add to object.
     * @return modified datetime object.
     */
    DateTime& operator+=(long seconds);

    /**
     * Subtract seconds from current datetime object.  Day underflows
     * update julian date.
     * @param seconds to subtract from object.
     * @return modified datetime object.
     */
    DateTime& operator-=(long seconds);

    /**
     * Add seconds to datetime in an expression.  Day overflows update
     * julian date.
     * @param seconds to add to datetime.
     * @return new modified datetime object.
     */
    DateTime operator+(long seconds);

    /**
     * Subtract seconds from datetime in an expression.  Day underflows
     * update julian date.
     * @param seconds to subtract from datetime.
     * @return new modified datetime object.
     */
    DateTime operator-(long seconds);

    /**
     * Add a day from the current date and time.
     * @return datetime object reference that was modified.
     */
    DateTime& operator++();

    /**
     * Subtract a day from the current date and time.
     * @return datetime object reference that was modified.
     */
    DateTime& operator--();

    /**
     * Compare date and time with another date and time to see if the same.
     * @param datetime to compare with.
     * @return true if equal.
     */
    bool operator==(const DateTime& datetime) const;

    /**
     * Compare date and time with another date and time to see if not same.
     * @param datetime to compare with.
     * @return true if not equal.
     */
    bool operator!=(const DateTime& datetime) const;

    /**
     * Compare date and time with another date and time to see if earlier.
     * @param datetime to compare with.
     * @return true if earlier.
     */
    bool operator<(const DateTime& datetime) const;

    /**
     * Compare date and time with another date and time to see if earlier or
     * the same.
     * @param datetime to compare with.
     * @return true if earlier or equal.
     */
    bool operator<=(const DateTime& datetime) const;

    /**
     * Compare date and time with another date and time to see if later.
     * @param datetime to compare with.
     * @return true if later.
     */
    bool operator>(const DateTime& datetime) const;

    /**
     * Compare date and time with another date and time to see if later or
     * the same.
     * @param datetime to compare with.
     * @return true if later or equal.
     */
    bool operator>=(const DateTime& datetime) const;

    /**
     * Check if date and time is not valid.
     * @return true if not valid.
     */
    bool operator!() const;

    /**
     * Test is date and time is valid for is() operator.
     * @return true if object is valid.
     */
    operator bool() const;

    /**
     * Casting operator to return date as number.
     * @return date as a number.
     */
    inline operator long() const
        {return Date::get();};

    /**
     * Set (update) the date and time with current date and time.
     */
    void set(void);

    /**
     * Convert date and time to julian day number.
     * @return julian day number as a double.
     */
    operator double() const;

    /**
     * Return date and time formatted using strftime format values.
     * @param strftime format to use.
     * @return String object with formatted time.
     */
    String format(const char *strftime) const;

    /**
     * Fetch an instance of time converted to local time.  If the localtime
     * abi is not re-entrant, than a lock is held, otherwise a unique
     * object is returned.  In either case, when you are done, you must
     * release the object.
     * @param time object or NULL if using current time.
     * @return locked instance of struct tm object.
     */
    static tm_t *local(time_t *time = NULL);

    /**
     * Fetch an instance of time converted to gmt.  If the gmtime abi
     * is not re-entrant, than a lock is held, otherwise a unique
     * object is returned.  In either case, when you are done, you must
     * release the object.
     * @param time object or NULL if using current time.
     * @return locked instance of struct tm object.
     */
    static tm_t *gmt(time_t *time = NULL);

    /**
     * Release a struct tm object from glt or gmt.
     * @param object to release.
     */
    static void release(tm_t *object);
};

/**
 * A DateTime string class.  This can be used to access the date and time
 * as a standard string without requiring an external buffer.
 *
 * @author David Sugar <dyfet@gnutelephony.org>
 * @short a datetime class that returns strings.
 */
class __EXPORT DateTimeString : public DateTime
{
public:
    /**
     * Specify string buffer mode.  By default we form a string with date
     * and time.
     */
    typedef enum {
        DATE, TIME, BOTH} mode_t;

private:
    char buffer[DATETIME_BUFFER_SIZE];
    mode_t mode;

protected:
    void update(void);

public:
    /**
     * Construct a date and time from C libraray time_t type.
     * @param time type to make date and time from.
     */
    DateTimeString(time_t time);

    /**
     * Construct a date and time from C library time structure.
     * @param tm structure from C library (from glt or gmt).
     */
    DateTimeString(tm_t *tm);

    /**
     * Construct a date and time from ISO string buffer.
     * @param pointer to string field holding date and time.
     * @param size of field if not null terminated string.
     */
    DateTimeString(const char *pointer, size_t size = 0);

    /**
     * Construct a date and time object from explicit date and time values.
     * @param year of object.
     * @param month of object (1-12).
     * @param day of month of object (1-31).
     * @param hour of object (0-23).
     * @param minute of object (0-59).
     * @param second of object (0-59).
     */
    DateTimeString(int year, unsigned month, unsigned day,
         int hour = 0, int minute = 0, int second = 0);

    /**
     * Create a datetime object from another object.
     * @param object to copy.
     */
    DateTimeString(const DateTimeString& object);

    /**
     * Construct a new date and time object with current date and time.
     */
    DateTimeString(mode_t string = DateTimeString::BOTH);

    /**
     * Destroy date time string.
     */
    virtual ~DateTimeString();

    /**
     * Extract char from string.
     *
     * @return string of datetime.
     */
    inline const char *c_str(void)
        {return buffer;};

    /**
     * Cast to string.
     *
     * @return string of datetime.
     */
    inline operator const char *(void)
        {return buffer;};

    /**
     * Set (update) the date and time with current date and time.
     */
    void set(void);

    /**
     * Set the string mode.
     * @param string mode to use.
     */
    void set(mode_t string);
};

/**
 * A number class that manipulates a string buffer that is also a date.
 *
 * @author David Sugar <dyfet@ostel.com>
 * @short a number that is also a date string.
 */
class __EXPORT DateNumber : public Number, public Date
{
protected:
    void update(void);

public:
    /**
     * Create a date number tied to a refreshed string buffer.
     * @param pointer to string buffer to rewrite.
     */
    DateNumber(char *pointer);

    /**
     * Release a datenumber object.
     */
    virtual ~DateNumber();

    /**
     * Set date number to current date.
     */
    void set(void);
};

class __EXPORT isotime : public PrintProtocol, public InputProtocol
{
private:
    Date *d;
    Time *t;

    enum {DATE, TIME, DATETIME} mode;
    char buf[32];
    unsigned pos;

protected:
    const char *_print(void) const;

    int _input(int code);

public:
    isotime(Date& date, Time& time);
    isotime(Date& date);
    isotime(Time& time);
};

/**
 * Convenience type for using DateTime object.
 */
typedef DateTime    datetime_t;

/**
 * Convenience type for using DateTimeString object.
 */
typedef DateTimeString  datetimestring_t;

/**
 * Convenience type for using Date object.
 */
typedef Date        date_t;

/**
 * Convenience type for using Time object.
 */
typedef Time        tod_t;

extern "C" {
    __EXPORT long tzoffset(struct timezone *tz = NULL);
}

END_NAMESPACE

#endif