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

/*

 * Copyright (c) 2007 INRIA

 * 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>

 */

#include "random-variable-default-value.h"

NS_DEBUG_COMPONENT_DEFINE ("RandomVariableDefaultValue");

namespace ns3 {

RandomVariableDefaultValue::RandomVariableDefaultValue (std::string name,

							std::string help,

							std::string defaultValue)

  : DefaultValueBase (name, help),

    m_defaultValue (defaultValue),

    m_value (defaultValue)

{

  if (!Parse (defaultValue, false, 0))

    {

      NS_FATAL_ERROR ("Invalid Random Variable specification: " << defaultValue);

    }

  DefaultValueList::Add (this);

}

RandomVariable *

RandomVariableDefaultValue::GetCopy (void)

{

  RandomVariable *variable;

  bool ok;

  ok = Parse (m_value, true, &variable);

  NS_ASSERT (ok);

  return variable;

}

double

RandomVariableDefaultValue::ReadAsDouble (std::string value, bool &ok)

{

  double v;

  std::istringstream iss;

  iss.str (value);

  iss >> v;

  ok = !iss.bad () && !iss.fail ();

  return v;

}

bool

RandomVariableDefaultValue::Parse (const std::string &value, 

				   bool mustCreate, RandomVariable **pVariable)

{

  std::string::size_type pos = value.find_first_of(":");

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

    {

      return false;

    }

  bool ok;

  std::string type = value.substr (0, pos);

  std::string v = value.substr (pos+1, std::string::npos);

  if (type == "Constant")

    {

      double constant = ReadAsDouble (v, ok);

      if (mustCreate)

	{

          NS_DEBUG ("create Constant constant=" << constant);

	  *pVariable = new ConstantVariable (constant);

	}

      else

        {

          NS_DEBUG ("parse  Constant constant=" << constant);

        }

      return ok;

    }

  else if (type == "Uniform")

    {

      std::string::size_type maxPos = v.find_first_of(":");

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

	{

	  return false;

	}

      std::string min = v.substr (0, maxPos);

      std::string max = v.substr (maxPos + 1, std::string::npos);

      double minVal;

      double maxVal;

      minVal = ReadAsDouble (min, ok);

      maxVal = ReadAsDouble (max, ok);

      if (mustCreate)

	{

          NS_DEBUG ("create Uniform min=" << min << ", max=" << max);

	  *pVariable = new UniformVariable (minVal, maxVal);

	}

      else

        {

          NS_DEBUG ("parse  Uniform min=" << min << ", max=" << max);

        }

      return ok;

    }

  else

    {

      // XXX parse other types of distributions.

      return false;

    }

}

bool 

RandomVariableDefaultValue::DoParseValue (const std::string &value)

{

  bool ok = Parse (value, false, 0);

  if (ok)

    {

      m_value = value;

    }

  return ok;

}

std::string 

RandomVariableDefaultValue::DoGetType (void) const

{

  return "(Uniform:min:max|Constant:cst)";

}

std::string 

RandomVariableDefaultValue::DoGetDefaultValue (void) const

{

  return m_defaultValue;

}

} // namespace ns3