/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2005,2006 INRIA

 * Copyright (c) 2007 Emmanuelle Laprise

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 * TimeStep support by Emmanuelle Laprise <emmanuelle.laprise@bluekazoo.ca>

 */

#include "nstime.h"

#include "ns3/fatal-error.h"

#include "ns3/default-value.h"

#include <math.h>

namespace ns3 {

namespace TimeStepPrecision {

static const uint64_t MS_FACTOR = (uint64_t)pow(10,3);

static const uint64_t US_FACTOR = (uint64_t)pow(10,6);

static const uint64_t NS_FACTOR = (uint64_t)pow(10,9);

static const uint64_t PS_FACTOR = (uint64_t)pow(10,12);

static const uint64_t FS_FACTOR = (uint64_t)pow(10,15);

static uint64_t g_tsPrecFactor = NS_FACTOR;

static EnumDefaultValue<enum precision_t> g_precisionDefaultValue ("TimeStepPrecision", 

                                                                   "The time unit of the internal 64 bit integer time.",

                                                                   NS, "NS",

                                                                   S, "S",

                                                                   MS, "MS",

                                                                   US, "US",

                                                                   PS, "PS",

                                                                   FS, "FS",

                                                                   0, (void *)0);

precision_t

Get (void)

{

  return g_precisionDefaultValue.GetValue ();

}

void 

Set (precision_t precision)

{

  g_precisionDefaultValue.SetValue (precision);

  g_tsPrecFactor = (uint64_t)pow(10, precision);

}

} // namespace TimeStepPrecision

TimeUnit<1>::TimeUnit(const std::string& s)

{

  std::string::size_type n = s.find_first_not_of("0123456789.");

  if (n != std::string::npos)

  { // Found non-numeric

    double r = atof(s.substr(0, n).c_str());

    std::string trailer = s.substr(n, std::string::npos);

    if (trailer == std::string("s"))

    {

      m_data = HighPrecision (r * TimeStepPrecision::g_tsPrecFactor);

      return;

    }

    if (trailer == std::string("ms"))

    {

      m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,3))), 

                              false);

      return;

    }

    if (trailer == std::string("us"))

    {

      m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,6))), 

                              false);

      return;

    }

    if (trailer == std::string("ns"))

    {

      m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,9))), 

                              false);

      return;

    }

    if (trailer == std::string("ps"))

    {

      m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,12))), 

                              false);

      return;

    }

    if (trailer == std::string("fs"))

    {

      m_data = HighPrecision ((int64_t)(r * (TimeStepPrecision::g_tsPrecFactor/pow(10,15))), 

                              false);

      return;

    }

    NS_FATAL_ERROR("Can't Parse Time "<<s);

  }

  //else

  //they didn't provide units, assume seconds

  m_data = HighPrecision (atof(s.c_str()) * TimeStepPrecision::g_tsPrecFactor);

}

double 

TimeUnit<1>::GetSeconds (void) const

{

  double timeValue = GetHighPrecision ().GetDouble ();

  return timeValue/TimeStepPrecision::g_tsPrecFactor;

}

int64_t

TimeUnit<1>::ConvertToUnits (int64_t timeValue, uint64_t unitFactor) const

{

  uint64_t precFactor;

  // In order to avoid conversion to double, precFactor can't be less 1

  if (TimeStepPrecision::g_tsPrecFactor < unitFactor)

    {

      precFactor = unitFactor / TimeStepPrecision::g_tsPrecFactor;

      timeValue = timeValue * precFactor;

    }

  else

    {

      precFactor = TimeStepPrecision::g_tsPrecFactor / unitFactor;

      timeValue = timeValue / precFactor;

    }

  return timeValue;

}

int64_t 

TimeUnit<1>::GetMilliSeconds (void) const

{

  int64_t ts = GetTimeStep();

  int64_t ms = ConvertToUnits(ts, TimeStepPrecision::MS_FACTOR);

  return ms;

}

int64_t 

TimeUnit<1>::GetMicroSeconds (void) const

{

  int64_t ts = GetTimeStep();

  int64_t us = ConvertToUnits(ts, TimeStepPrecision::US_FACTOR);

  return us;

}

int64_t 

TimeUnit<1>::GetNanoSeconds (void) const

{

  int64_t ts = GetTimeStep();

  int64_t ns = ConvertToUnits(ts, TimeStepPrecision::NS_FACTOR);

  return ns;

}

int64_t 

TimeUnit<1>::GetPicoSeconds (void) const

{

  int64_t ts = GetTimeStep();

  int64_t ps = ConvertToUnits(ts, TimeStepPrecision::PS_FACTOR);

  return ps;

}

int64_t 

