/***************************************************************************
 * E-Com Technology Ltd.
 *
 * ECOMPACS DICOM Network Transport Libraries * Version 0.1 Beta
 ***************************************************************************/
#ifndef	_DICOM_DATETIME_
#define	_DICOM_DATETIME_


typedef double DATE;

class DDateTimeSpan;


/////////////////////////////////////////////////////////////////////////////
// DDateTime class helpers

#define DDATETIME_ERROR (-1)
#define DDATETIME_HALFSECOND (1.0 / (2.0 * (60.0 * 60.0 * 24.0)))

/////////////////////////////////////////////////////////////////////////////
// DDateTime class

class DICOM_API DDateTime
{
// Constructors
public:
	static DDateTime PASCAL GetCurrentTime ();

	DDateTime ();
	DDateTime (const DDateTime & dateSrc);
	DDateTime (DATE dtSrc);
	DDateTime (time_t timeSrc);
	DDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);
	DDateTime (const char * DateString, const char * TimeStr);
	DDateTime (WORD wDosDate, WORD wDosTime, int nDST);

// Attributes
public:
	enum DateTimeStatus
	{
		valid = 0,
		invalid = 1,    // Invalid date (out of range, etc.)
		null = 2,       // Literally has no value
	};

	DATE m_dt;
	DateTimeStatus m_status;

	void SetStatus (DateTimeStatus status);
	DateTimeStatus GetStatus () const;

	int GetYear () const;
	int GetMonth () const;       // month of year (1 = Jan)
	int GetDay () const;         // day of month (0-31)
	int GetHour () const;        // hour in day (0-23)
	int GetMinute () const;      // minute in hour (0-59)
	int GetSecond () const;      // second in minute (0-59)
	int GetDayOfWeek () const;   // 1=Sun, 2=Mon, ..., 7=Sat
	int GetDayOfYear () const;   // days since start of year, Jan 1 = 1

	bool IsSunday ()	const { return (GetDayOfWeek () == 1); }
	bool IsMonday ()	const { return (GetDayOfWeek () == 2); }
	bool IsTuesday ()	const { return (GetDayOfWeek () == 3); }
	bool IsWednesday () const { return (GetDayOfWeek () == 4); }
	bool IsThursday ()	const { return (GetDayOfWeek () == 5); }
	bool IsFriday ()	const { return (GetDayOfWeek () == 6); }
	bool IsSaturday ()	const { return (GetDayOfWeek () == 7); }

// Operations
public:
	const DDateTime & operator = (const DDateTime & dateSrc);
	const DDateTime & operator = (DATE dtSrc);
	const DDateTime & operator = (const time_t & timeSrc);

	BOOL operator == (const DDateTime & date) const;
	BOOL operator != (const DDateTime & date) const;
	BOOL operator <  (const DDateTime & date) const;
	BOOL operator >  (const DDateTime & date) const;
	BOOL operator <= (const DDateTime & date) const;
	BOOL operator >= (const DDateTime & date) const;

	// DateTime math
	DDateTime operator + (const DDateTimeSpan & dateSpan) const;
	DDateTime operator - (const DDateTimeSpan & dateSpan) const;
	const DDateTime & operator += (const DDateTimeSpan dateSpan);
	const DDateTime & operator -= (const DDateTimeSpan dateSpan);

	// DateTimeSpan math
	DDateTimeSpan operator - (const DDateTime & date) const;

	operator DATE () const;

	int SetDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);
	int SetDate (int nYear, int nMonth, int nDay);
	int SetTime (int nHour, int nMin, int nSec);

	int SetDateTime (const char * DateStr, const char * TimeStr);
	// 保留时间不变,但是日期用DateStr中的日期
	int SetDate (const char * DateStr);
	// 保留日期不变,但是时间设置为TimeStr中的日期
	int SetTime (const char * TimeStr);

	// formatting
	DString Format (LPCTSTR lpszFormat) const;
	DString ToString (LPCTSTR lpszFormat) const
	{
		return Format (lpszFormat);
	}

	DString FormatDate (void) const;
	DString FormatTime (void) const;

// Implementation
protected:
	void CheckRange ();
	friend class DDateTimeSpan;
};


/////////////////////////////////////////////////////////////////////////////
// DDateTimeSpan class
class DICOM_API DDateTimeSpan
{
// Constructors
public:
	DDateTimeSpan ();

