#include "Time.hxx"

#if defined(WIN32)

#define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers

#include <windows.h>

#include <mmsystem.h>

#if (_MSC_VER >= 1400) //no atomic intrinsics on Visual Studio 2003 and below

#include <intrin.h>

#pragma intrinsic(_InterlockedCompareExchange64)

#endif

#endif

#include "rutil/Random.hxx"

#include "rutil/Logger.hxx"

#include "rutil/Lock.hxx"

#define RESIPROCATE_SUBSYSTEM Subsystem::SIP

using namespace resip;

void resip::sleepMs(unsigned int ms)

{

#ifdef WIN32

   Sleep(ms);

#else

   usleep(ms*1000);

#endif

}

void resip::sleepSeconds(unsigned int seconds)

{

#ifdef WIN32

   Sleep(seconds*1000);

#else

   sleep(seconds);

#endif

}

ResipClock::ResipClock(void)

{

}

ResipClock::~ResipClock(void)

{

}

#if defined(WIN32) && defined(_RESIP_MONOTONIC_CLOCK)

unsigned ResipClock::mMaxSystemTimeWaitMs = 60000; //set low initially, may get adjusted by actual timer chosen

#else

unsigned ResipClock::mMaxSystemTimeWaitMs = UINT_MAX;

#endif

#ifdef WIN32

ResipClock::WinMonoClock::PGTC64 ResipClock::WinMonoClock::mGTC64 = &ResipClock::WinMonoClock::GTCLockDuringRange::GTC64;

ResipClock::WinMonoClock::WinMonoClock()

{

   Initialize();

}

void 

ResipClock::WinMonoClock::Initialize(void)

{

   static Mutex mtxStart;

   static volatile bool isInitialized=false;    

   Lock lock(mtxStart);

   if (isInitialized)

   {

      return;

   }

#if defined(_MSC_VER) && (_MSC_VER >= 1400)

   ResipClock::mMaxSystemTimeWaitMs  = GTCInterlocked::GetMaxWaitMs();

   mGTC64 = (PGTC64)&GTCInterlocked::GTC64;

   DebugLog(<< "Using GTCInterlocked::GTC64 as the monotonic clock for time functions.");

#else                

   ResipClock::mMaxSystemTimeWaitMs  = GTCLockDuringRange::GetMaxWaitMs();

   mGTC64 = (PGTC64)&GTCLockDuringRange::GTC64;

   DebugLog(<< "Using GTCLockDuringRange::GTC64 as the monotonic clock for time functions.");

#endif 

   unsigned min=0,max=0,actual=0;

   bool isMono = false;

   ResipClock::queryTimerInfo(min,max,actual,isMono);

   InfoLog(<< "Timer resolution: (min/max/actual/isMonotonic) = " << min << '/' << max << '/' << actual <<

      '/' << ((isMono)?("true"):("false")));

   isInitialized = true;

}

#define IS_ALIGNED(_pointer, _alignment) ((((ULONG_PTR) (_pointer)) & ((_alignment) - 1)) == 0)

uint64_t ResipClock::WinMonoClock::GTCInterlocked::GTC64(void)

{

#if defined(_MSC_VER) && (_MSC_VER >= 1400) //no atomic intrinsics on Visual Studio 2003 and below

   ULARGE_INTEGER timeVal;

   resip_assert(IS_ALIGNED(&mBaseTime,8)); //if the implementation ever changes to use 64-bit atomic read/write then 64-bit alignment will be required.

   //InterlockedCompareExchange64 will issue a LOCK CMPXCHG8B to ensure atomic access to mBaseTime

   //Not the most efficient wat to do a 64-bit atomic read (see fild instruction), but no intrinsic for 64-bit atomic read.

   timeVal.QuadPart = _InterlockedCompareExchange64((LONGLONG volatile *)&mBaseTime,0,0);

   DWORD tickNow = ::timeGetTime();

   if (tickNow != timeVal.LowPart)

   {

      //the difference in the low 32-bits and the current 32-bit timeGetTime will be the time difference from

      //the base time till now.  Integer arithmentic will correctly handle cases where tickNow < timeVal.LowPart (rollover).

      //This diff cannot be greater than 0xFFFFFFFF, so this function must be called more frequently than once

      //every 49.7 days.

      DWORD diff = tickNow - timeVal.LowPart;

      //periodically update the basetime, only really necessary at least once every 49.7 days.

      if (diff > mBaseTimeUpdateInterval)

      {

         ULARGE_INTEGER newVal;

         newVal.QuadPart = timeVal.QuadPart + diff; //any 32-bit rollover is now part of the high 32-bits.

         //don't care if this CAS64 actually writes mBaseTime, as long as at least 1 thread updates mBaseTime.

         _InterlockedCompareExchange64((LONGLONG volatile *)&mBaseTime,(LONGLONG)newVal.QuadPart,(LONGLONG)timeVal.QuadPart);

      }

      timeVal.QuadPart += diff; //any 32-bit rollover is now part of the high 32-bits.

   }

   return timeVal.QuadPart;

#else

   resip_assert(0); //this counter only compiles on Visual Studio 2005 +

   return GTCLock::GTC64();

#endif //#if (_MSC_VER >= 1400) //no atomic intrinsics on Visual Studio 2003 and below

}