TimeUnit<1>::GetFemtoSeconds (void) const

{

  int64_t ts = GetTimeStep();

  int64_t fs = ConvertToUnits(ts, TimeStepPrecision::FS_FACTOR);

  return fs;

}

/**

 * This returns the value with the precision returned by TimeStepPrecision::Get

 */

int64_t

TimeUnit<1>::GetTimeStep (void) const

{

  int64_t timeValue = GetHighPrecision ().GetInteger ();

  return timeValue;

}

std::ostream& 

operator<< (std::ostream& os, Time const& time)

{

  std::string unit;

  switch (TimeStepPrecision::Get ()) {

  case TimeStepPrecision::S:

    unit = "s";

    break;

  case TimeStepPrecision::MS:

    unit = "ms";

    break;

  case TimeStepPrecision::US:

    unit = "us";

    break;

  case TimeStepPrecision::NS:

    unit = "ns";

    break;

  case TimeStepPrecision::PS:

    unit = "ps";

    break;

  case TimeStepPrecision::FS:

    unit = "fs";

    break;

  }

  os << time.GetTimeStep () << unit;

  return os;

}

Time Seconds (double seconds)

{

  double d_sec = seconds * TimeStepPrecision::g_tsPrecFactor;

  return Time (HighPrecision (d_sec));

  //  return Time (HighPrecision ((int64_t)d_sec, false));

}

uint64_t

TimeUnit<1>::UnitsToTimestep (uint64_t unitValue, 

                              uint64_t unitFactor)

{

  uint64_t precFactor;

  // In order to avoid conversion to double, precFactor can't be less 1

  if (TimeStepPrecision::g_tsPrecFactor < unitFactor)

    {

      precFactor = unitFactor / TimeStepPrecision::g_tsPrecFactor;

      unitValue = unitValue / precFactor;

    }

  else

    {

      precFactor = TimeStepPrecision::g_tsPrecFactor / unitFactor;

      unitValue = unitValue * precFactor;

    }

  return unitValue;

}

Time MilliSeconds (uint64_t ms)

{

  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ms, TimeStepPrecision::MS_FACTOR);

  return TimeStep(ts);

}

Time MicroSeconds (uint64_t us)

{

  uint64_t ts = TimeUnit<1>::UnitsToTimestep(us, TimeStepPrecision::US_FACTOR);

  return TimeStep(ts);

}

Time NanoSeconds (uint64_t ns)

{

  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ns, TimeStepPrecision::NS_FACTOR);

  return TimeStep(ts);

}

Time PicoSeconds (uint64_t ps)

{

  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ps, TimeStepPrecision::PS_FACTOR);

  return TimeStep(ts);

}

Time FemtoSeconds (uint64_t fs)

{

  uint64_t ts = TimeUnit<1>::UnitsToTimestep(fs, TimeStepPrecision::FS_FACTOR);

  return TimeStep(ts);

}

/*

 * The timestep value passed to this function must be of the precision

 * of TimeStepPrecision::Get

 */

Time TimeStep (uint64_t ts)

{

  return Time (HighPrecision (ts, false));

}

TimeUnit<0>::TimeUnit (double scalar)

  : m_data (HighPrecision (scalar))

{}

double

TimeUnit<0>::GetDouble (void) const

{

  return GetHighPrecision ().GetDouble ();

}

}; // namespace ns3

#ifdef RUN_SELF_TESTS

#include "ns3/test.h"

//#include <iostream>

namespace ns3 {

class TimeTests : public Test

{

public:

  TimeTests ();

  virtual ~TimeTests ();

  virtual bool RunTests (void);

  /*

   * Verifies that a calculated time value is as expected using

   * doubles since GetSeconds() returns a double

   */ 

  void CheckTimeSec(std::string test_id, double actual, double expected, 

                    bool *flag, double precMultFactor = 1, 

                    bool verbose = false);

  /*

   * Verifies that a calculated time value is as expected.

   */ 

  void CheckTime(std::string test_id, int64_t actual, int64_t expected, 

                 bool *flag, double precMultFactor = 1, 

                 bool verbose = false);

  /*

   * Verifies the +, -, * and / operations for the TimeUnit<1> or Time class

   */

  void CheckOperations(Time t0, Time t1, bool *ok, bool verbose = false);

  /*

   * Verifies that the TimeUnit class stores values with the precision

   * set in the variable TimeStepPrecision::Get

   * Checks that overflow and underflow occur at expected numbers

   */

  void CheckPrecision(TimeStepPrecision::precision_t prec, uint64_t val, bool *ok,

                      bool verbose = false);

  /*

   * Verifies that the conversion between units in the class

   * TimeUnit<1> or Time is done correctly. This is verified both when

   * setting and retrieving a Time value

   */

