/* -*- 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)1000;

static const uint64_t US_FACTOR = (uint64_t)1000000;

static const uint64_t NS_FACTOR = (uint64_t)1000000 * (uint64_t)1000;

static const uint64_t PS_FACTOR = (uint64_t)1000000 * (uint64_t)1000000;

static const uint64_t FS_FACTOR = (uint64_t)1000000 * (uint64_t)1000000 * (uint64_t)1000;

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

#include "ns3/test.h"

namespace ns3 {

#define PRECISION(mult) (pow(10,-((double)(ns3::TimeStepPrecision::Get ())))*mult)

#define ASSERT_MSG_EQ(a,b,mult,msg)                                     \

  NS_TEST_ASSERT_MSG_EQ(((a)<((b)-PRECISION(mult)) || (a)>((b)+PRECISION(mult))),false, \

                        msg << " Values are not equal within requested precision range: " << \

                        (a) << "!=" << (b) << " ~ " << PRECISION(mult))

#define ASSERT_MSG_EQ_INT(a,b,mult,msg) \

  ASSERT_MSG_EQ(((int64_t)(a)),((int64_t)(b)),mult,msg)

#define ASSERT_EQ(a,b)                          \

  ASSERT_MSG_EQ(a,b,1,"")

class OldTimeTestCase : public TestCase

{

public:

  OldTimeTestCase();

  virtual bool DoRun (void);

};

OldTimeTestCase::OldTimeTestCase()

  : TestCase("Sanity check of common time operations")

{}

bool 

OldTimeTestCase::DoRun (void)

{  

  NS_TEST_ASSERT_MSG_EQ(TimeStepPrecision::Get(), 

                        TimeStepPrecision::NS,

                        "Invalid precision mode");

  Time t0 = Seconds (10.0);

  ASSERT_EQ(t0.GetSeconds(), 10.0);

  Time t1 = Seconds (11.0);

  ASSERT_EQ(t1.GetSeconds(), 11.0);

  t0 = Seconds (1.5);

  ASSERT_EQ(t0.GetSeconds(), 1.5);

  t0 = Seconds (-1.5);

  ASSERT_EQ(t0.GetSeconds(), -1.5);

  t0 = MilliSeconds ((uint64_t)10.0);

  ASSERT_EQ(t0.GetSeconds(), 0.01);

  t1 = MilliSeconds ((uint64_t)11.0);

  ASSERT_EQ(t1.GetSeconds(), 0.011);

  Time t2, t3;

  t2 = t1 - t0;

  NS_TEST_ASSERT_MSG_EQ(t2.IsStrictlyPositive (),true, "Variable should be positive");

  ASSERT_EQ(t2.GetSeconds(), t1.GetSeconds()-t0.GetSeconds());

  t2 = t1 - t1;

  NS_TEST_ASSERT_MSG_EQ(t2.IsZero (),true, "Variable should be zero");

  ASSERT_EQ(t2.GetSeconds(), t1.GetSeconds()-t1.GetSeconds());

  t2 = t0 - t1;

  NS_TEST_ASSERT_MSG_EQ(t2.IsStrictlyNegative (),true, "Variable should be negative");

  ASSERT_EQ(t2.GetSeconds(), t0.GetSeconds()-t1.GetSeconds());

  Time tmp = MilliSeconds (0);

  NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) == NanoSeconds(0)), true, "Zero is not Zero ?");

  NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) > NanoSeconds(0)), false, "Zero is bigger than Zero ?");

  NS_TEST_ASSERT_MSG_EQ((MilliSeconds (0) < NanoSeconds(0)), false, "Zero is smaller than Zero ?");

  Time t4 = Seconds (10.0) * Scalar (1.5);

  ASSERT_EQ(t4.GetSeconds(), 15.0);

  Time t5 = NanoSeconds (10) * Scalar (1.5);

  ASSERT_EQ(t5.GetNanoSeconds(), 15.0);

  Time t6 = Seconds (10.0) * Scalar (15) / Scalar (10);

  ASSERT_EQ(t6.GetSeconds (), 15.0);

  Time t7 = NanoSeconds (10) * Scalar (15) / Scalar (10);

  ASSERT_EQ(t7.GetNanoSeconds (), 15.0);

  ASSERT_EQ((t1 + t2).GetSeconds (), t1.GetSeconds()+t2.GetSeconds());

  ASSERT_EQ((t1 / t2).GetDouble (), t1.GetSeconds()/t2.GetSeconds());

  return false;

}

class OperationsTimeTestCase : public TestCase

{

public:

  OperationsTimeTestCase();

  virtual bool DoRun(void);

};

OperationsTimeTestCase::OperationsTimeTestCase()

  : TestCase ("Check the +, -, * and / operators for the TimeUnit<1>")

{}

bool

OperationsTimeTestCase::DoRun(void)

{

  // What happens if you set these values ?

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

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

  Time t0 = MilliSeconds(10);

  Time t1 = MilliSeconds(11);

  ASSERT_EQ((t0-t1).GetSeconds(),

            (t0.GetSeconds()-t1.GetSeconds()));

  ASSERT_EQ(((t0-t1) * t0 / t0).GetSeconds(),

            ((t0.GetSeconds()-t1.GetSeconds()) * t0.GetSeconds () / t0.GetSeconds ()));

  ASSERT_EQ(((t0-t1) * t0 / t1).GetSeconds(),

            ((t0.GetSeconds()-t1.GetSeconds()) * t0.GetSeconds () / t1.GetSeconds ()));

  ASSERT_EQ((t0 * (t0-t1) / t1).GetSeconds(),

            (t0.GetSeconds () * (t0.GetSeconds()-t1.GetSeconds()) / t1.GetSeconds ()));

  ASSERT_EQ((t0 * t1 / (t0-t1)).GetSeconds(),

            (t0.GetSeconds () * t1.GetSeconds() / (t0.GetSeconds()-t1.GetSeconds())));

  ASSERT_EQ((t0 * (t1 / (t0-t1))).GetSeconds(),

            (t0.GetSeconds () * (t1.GetSeconds() / (t0.GetSeconds()-t1.GetSeconds()))));