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

/*

 * Copyright (c) 2005,2006 INRIA

 * Copyright (c) 2007 Emmanuelle Laprise

 *

 * 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/global-value.h"

#include "ns3/enum.h"

#include "ns3/string.h"

#include "ns3/object.h"

#include "ns3/config.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 GlobalValue g_precisionDefaultValue ("TimeStepPrecision", 

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

                                            EnumValue (NS),

                                            MakeEnumChecker (NS, "NS",

                                                             S, "S",

                                                             MS, "MS",

                                                             US, "US",

                                                             PS, "PS",

                                                             FS, "FS")

                                            );

precision_t

Get (void)

{

  EnumValue v;

  g_precisionDefaultValue.GetValue (v);

  return (precision_t) v.Get ();

}

void 

Set (precision_t precision)

{

  g_precisionDefaultValue.SetValue (EnumValue (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

    std::istringstream iss;

    iss.str (s.substr(0, n));

    double r;

    iss >> r;

    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

  std::istringstream iss;

  iss. str (s);

  double v;

  iss >> v;

  m_data = HighPrecision (v * 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, const Time & 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;

}

std::istream& operator>> (std::istream& is, Time & time)

{

  std::string value;

  is >> value;

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

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

    {

      is.setstate (std::ios_base::failbit);

      return is;

    }

  std::string trailer = value.substr(n, value.size ()-n);

  std::istringstream iss;

  iss.str (value.substr(0, n));

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

    {

      double v;

      iss >> v;

      time = Seconds (v);

      return is;

    }

  uint64_t integer;

  iss >> integer;

  if (is.bad () || is.fail ())

    {

      is.setstate (std::ios_base::failbit);

    }

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

    {

      time = MilliSeconds (integer);

    }

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

    {

      time = MicroSeconds (integer);

    }

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

    {

      time = NanoSeconds (integer);

    }

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

    {

      time = PicoSeconds (integer);

    }

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

    {

      time = FemtoSeconds (integer);

    }

  else

    {

      is.setstate (std::ios_base::failbit);

    }

  return is;

}

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;

}

ATTRIBUTE_VALUE_IMPLEMENT (Time);

ATTRIBUTE_CHECKER_IMPLEMENT (Time);

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 result = true;

  Time t0, t1;

  CheckOld(&result);

  t0 = MilliSeconds ((uint64_t)10.0);

  t1 = MilliSeconds ((uint64_t)11.0);

  CheckOperations(t0, t1, &result);

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

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

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

  CheckConversions((uint64_t)5, &result);

  CheckConversions((uint64_t)0, &result);

  CheckConversions((uint64_t)783, &result);

  CheckConversions((uint64_t)1132, &result);

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

  // Now vary the precision and check the conversions

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

    result = false;

  }

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

  CheckConversions((uint64_t)7, &result);

  CheckConversions((uint64_t)546, &result);

  CheckConversions((uint64_t)6231, &result);

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

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

  CheckConversions((uint64_t)3, &result);

  CheckConversions((uint64_t)134, &result);

  CheckConversions((uint64_t)2341, &result);

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

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

  CheckConversions((uint64_t)4, &result);

  CheckConversions((uint64_t)342, &result);

  CheckConversions((uint64_t)1327, &result);

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

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

  CheckConversions((uint64_t)12, &result);

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

  CheckConversions((uint64_t)7, &result);

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

  CheckConversions((uint64_t)5, &result);