//      OperObjects
//      OpDateTime Class
//
//	DateTime class used in addition to standard C datetime class
//
//      Copyright © 1994-1997
//      Oklahoma Climatological Survey
//      All Rights Reserved.

// Included Files
#include "OpDateTime.h"


OpDateTime::OpDateTime()
{
        this->mVariables.mYear = 1970;
        this->mVariables.mMonth = 1;
        this->mVariables.mDay = 1;
        this->mVariables.mHour = 0;
        this->mVariables.mMinute = 0;
        this->mVariables.mSecond = 0;
        return;
}



OpDateTime::OpDateTime(const char * inDateTimeString)
{
        // MUST BE IN YYYYmmddHHMMSS format!
	char tmpYear[5], tmpMonth[3], tmpDay[3];
	char tmpHour[3], tmpMinute[3], tmpSecond[3];
	strncpy(tmpYear,inDateTimeString + 0,4);
	strncpy(tmpMonth,inDateTimeString + 4,2);
	strncpy(tmpDay,inDateTimeString + 6,2);
	strncpy(tmpHour,inDateTimeString + 8,2);
	strncpy(tmpMinute,inDateTimeString + 10,2);
	strncpy(tmpSecond,inDateTimeString + 12,2);
        this->mVariables.mYear = atoi(tmpYear);
        this->mVariables.mMonth = atoi(tmpMonth);
        this->mVariables.mDay = atoi(tmpDay);
        this->mVariables.mHour = atoi(tmpHour);
        this->mVariables.mMinute = atoi(tmpMinute);
        this->mVariables.mSecond = atoi(tmpSecond);
        return;
}



OpDateTime::OpDateTime(const OpDateTime & inSource)
{
        this->mVariables.mYear = inSource.mVariables.mYear;
        this->mVariables.mMonth =inSource.mVariables.mMonth;
        this->mVariables.mDay = inSource.mVariables.mDay;
        this->mVariables.mHour = inSource.mVariables.mHour;
        this->mVariables.mMinute = inSource.mVariables.mMinute;
        this->mVariables.mSecond = inSource.mVariables.mSecond;
        return;
}



OpDateTime::~OpDateTime()
{
        return;
}



void OpDateTime::AddOne(const enum OpDateTimeIncrements inWhichToIncrement)
{
	int * tmpNewValuePointer;
	switch (inWhichToIncrement)
	{
		case year:
			this->mVariables.mYear++;
			tmpNewValuePointer = &(this->mVariables.mYear);
			break;
		case month:
			this->mVariables.mMonth++;
			tmpNewValuePointer = &(this->mVariables.mMonth);
			break;
		case day:
			this->mVariables.mDay++;
			tmpNewValuePointer = &(this->mVariables.mDay);
			break;
		case hour:
			this->mVariables.mHour++;
			tmpNewValuePointer = &(this->mVariables.mHour);
			break;
		case minute:
			this->mVariables.mMinute++;
			tmpNewValuePointer = &(this->mVariables.mMinute);
			break;
		case second:
			this->mVariables.mSecond++;
			tmpNewValuePointer = &(this->mVariables.mSecond);
			break;
	}
	// The following handles cases where new day
	// does not exist in new month -  greater than last day
	if (((inWhichToIncrement == month) || (inWhichToIncrement == year)) && (this->mVariables.mDay > this.GetMaximum(day)))
		this->mVariables.mDay = this.GetMaximum(day);
	if ((inWhichToIncrement != year) && (*tmpNewValuePointer > (this.GetMaximum(inWhichToIncrement))))
	{
		*tmpNewValuePointer=(this.GetMinimum(inWhichToIncrement));
		AddOne( (enum OpDateTimeIncrements) (inWhichToIncrement - 1));
	}
        return;
}


