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

//

// Copyright (c) 2006 Georgia Tech Research Corporation

//

// 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: Rajib Bhattacharjea<raj.b@gatech.edu>

//

#include <iostream>

#include <math.h>

#include <stdlib.h>

#include <sys/time.h>			// for gettimeofday

#include <unistd.h>

#include <iostream>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>       

#include <sstream>

#include "assert.h"

#include "random-variable.h"

#include "rng-stream.h"

#include "fatal-error.h"

using namespace std;

namespace ns3{

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// RandomVariableBase methods

class RandomVariableBase 

{

public:

  RandomVariableBase ();

  RandomVariableBase (const RandomVariableBase &o);

  virtual ~RandomVariableBase();

  virtual double  GetValue() = 0;

  virtual uint32_t GetInteger();

  virtual RandomVariableBase*   Copy(void) const = 0;

  virtual void GetSeed(uint32_t seed[6]);

  static  void UseDevRandom(bool udr = true);

  static void UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 

                            uint32_t s3, uint32_t s4, uint32_t s5);

  static void SetRunNumber(uint32_t n);

private:

  static void GetRandomSeeds(uint32_t seeds[6]);

private:

  static bool useDevRandom;    // True if using /dev/random desired

  static bool globalSeedSet;   // True if global seed has been specified

  static int  devRandom;       // File handle for /dev/random

  static uint32_t globalSeed[6]; // The global seed to use

  friend class RandomVariableInitializer;

protected:

  static unsigned long heuristic_sequence;

  static RngStream* m_static_generator;

  static uint32_t runNumber;

  static void Initialize();    // Initialize  the RNG system

  static bool initialized;     // True if package seed is set 

  RngStream* m_generator;  //underlying generator being wrapped

};

bool          RandomVariableBase::initialized = false;   // True if RngStream seed set 

bool          RandomVariableBase::useDevRandom = false;  // True if use /dev/random

bool          RandomVariableBase::globalSeedSet = false; // True if GlobalSeed called

int           RandomVariableBase::devRandom = -1;

uint32_t      RandomVariableBase::globalSeed[6];

unsigned long RandomVariableBase::heuristic_sequence;

RngStream*    RandomVariableBase::m_static_generator = 0;

uint32_t      RandomVariableBase::runNumber = 0;

//the static object random_variable_initializer initializes the static members

//of RandomVariable

static class RandomVariableInitializer

{

  public:

  RandomVariableInitializer()

  {

//     RandomVariableBase::Initialize(); // sets the static package seed

//     RandomVariableBase::m_static_generator = new RngStream();

//     RandomVariableBase::m_static_generator->InitializeStream();

  }

  ~RandomVariableInitializer()

  {

    delete RandomVariableBase::m_static_generator;

  }

} random_variable_initializer;

RandomVariableBase::RandomVariableBase() 

  : m_generator(NULL)

{

//   m_generator = new RngStream();

//   m_generator->InitializeStream();

//   m_generator->ResetNthSubstream(RandomVariableBase::runNumber);

}

RandomVariableBase::RandomVariableBase(const RandomVariableBase& r)

  :m_generator(0)

{

  if(r.m_generator)

  {

    m_generator = new RngStream(*r.m_generator);

  }

}

RandomVariableBase::~RandomVariableBase()

{

  delete m_generator;

}

uint32_t RandomVariableBase::GetInteger() 

{

  return (uint32_t)GetValue();

}

void RandomVariableBase::UseDevRandom(bool udr) 

{

  RandomVariableBase::useDevRandom = udr;

}

void RandomVariableBase::GetSeed(uint32_t seed[6])

{

  if(!m_generator)

  {

    m_generator = new RngStream();

    m_generator->InitializeStream();

    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);

  }

  m_generator->GetState(seed);

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// RandomVariableBase static methods

void RandomVariableBase::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 

                                   uint32_t s3, uint32_t s4, uint32_t s5)

{

  if (RandomVariableBase::globalSeedSet)

    {

      cerr << "Random number generator already initialized!" << endl;

      cerr << "Call to RandomVariableBase::UseGlobalSeed() ignored" << endl;

      return;

    }

  RandomVariableBase::globalSeed[0] = s0;

  RandomVariableBase::globalSeed[1] = s1;

  RandomVariableBase::globalSeed[2] = s2;

  RandomVariableBase::globalSeed[3] = s3;

  RandomVariableBase::globalSeed[4] = s4;

  RandomVariableBase::globalSeed[5] = s5;

  if (!RngStream::CheckSeed(RandomVariableBase::globalSeed))

    NS_FATAL_ERROR("Invalid seed");

  RandomVariableBase::globalSeedSet = true;

}

