// Copyright (c) 1998-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:
// Mapping between EPOC32 time and libc time
// The basic philosophy is to work in time_t units (TInt) which
// will be essentially TTimeIntervalSeconds from the start of Unix time.
// To stay compliant with the C-Standard (with reference to C99 draft), we  
// set the meaning of time_t to be Universal time.
// 
//

#include <e32std.h>
#include <ltime.h>
#include "reent.h"	    // for _ASCTIME_SIZE
#include <sys/time.h>	    // for gettimeofday
#include <time.h>
#include <string.h>	    // for strcpy

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

// Utility routines for converting between representations

#ifdef __SYMBIAN_COMPILE_UNUSED__	
static struct tm& as_struct_tm (const time_t& t, struct tm& res)
    {
    TTime us = UNIX_BASE + TTimeIntervalSeconds(t);
    TDateTime dt = us.DateTime();

    res.tm_sec  = dt.Second();
    res.tm_min  = dt.Minute();
    res.tm_hour = dt.Hour();
    res.tm_mday = dt.Day() + 1;
    res.tm_mon  = dt.Month();
    res.tm_year = dt.Year() - 1900;

    // EPOC32 counts the year day as Jan 1st == day 1
    res.tm_yday = us.DayNoInYear() - 1;

    // EPOC32 counts the weekdays from 0==Monday to 6==Sunday
    res.tm_wday = us.DayNoInWeek() + 1;
    if (res.tm_wday==7)
	    res.tm_wday=0;	// Sunday==0 in a struct tm

    // newlib just sets this field to -1
    // tm_isdst doesn't really make sense here since we don't 
    // know the locale for which to interpret this time.

    res.tm_isdst = -1;

    return res;
    }

static void as_ttime (const struct tm& p, TTime& res, TBool normalise=EFalse)
    {
    TDateTime dt;
    TInt err = dt.Set(p.tm_year+1900, (enum TMonth)p.tm_mon, p.tm_mday-1, 
	p.tm_hour, p.tm_min, p.tm_sec, 0);
    if (err == KErrNone)
	{
	res = dt;
	return;
	}
    if (!normalise)
	{
	res = TInt64(-1);
	return;
	}
    // Try to normalise things (for mktime)
    dt.Set(p.tm_year+1900, EJanuary, 0, 0, 0, 0, 0);
    res = dt;
    res += TTimeIntervalMonths (p.tm_mon);
    res += TTimeIntervalDays   (p.tm_mday-1);
    res += TTimeIntervalHours  (p.tm_hour);
    res += TTimeIntervalMinutes(p.tm_min);
    res += TTimeIntervalSeconds(p.tm_sec);
    }
    
inline void as_ttime (const time_t& p, TTime& res)
    {
    res = UNIX_BASE + TTimeIntervalSeconds(p);
    }
    
#endif //__SYMBIAN_COMPILE_UNUSED__


GLDEF_C time_t as_time_t(const TTime& t)
    {
    TTimeIntervalSeconds res;
    TInt err = t.SecondsFrom(UNIX_BASE, res);
    if (err)
	return -1;
    else
	return res.Int();
    }
    
#ifdef __SYMBIAN_COMPILE_UNUSED__
// Utility routine for formatting a TTime into a descriptor using the
// UNIX ctime format. NB. EPOC32 abbreviations can be up to KMaxDayNameAbb
// and KMaxMonthNameAbb characters (both == 4). The %F is needed to
// force the meanings of %D, %Y etc.

static TDes8& as_string (TTime& t, TDes8& res)
    {
    // UNICODE problem - t.Format operates on TDes => TDes16

#if !defined(_UNICODE)
    TRAPD(err, t.FormatL(res, _L("%F%*E %*N %D %H:%T:%S %Y")));
#else
    TBuf<_ASCTIME_SIZE> unires;
    TRAPD(err, t.FormatL(unires, _L("%F%*E %*N %D %H:%T:%S %Y")));
    if (!err)
	res.Copy(unires);
#endif
    if (err)
	res = _L8("Error\n");
    else
	res.Append('\n');
    return res;
    }
#endif

#ifdef __SYMBIAN_COMPILE_UNUSED__
/*
Intended Usage:	Utility routine for converting from UTC to localtime.
*/
inline time_t toLocal (const time_t aUniversalTime)
    {
#ifndef __SERIES60_MRT_1_0
    TTimeIntervalSeconds offset = User::UTCOffset();
    return aUniversalTime + offset.Int();
#else
    TLocale locale;
    return aUniversalTime + locale.UniversalTimeOffset().Int();
#endif //__SERIES60_MRT_1_0
    }

/*
Intended Usage:	Utility routine for converting from localtime to UTC.
				However, having decided that time_t is always Universal time, toGMT is empty.
*/
inline time_t toGMT (const time_t aLocalTime)
    {
    return aLocalTime;
    }
#endif //__SYMBIAN_COMPILE_UNUSED__

// external interface for the C library

extern "C" {
/*
Intended Usage:	Get current UTC time.
				Get the number of seconds elapsed since 00:00 hours, 
				Jan 1, 1970 UTC from the system clock.
*/
EXPORT_C time_t time (time_t* p)
    {
    TTime t;
    t.UniversalTime();
	
    time_t res = as_time_t(t);
    if (p)
		*p = res;
    return res;
    }


/*
Return number of clock ticks since process start.
Returns the number of clock ticks elapsed.
A macro constant called CLK_TCK defines the relation betwen
clock tick and second (clock ticks per second).
*/

EXPORT_C clock_t clock ()
    {
	int retval=-1;
	RThread proc;
	TTimeIntervalMicroSeconds iMicSecsFromEpoc;
	TInt err=proc.GetCpuTime(iMicSecsFromEpoc);
	
	if(err)
		{
		return retval;
		}
	return I64INT(iMicSecsFromEpoc.Int64());
    }
}// extern "C"