volatile uint64_t ResipClock::WinMonoClock::GTCInterlocked::mBaseTime = 0;

uint64_t

ResipClock::WinMonoClock::GTCLock::GTC64(void)

{

   Lock lock(mMutex);

   DWORD tickNow = ::timeGetTime();

   if (tickNow != mBaseTime.LowPart)

   {

      mBaseTime.QuadPart += (tickNow - mBaseTime.LowPart);

   }

   return mBaseTime.QuadPart;

}

ULARGE_INTEGER ResipClock::WinMonoClock::GTCLock::mBaseTime = {0,0};

Mutex ResipClock::WinMonoClock::GTCLock::mMutex;

uint64_t ResipClock::WinMonoClock::GTCLockDuringRange::GTC64(void)

{

   // we assume that this function is called reasonable often

   // monitor wrap around only in dangerous time range:

   // empiric constants

   const DWORD TIMER_BEGIN_SAFE_RANGE = 0xffff; // about one minute after

   const DWORD TIMER_END_SAFE_RANGE = 0xffff0000; // and before wrap around

   DWORD tick = ::timeGetTime();

   if ( ( tick > TIMER_BEGIN_SAFE_RANGE ) && ( tick < TIMER_END_SAFE_RANGE ) )

   {

      LARGE_INTEGER ret;

      ret.HighPart = mWrapCounter;

      ret.LowPart = tick;

      return (uint64_t)ret.QuadPart;

   }

   // most application will never be here - only long running servers

   Lock lock(mWrapCounterMutex);

   if (mPrevTick > tick)

   {

      mWrapCounter++;

   }

   mPrevTick = tick;

   LARGE_INTEGER ret;

   ret.HighPart = mWrapCounter;

   ret.LowPart = tick;

   return (uint64_t)ret.QuadPart;

}

uint32_t   ResipClock::WinMonoClock::GTCLockDuringRange::mWrapCounter = 0;

DWORD    ResipClock::WinMonoClock::GTCLockDuringRange::mPrevTick = 0;

Mutex    ResipClock::WinMonoClock::GTCLockDuringRange::mWrapCounterMutex;

#endif

uint64_t

ResipClock::getSystemTime()

{

   resip_assert(sizeof(uint64_t) == 64/8);

#if defined(WIN32) || defined(UNDER_CE)

#ifdef _RESIP_MONOTONIC_CLOCK

   static ResipClock::WinMonoClock clockInit;

   return WinMonoClock::GetClock64() * 1000;

#else

   FILETIME ft;

#ifdef UNDER_CE

   SYSTEMTIME st;

   ::GetSystemTime(&st);

   ::SystemTimeToFileTime(&st,&ft);

#else

   ::GetSystemTimeAsFileTime(&ft);

#endif

   ULARGE_INTEGER li;

   li.LowPart = ft.dwLowDateTime;

   li.HighPart = ft.dwHighDateTime;

   return li.QuadPart/10;

#endif //_RESIP_MONOTONIC_CLOCK

#else //#if defined(WIN32) || defined(UNDER_CE)

   uint64_t time=0;

#ifdef _RESIP_MONOTONIC_CLOCK

   struct timespec now_monotonic;

   if (clock_gettime( CLOCK_MONOTONIC, &now_monotonic ) == 0)

//   if ( syscall( __NR_clock_gettime, CLOCK_MONOTONIC, &now_monotonic ) == 0 )

   {

      time = now_monotonic.tv_sec;

      time = time*1000000;

      time += now_monotonic.tv_nsec/1000;

      return time;

   }

#endif

   struct timeval now;

   gettimeofday( &now , NULL );

   //assert( now );

   time = now.tv_sec;

   time = time*1000000;

   time += now.tv_usec;

   return time;

#endif

}

