/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  This is a project specific source file for building the 
*                clock related functions as part of librt library.
*
*/


#include <time.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <e32std.h>
#include <sys/_timeval.h>
#include <sys/types.h>

#include "lposix.h"

#define UNIX_BASE	TTime(MAKE_TINT64(0x00dcddb3,0x0f2f8000))    // 00:00, Jan 1st 1970

#define BOUNDARY_CHECK(rqtp) ( (rqtp->tv_nsec != 0 && rqtp->tv_nsec < 1000) || \
							   rqtp->tv_nsec >= 1000000000L )\

extern "C" {

//Returns the resolution (granularity) of a clock
//This value is placed in a (non-NULL) *res
EXPORT_C int clock_getres(clockid_t clock_id, struct timespec* res)
{
	int retval = -1;
	//We expect the user of the library to give us a valid pointer	
	if(res == NULL)
		{
		return 0; //no strict reactions please.
		}
			
	switch (clock_id) 
		{
		case CLOCK_REALTIME:
			//Since Symbian OS is not realtime,we simulate the same using
			//the available wall clock whose resolution is upto microseconds
			res->tv_sec = 0;
			res->tv_nsec = 1000;
			retval = 0;
			break;
		
		default:
			//For all other clocks that cannot be supported or invalid clockids,
			//we set errno to not-supported
			retval = -1;
			errno = EINVAL;
			break;
		}
		
	return retval;
}

//Allow the calling process to retrieve the value used by a clock which 
//is specified by clock_id
EXPORT_C int clock_gettime (clockid_t clock_id, struct timespec *tp)
{
	int retval = -1;
	TTime t;
	TTimeIntervalSeconds iSeconds;
	TInt err;
	//We expect the user of the library to give us a valid pointer	
	if(tp == NULL)
		{
		errno = EFAULT;
		return retval;
		}

	switch(clock_id)
		{
		case CLOCK_REALTIME:
			//Since Symbian OS is not realtime,we simulate the same using
			//the available wall clock.We use TTime::HomeTime() call to get
			//the wall clock time
			t.HomeTime();
			err = t.SecondsFrom(UNIX_BASE, iSeconds); //TODO check for the negative tests..
			if (!err)
				{
				t-=iSeconds;//extracting seconds info into iSeconds 			
				tp->tv_sec = iSeconds.Int();
				tp->tv_nsec = t.Int64();
				retval = 0;
				}
			break;
		
		default:
			//For all other clocks that cannot be supported or invalid clockids,
			//we set errno to invalid
			retval = -1;
			errno = EINVAL;
			break;
		}
	return retval;
}


//The clock_settime allow the calling process to set the value used by a 
//clock which is specified by  clock_id
EXPORT_C int clock_settime (clockid_t clock_id, const struct timespec *tp)
{
	int retval = -1;
	TTime t(MAKE_TINT64 (0x00dcddb3 ,0x0f2f8000)) ;  // 00:00, Jan 1st 1970
	TInt err;
	TInt64 microtime;
	
	if(tp == NULL)
		{
		errno = EFAULT;
		return retval;
		}
			
	//Check for boundary values of seconds and microseconds
	if (BOUNDARY_CHECK(tp))
		{
		errno = EINVAL;
		return retval;
		}

	switch(clock_id)
		{
		case CLOCK_REALTIME:
			//We support only the wall-clock,hence use the 
			//User::SetHomeTime call to set the time
			t+=(TTimeIntervalSeconds)tp->tv_sec;
			microtime = (tp->tv_nsec)/1000;
			t+=(TTimeIntervalMicroSeconds)microtime;        
			err = User::SetUTCTime(t);
			if(err)
				{
				MapError(err,errno);
				break;
				}
			else
				retval = 0;	
			break;
			
		default:
			//For all other clocks that cannot be supported or invalid clockids,
			//we set errno to invalid
			retval = -1;
			errno = EINVAL;
			break;
		}	
		
	return retval;
}


//Returns the clock ID of the CPU-time clock of the process specified by pid
EXPORT_C int clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
{
	int retval = -1;

	if(clock_id == NULL)
		{
		errno = EFAULT;
		return retval;
		}
			
	/* We don't allow any process ID but our own.  */
	if (pid == 0)
		{
		//The only available clock is the realtime wall clock
		//Hence we set the clockid to that
		*clock_id = CLOCK_REALTIME;
		retval = 0;
		}
	else
		errno = ESRCH;
	
	return retval;
}


//clock_nanosleep will not be interrupted by the signal emulation. 
//hence EINTR is not valid here. 

EXPORT_C int clock_nanosleep(clockid_t clock_id, int flags,
       const struct timespec *rqtp, struct timespec */*rmtp*/)
{
	int retval = -1;
	
	if(rqtp == NULL)
		{
		errno = EFAULT;
		return retval;
		}
			
	//Check for boundary values of seconds and microseconds
	if (BOUNDARY_CHECK(rqtp))
		{
		errno = EINVAL;
		return retval;
		}
		
	switch(clock_id)
		{
		case CLOCK_REALTIME:
			{
			switch(flags)
				{
				case TIMER_ABSTIME:
					{
					TTime lSetTime(MAKE_TINT64 (0x00dcddb3 ,0x0f2f8000)) ;  // 00:00, Jan 1st 1970				
						
					lSetTime+=(TTimeIntervalSeconds)rqtp->tv_sec;
					lSetTime+=(TTimeIntervalMicroSeconds)(rqtp->tv_nsec/1000);
						
					User::At(lSetTime);
					}
					break;
				
				default:
					{
					unsigned long timeout;
					timeout = (1000000 * rqtp->tv_sec) + (rqtp->tv_nsec /1000);
					User::AfterHighRes(timeout);
					}
					break;
				}
			}
			retval = 0;
			break;
				
		default:
			//For all other clocks that cannot be supported or invalid clockids,
			//we set errno to invalid
			retval = -1;
			errno = EINVAL;
			break;
		}
		
	return retval;	
}
} // extern "C"

//EOF