void OpDateTime::SubtractOne(const enum OpDateTimeIncrements inWhichToDecrement)
{
	int * tmpNewValuePointer;
	switch (inWhichToDecrement)
	{
		case year:
			this->mVariables.mYear--;
			tmpNewValuePointer = &(this->mVariables.mYear);
			break;
		case month:
			this->mVariables.mMonth--;
			tmpNewValuePointer = &(this->mVariables.mMonth);
			break;
		case day:
			this->mVariables.mDay--;
			tmpNewValuePointer = &(this->mVariables.mDay);
			break;
		case hour:
			this->mVariables.mHour--;
			tmpNewValuePointer = &(this->mVariables.mHour);
			break;
		case minute:
			this->mVariables.mMinute--;
			tmpNewValuePointer = &(this->mVariables.mMinute);
			break;
		case second:
			this->mVariables.mSecond--;
			tmpNewValuePointer = &(this->mVariables.mSecond);
			break;
	}
	if (((inWhichToDecrement == month) || (inWhichToDecrement == year)) && (this->mVariables.mDay > (this.GetMaximum(month))))
		this->mVariables.mDay = this.GetMaximum(day);
	if ((inWhichToDecrement != year) && (*tmpNewValuePointer < (this.GetMinimum(inWhichToDecrement))))
	{
		*tmpNewValuePointer=this.GetMaximum(inWhichToDecrement);
		SubtractOne( (enum OpDateTimeIncrements) (inWhichToDecrement - 1));
	}
        return;
}



char * OpDateTime::GetString()
{
	static char tmpReturnedString[15];
	sprintf (tmpReturnedString,"%4.4d%2.2d%2.2d%2.2d%2.2d%2.2d",this->mVariables.mYear,this->mVariables.mMonth,this->mVariables.mDay,this->mVariables.mHour,this->mVariables.mMinute,this->mVariables.mSecond);
	tmpReturnedString[15] = 0;
	return tmpReturnedString;
}



bool OpDateTime::IsLeapYear()
{
	if (	(((this->mVariables.mYear)%4) == 0) &&
		(!((((this->mVariables.mYear)%100) == 0) &&
		(((this->mVariables.mYear)%400) != 0)))		)
		return true;
	else
		return false;
}



int OpDateTime::GetMinimum(const enum OpDateTimeIncrements inIncrement)
{
	static const int kMinimum[6] = {-9999,1,1,0,0,0};
	return kMinimum[(int) inIncrement];
}



int OpDateTime::GetMaximum(const enum OpDateTimeIncrements inIncrement)
{
	static const int kMaximum[6] = {9999,12,99,23,59,59};
	static const int kMaximumDaysInMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};
	if (inIncrement == day)
	{
		if ((this.IsLeapYear()) && ((this->mVariables.mMonth) == 2))
			return 29;
		else
			return kMaximumDaysInMonth[(this->mVariables.mMonth) - 1];
	}
	else
		return kMaximum[(int) inIncrement];
}



void OpDateTime::RoundToNearest(const enum OpDateTimeIncrements inWhichToRoundTo)
{
	if (inWhichToRoundTo != second)
	{
		int * tmpValuePointer = PointerToDateTimeVariable((enum OpDateTimeIncrements) (inWhichToRoundTo + 1));
		if (*tmpValuePointer > (((this.GetMaximum((enum OpDateTimeIncrements) (inWhichToRoundTo+1))) - (this.GetMinimum((enum OpDateTimeIncrements) (inWhichToRoundTo + 1))))/2))
			AddOne(inWhichToRoundTo);
		for (int x=inWhichToRoundTo+1;x<(second+1);x++)
		{
			tmpValuePointer = PointerToDateTimeVariable((enum OpDateTimeIncrements) x);
			*tmpValuePointer = GetMinimum((enum OpDateTimeIncrements) x);
		}
	}
	else
		// No rounding of seconds; the nearest second is this one!
	return;
}



int * OpDateTime::PointerToDateTimeVariable(const enum OpDateTimeIncrements inWhichToPointTo)
{
	static int * tmpValuePointer;
	switch (inWhichToPointTo)
	{
	case year:
		tmpValuePointer = &(this->mVariables.mYear);
		break;
	case month:
		tmpValuePointer = &(this->mVariables.mMonth);
		break;
	case day:
		tmpValuePointer = &(this->mVariables.mDay);
		break;
	case hour:
		tmpValuePointer = &(this->mVariables.mHour);
		break;
	case minute:
		tmpValuePointer = &(this->mVariables.mMinute);
		break;
	case second:
		tmpValuePointer = &(this->mVariables.mSecond);
		break;
	}
	return tmpValuePointer;
}



//                                      END OF FILE