uint64_t

ResipClock::getForever()

{

   resip_assert( sizeof(uint64_t) == 8 );

#if defined(WIN32) && !defined(__GNUC__)

   return 18446744073709551615ui64;

#else

   return 18446744073709551615ULL;

#endif

}

uint64_t

ResipClock::getRandomFutureTimeMs( uint64_t futureMs )

{

   uint64_t now = getTimeMs();

   // make r a random number between 5000 and 9000

   int r = Random::getRandom()%4000;

   r += 5000;

   uint64_t ret = now;

   ret += (futureMs*r)/10000;

   resip_assert( ret >= now );

   resip_assert( ret >= now+(futureMs/2) );

   resip_assert( ret <= now+futureMs );

   return ret;

}

void 

ResipClock::queryTimerInfo(unsigned &min, unsigned &max, unsigned &actual, bool &isMonotonic)

{  

   min = max = actual = 0;

   isMonotonic = false;

#if defined(WIN32) 

#if defined(_RESIP_MONOTONIC_CLOCK)

#if !defined(NTSTATUS)

#define NTSTATUS DWORD

#endif

   typedef NTSTATUS (WINAPI*PNTQTR)(PULONG,PULONG,PULONG);  

  HMODULE hm = ::LoadLibrary("ntdll");

   if (hm != NULL)

   {

      PNTQTR ntqtr = (PNTQTR)::GetProcAddress(hm,"NtQueryTimerResolution");

      if (ntqtr)

      {

         ntqtr((PULONG)&min,(PULONG)&max,(PULONG)&actual);

         min /= 10;

         max /= 10;

         actual /= 10;

      }

      ::FreeLibrary(hm);

      hm = NULL;

   }   

   isMonotonic = true;

#else

   DWORD timeAdjustment=0;

  BOOL timeAdjustmentDisabled=0;

   //on Vista it looks like GetSystemTime has 1ms resolution, but GetSystemTimeAdjustment still returns 15ms

   //so just set the min resolution to whatever is reported, no actual resolution can be consistently found.

   ::GetSystemTimeAdjustment(&timeAdjustment,(PDWORD)&min,&timeAdjustmentDisabled);

   min /= 10;

   isMonotonic = false;   

#endif

#else //WIN32

#ifdef __APPLE__

   //@TODO 

#else

   clockid_t clock = CLOCK_REALTIME; //need to test/verify CLOCK_REALTIME returns the gettimeofday resolution.  

#if defined(_RESIP_MONOTONIC_CLOCK)

   clock = CLOCK_MONOTONIC;

   isMonotonic = true;

#endif

   struct timespec res;

   if (clock_getres(clock,&res) == 0)

   {

      actual = (res.tv_sec * 1000000) + (res.tv_nsec / 1000);

   } 

#endif

#endif

}

/* ====================================================================

 * The Vovida Software License, Version 1.0

 *

 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * 3. The names "VOCAL", "Vovida Open Communication Application Library",

 *    and "Vovida Open Communication Application Library (VOCAL)" must

 *    not be used to endorse or promote products derived from this

 *    software without prior written permission. For written

 *    permission, please contact vocal@vovida.org.

 *

 * 4. Products derived from this software may not be called "VOCAL", nor

 *    may "VOCAL" appear in their name, without prior written

 *    permission of Vovida Networks, Inc.

 *

 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND

 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA

 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES

 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * ====================================================================

 *

 * This software consists of voluntary contributions made by Vovida

 * Networks, Inc. and many individuals on behalf of Vovida Networks,

 * Inc.  For more information on Vovida Networks, Inc., please see

 * <http://www.vovida.org/>.

 *

 * vi: set shiftwidth=3 expandtab:

 */