  void CheckConversions(uint64_t tval, bool *ok, bool verbose = false);

  /*

   * These are the old tests that used to be run

   */

  void CheckOld(bool *ok);

};

TimeTests::TimeTests ()

  : Test ("Time")

{}

TimeTests::~TimeTests ()

{}

bool TimeTests::RunTests (void)

{

  bool ok = true;

  Time t0, t1;

  CheckOld(&ok);

  t0 = MilliSeconds ((uint64_t)10.0);

  t1 = MilliSeconds ((uint64_t)11.0);

  CheckOperations(t0, t1, &ok);

  //  t0 = Seconds ((uint64_t)10.0);

  //  t1 = Seconds ((uint64_t)11.0);

  //  CheckOperations(t0, t1, &ok);

  CheckConversions((uint64_t)5, &ok);

  CheckConversions((uint64_t)0, &ok);

  CheckConversions((uint64_t)783, &ok);

  CheckConversions((uint64_t)1132, &ok);

  //  CheckConversions((uint64_t)3341039, &ok);

  // Now vary the precision and check the conversions

  if (TimeStepPrecision::Get () != TimeStepPrecision::NS) {

    ok = false;

  }

  CheckPrecision(TimeStepPrecision::US, 7, &ok);

  CheckConversions((uint64_t)7, &ok);

  CheckConversions((uint64_t)546, &ok);

  CheckConversions((uint64_t)6231, &ok);

  //  CheckConversions((uint64_t)1234639, &ok);

  CheckPrecision(TimeStepPrecision::MS, 3, &ok);

  CheckConversions((uint64_t)3, &ok);

  CheckConversions((uint64_t)134, &ok);

  CheckConversions((uint64_t)2341, &ok);

  //  CheckConversions((uint64_t)8956239, &ok);

  CheckPrecision(TimeStepPrecision::PS, 21, &ok);

  CheckConversions((uint64_t)4, &ok);

  CheckConversions((uint64_t)342, &ok);

  CheckConversions((uint64_t)1327, &ok);

  //  CheckConversions((uint64_t)5439627, &ok);

  CheckPrecision(TimeStepPrecision::NS, 12, &ok);

  CheckConversions((uint64_t)12, &ok);

  CheckPrecision(TimeStepPrecision::S, 7, &ok);

  CheckConversions((uint64_t)7, &ok);

  CheckPrecision(TimeStepPrecision::FS, 5, &ok);

  CheckConversions((uint64_t)5, &ok);

  TimeStepPrecision::Set (TimeStepPrecision::NS);

  return ok;

}

void TimeTests::CheckOld (bool *ok)

{

  double dt0, dt1, dt2;

  int64_t it0, it1;

  Time t0 = Seconds (10.0);

  CheckTimeSec("old 1", t0.GetSeconds(), 10.0, ok);

  Time t1 = Seconds (11.0);

  CheckTimeSec("old 2", t1.GetSeconds(), 11.0, ok);

  t0 = Seconds (1.5);

  CheckTimeSec("old 3", t0.GetSeconds(), 1.5, ok);

  t0 = Seconds (-1.5);

  CheckTimeSec("old 4", t0.GetSeconds(), -1.5, ok);

  t0 = MilliSeconds ((uint64_t)10.0);

  dt0 = t0.GetSeconds();

  CheckTimeSec("old 5", dt0, 0.01, ok);

  t1 = MilliSeconds ((uint64_t)11.0);

  dt1 = t1.GetSeconds();

  CheckTimeSec("old 6", dt1, 0.011, ok);

  Time t2, t3;

  t2 = t1 - t0;

  if (!t2.IsStrictlyPositive ())

    {

      ok = false;

    }

  dt2 = t2.GetSeconds();

  CheckTimeSec("old 7", dt2, dt1-dt0, ok);

  t2 = t1 - t1;

  if (!t2.IsZero ())

    {

      ok = false;

    }

  dt2 = t2.GetSeconds();

  CheckTimeSec("old 8", dt2, dt1-dt1, ok);

  t2 = t0 - t1;

  if (!t2.IsStrictlyNegative ())

    {

      ok = false;

    }

  dt2 = t2.GetSeconds();

  CheckTimeSec("old 9", dt2, dt0-dt1, ok);

  t1 = NanoSeconds(15);

  it0 = t0.GetNanoSeconds();

  it1 = t1.GetNanoSeconds();

  TimeUnit<-2> tu4 = t0 / (t1 * t1 * t1);

  CheckTime("old 10", tu4.GetHighPrecision().GetInteger(), it0 / (it1*it1*it1), 

            ok, 1e9);