	DDateTimeSpan (double dblSpanSrc);
	DDateTimeSpan (const DDateTimeSpan & dateSpanSrc);
	DDateTimeSpan (long lDays, int nHours, int nMins, int nSecs);
	DDateTimeSpan (const char * SpanString);

// Attributes
public:
	enum DateTimeSpanStatus
	{
		valid = 0,
		invalid = 1,    // Invalid span (out of range, etc.)
		null = 2,       // Literally has no value
	};

	double m_span;
	DateTimeSpanStatus m_status;

	void SetStatus (DateTimeSpanStatus status);
	DateTimeSpanStatus GetStatus () const;

	double GetTotalDays () const;    // span in days (about -3.65e6 to 3.65e6)
	double GetTotalHours () const;   // span in hours (about -8.77e7 to 8.77e6)
	double GetTotalMinutes () const; // span in minutes (about -5.26e9 to 5.26e9)
	double GetTotalSeconds () const; // span in seconds (about -3.16e11 to 3.16e11)

	long GetDays () const;       // component days in span
	long GetHours () const;      // component hours in span (-23 to 23)
	long GetMinutes () const;    // component minutes in span (-59 to 59)
	long GetSeconds () const;    // component seconds in span (-59 to 59)

// Operations
public:
	const DDateTimeSpan & operator = (double dblSpanSrc);
	const DDateTimeSpan & operator = (const DDateTimeSpan & dateSpanSrc);

	BOOL operator == (const DDateTimeSpan & dateSpan) const;
	BOOL operator != (const DDateTimeSpan & dateSpan) const;
	BOOL operator <  (const DDateTimeSpan & dateSpan) const;
	BOOL operator >  (const DDateTimeSpan & dateSpan) const;
	BOOL operator <= (const DDateTimeSpan & dateSpan) const;
	BOOL operator >= (const DDateTimeSpan & dateSpan) const;

	// DateTimeSpan math
	DDateTimeSpan operator + (const DDateTimeSpan & dateSpan) const;
	DDateTimeSpan operator - (const DDateTimeSpan & dateSpan) const;
	const DDateTimeSpan & operator += (const DDateTimeSpan dateSpan);
	const DDateTimeSpan & operator -= (const DDateTimeSpan dateSpan);
	DDateTimeSpan operator - () const;

	operator double () const;

	void SetDateTimeSpan (long lDays, int nHours, int nMins, int nSecs);

	// formatting
	DString Format (LPCTSTR lpszFormat) const;
	DString	ToString (LPCTSTR lpszFormat) const
	{
		return Format (lpszFormat);
	}

// Implementation
public:
	void CheckRange ();
	friend class DDateTime;
};


// DDateTime
__inline DDateTime::DDateTime ()
	{ m_dt = 0; SetStatus (valid); }

__inline DDateTime::DDateTime (const DDateTime & dateSrc)
	{ m_dt = dateSrc.m_dt; m_status = dateSrc.m_status; }

__inline DDateTime::DDateTime (DATE dtSrc)
	{ m_dt = dtSrc; SetStatus (valid); }

__inline DDateTime::DDateTime (time_t timeSrc)
	{ *this = timeSrc; }

__inline DDateTime::DDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec)
	{ SetDateTime (nYear, nMonth, nDay, nHour, nMin, nSec); }

__inline const DDateTime& DDateTime::operator = (const DDateTime& dateSrc)
	{ m_dt = dateSrc.m_dt; m_status = dateSrc.m_status; return *this; }

__inline DDateTime::DateTimeStatus DDateTime::GetStatus () const
	{ return m_status; }

__inline void DDateTime::SetStatus (DateTimeStatus status)
	{ m_status = status; }

__inline BOOL DDateTime::operator == (const DDateTime& date) const
	{ return (m_status == date.m_status && m_dt == date.m_dt); }

__inline BOOL DDateTime::operator != (const DDateTime& date) const
	{ return (m_status != date.m_status || m_dt != date.m_dt); }

__inline const DDateTime & DDateTime::operator += (const DDateTimeSpan dateSpan)
	{ *this = *this + dateSpan; return *this; }

__inline const DDateTime & DDateTime::operator -= (const DDateTimeSpan dateSpan)
	{ *this = *this - dateSpan; return *this; }

__inline DDateTime::operator DATE () const
	{ return m_dt; }