void RandomVariableBase::Initialize()

{ 

  if (RandomVariableBase::initialized) return; // Already initialized and seeded

  RandomVariableBase::initialized = true;

  if (!RandomVariableBase::globalSeedSet)

    { // No global seed, try a random one

      GetRandomSeeds(globalSeed);

    }

  // Seed the RngStream package

  RngStream::SetPackageSeed(globalSeed);

}

void RandomVariableBase::GetRandomSeeds(uint32_t seeds[6])

{

  // Check if /dev/random exists

  if (RandomVariableBase::useDevRandom && RandomVariableBase::devRandom < 0)

    {

      RandomVariableBase::devRandom = open("/dev/random", O_RDONLY);

    }

  if (RandomVariableBase::devRandom > 0)

    { // Use /dev/random

      while(true)

        {

          for (int i = 0; i < 6; ++i)

            {

              read(RandomVariableBase::devRandom, &seeds[i], sizeof(seeds[i]));

            }

          if (RngStream::CheckSeed(seeds)) break; // Got a valid one

        }

    }

  else

    { // Seed from time of day (code borrowed from ns2 random seeding)

      // Thanks to John Heidemann for this technique

      while(true)

        {

          timeval tv;

          gettimeofday(&tv, 0);

          seeds[0] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          gettimeofday(&tv, 0);

          seeds[1] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          gettimeofday(&tv, 0);

          seeds[2] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          gettimeofday(&tv, 0);

          seeds[3] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          gettimeofday(&tv, 0);

          seeds[4] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          gettimeofday(&tv, 0);

          seeds[5] = (tv.tv_sec^tv.tv_usec^(++heuristic_sequence <<8))

              & 0x7fffffff;

          if (RngStream::CheckSeed(seeds)) break; // Got a valid one

        }

    }

}

void RandomVariableBase::SetRunNumber(uint32_t n)

{

  runNumber = n;

}

RandomVariable::RandomVariable()

  : m_variable (0)

{}

RandomVariable::RandomVariable(const RandomVariable&o)

  : m_variable (o.m_variable->Copy ())

{}

RandomVariable::RandomVariable (const RandomVariableBase &variable)

  : m_variable (variable.Copy ())

{}

RandomVariable &

RandomVariable::operator = (const RandomVariable &o)

{

  if (&o == this)

    {

      return *this;

    }

  delete m_variable;

  m_variable = o.m_variable->Copy ();

  return *this;

}

RandomVariable::~RandomVariable()

{

  delete m_variable;

}

double  

RandomVariable::GetValue (void) const

{

  return m_variable->GetValue ();

}

uint32_t 

RandomVariable::GetInteger (void) const

{

  return m_variable->GetInteger ();

}

void 

RandomVariable::GetSeed(uint32_t seed[6]) const

{

  return m_variable->GetSeed (seed);

}

void 

RandomVariable::UseDevRandom(bool udr)

{

  RandomVariableBase::UseDevRandom (udr);

}

void 

RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 

                              uint32_t s3, uint32_t s4, uint32_t s5)

{

  RandomVariableBase::UseGlobalSeed (s0, s1, s2, s3, s4, s5);

}

void 

RandomVariable::SetRunNumber(uint32_t n)

{

  RandomVariableBase::SetRunNumber (n);

}

RandomVariableBase *

RandomVariable::Peek (void) const

{

  return m_variable;

}

RandomVariable::RandomVariable (Attribute value)

  : m_variable (0)

{

  const RandomVariableValue *v = value.DynCast<const RandomVariableValue *> ();

  if (v == 0)

    {

      NS_FATAL_ERROR ("Unexpected type of value. Expected \"RandomVariableValue\"");

    }

  *this = v->Get ();

}

RandomVariable::operator Attribute () const

{

  return Attribute::Create<RandomVariableValue> (*this);

}

ATTRIBUTE_VALUE_IMPLEMENT (RandomVariable);

ATTRIBUTE_CHECKER_IMPLEMENT (RandomVariable);

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// UniformVariableImpl