__inline int DDateTime::SetDate (int nYear, int nMonth, int nDay)
	{ return SetDateTime (nYear, nMonth, nDay, 0, 0, 0); }

__inline int DDateTime::SetTime (int nHour, int nMin, int nSec)
	// Set date to zero date - 12/30/1899
	{ return SetDateTime (1899, 12, 30, nHour, nMin, nSec); }

// DDateTimeSpan
__inline DDateTimeSpan::DDateTimeSpan ()
	{ m_span = 0; SetStatus (valid); }

__inline DDateTimeSpan::DDateTimeSpan (double dblSpanSrc)
	{ m_span = dblSpanSrc; SetStatus (valid); }

__inline DDateTimeSpan::DDateTimeSpan (const DDateTimeSpan& dateSpanSrc)
	{ m_span = dateSpanSrc.m_span; m_status = dateSpanSrc.m_status; }

__inline DDateTimeSpan::DDateTimeSpan (long lDays, int nHours, int nMins, int nSecs)
	{ SetDateTimeSpan (lDays, nHours, nMins, nSecs); }

__inline DDateTimeSpan::DateTimeSpanStatus DDateTimeSpan::GetStatus () const
	{ return m_status; }

__inline void DDateTimeSpan::SetStatus (DateTimeSpanStatus status)
	{ m_status = status; }

__inline double DDateTimeSpan::GetTotalDays () const
	{ 
//		ASSERT (GetStatus () == valid); 
		return m_span;
	}

__inline double DDateTimeSpan::GetTotalHours () const
	{
//		ASSERT (GetStatus () == valid);
		long lReturns = (long) (m_span * 24 + DDATETIME_HALFSECOND);
		return lReturns;
	}

__inline double DDateTimeSpan::GetTotalMinutes () const
	{ 
//		ASSERT (GetStatus () == valid);
		long lReturns = (long) (m_span * 24 * 60 + DDATETIME_HALFSECOND);
		return lReturns;
	}

__inline double DDateTimeSpan::GetTotalSeconds () const
	{ 
//		ASSERT (GetStatus () == valid);
		long lReturns = (long) (m_span * 24 * 60 * 60 + DDATETIME_HALFSECOND);
		return lReturns;
	}

__inline long DDateTimeSpan::GetDays () const
	{ 
//		ASSERT (GetStatus () == valid); 
		return (long)m_span; 
	}

__inline BOOL DDateTimeSpan::operator == (const DDateTimeSpan& dateSpan) const
	{ return (m_status == dateSpan.m_status && m_span == dateSpan.m_span); }

__inline BOOL DDateTimeSpan::operator != (const DDateTimeSpan& dateSpan) const
	{ return (m_status != dateSpan.m_status || m_span != dateSpan.m_span); }

__inline BOOL DDateTimeSpan::operator < (const DDateTimeSpan& dateSpan) const
	{
//		ASSERT (GetStatus () == valid);
//		ASSERT (dateSpan.GetStatus () == valid);
		return m_span < dateSpan.m_span; 
	}

__inline BOOL DDateTimeSpan::operator > (const DDateTimeSpan& dateSpan) const
	{
//		ASSERT (GetStatus () == valid);
//		ASSERT (dateSpan.GetStatus () == valid);
		return m_span > dateSpan.m_span; 
	}

__inline BOOL DDateTimeSpan::operator <= (const DDateTimeSpan& dateSpan) const
	{
//		ASSERT (GetStatus () == valid);
//		ASSERT (dateSpan.GetStatus () == valid);
		return m_span <= dateSpan.m_span; 
	}

__inline BOOL DDateTimeSpan::operator >= (const DDateTimeSpan& dateSpan) const
	{
//		ASSERT (GetStatus () == valid);
//		ASSERT (dateSpan.GetStatus () == valid);
		return m_span >= dateSpan.m_span; 
	}

__inline const DDateTimeSpan& DDateTimeSpan::operator += (const DDateTimeSpan dateSpan)
	{ *this = *this + dateSpan; return *this; }

__inline const DDateTimeSpan& DDateTimeSpan::operator -= (const DDateTimeSpan dateSpan)
	{ *this = *this - dateSpan; return *this; }

__inline DDateTimeSpan DDateTimeSpan::operator - () const
	{ return -this->m_span; }

__inline DDateTimeSpan::operator double () const
	{ return m_span; }


#endif