class UniformVariableImpl : public RandomVariableBase {

public:

  /**

   * Creates a uniform random number generator in the

   * range [0.0 .. 1.0).

   */

  UniformVariableImpl();

  /**

   * Creates a uniform random number generator with the specified range

   * \param s Low end of the range

   * \param l High end of the range

   */

  UniformVariableImpl(double s, double l);

  UniformVariableImpl(const UniformVariableImpl& c);

  double GetMin (void) const;

  double GetMax (void) const;

  /**

   * \return A value between low and high values specified by the constructor

   */

  virtual double GetValue();

  virtual RandomVariableBase*  Copy(void) const;

public:

  /**

   * \param s Low end of the range

   * \param l High end of the range

   * \return A uniformly distributed random number between s and l

   */

  static double GetSingleValue(double s, double l);

private:

  double m_min;

  double m_max;

};

UniformVariableImpl::UniformVariableImpl() 

  : m_min(0), m_max(1.0) { }

UniformVariableImpl::UniformVariableImpl(double s, double l) 

  : m_min(s), m_max(l) { }

UniformVariableImpl::UniformVariableImpl(const UniformVariableImpl& c) 

  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max) { }

double 

UniformVariableImpl::GetMin (void) const

{

  return m_min;

}

double 

UniformVariableImpl::GetMax (void) const

{

  return m_max;

}

double UniformVariableImpl::GetValue()

{

  if(!RandomVariableBase::initialized)

  {

    RandomVariableBase::Initialize();

  }

  if(!m_generator)

  {

    m_generator = new RngStream();

    m_generator->InitializeStream();

    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);

  }

  return m_min + m_generator->RandU01() * (m_max - m_min);

}

RandomVariableBase* UniformVariableImpl::Copy() const

{

  return new UniformVariableImpl(*this);

}

double UniformVariableImpl::GetSingleValue(double s, double l)

{

  if(!RandomVariableBase::m_static_generator)

  {

    RandomVariableBase::Initialize(); // sets the static package seed

    RandomVariableBase::m_static_generator = new RngStream();

    RandomVariableBase::m_static_generator->InitializeStream();

  }

  return s + m_static_generator->RandU01() * (l - s);;

}

UniformVariable::UniformVariable()

  : RandomVariable (UniformVariableImpl ())

{}

UniformVariable::UniformVariable(double s, double l)

  : RandomVariable (UniformVariableImpl (s, l))

{}

double 

UniformVariable::GetSingleValue(double s, double l)

{

  return UniformVariableImpl::GetSingleValue (s, l);

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// ConstantVariableImpl methods

class ConstantVariableImpl : public RandomVariableBase { 

public:

  /**

   * Construct a ConstantVariableImpl RNG that returns zero every sample

   */

  ConstantVariableImpl();

  /**

   * Construct a ConstantVariableImpl RNG that returns the specified value

   * every sample.

   * \param c Unchanging value for this RNG.

   */

  ConstantVariableImpl(double c);

  ConstantVariableImpl(const ConstantVariableImpl& c) ;

  /**

   * \brief Specify a new constant RNG for this generator.

   * \param c New constant value for this RNG.

   */

  void    NewConstant(double c);

  /**

   * \return The constant value specified

   */

  virtual double  GetValue();

  virtual uint32_t GetInteger();

  virtual RandomVariableBase*   Copy(void) const;

private:

  double m_const;

};

ConstantVariableImpl::ConstantVariableImpl() 

  : m_const(0) { }

ConstantVariableImpl::ConstantVariableImpl(double c) 

  : m_const(c) { };

ConstantVariableImpl::ConstantVariableImpl(const ConstantVariableImpl& c) 

  : RandomVariableBase(c), m_const(c.m_const) { }

void ConstantVariableImpl::NewConstant(double c) 

  { m_const = c;}

double ConstantVariableImpl::GetValue()

{

  return m_const;

}

uint32_t ConstantVariableImpl::GetInteger()

{

  return (uint32_t)m_const;

}

RandomVariableBase* ConstantVariableImpl::Copy() const

{

  return new ConstantVariableImpl(*this);

}

ConstantVariable::ConstantVariable()

  : RandomVariable (ConstantVariableImpl ())

{}

ConstantVariable::ConstantVariable(double c)

  : RandomVariable (ConstantVariableImpl (c))