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

/*

 * Copyright (c) 2007 INRIA

 *

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

#include "fatal-error.h"

namespace ns3 {

namespace DefaultValue {

enum BindStatus {

  OK,

  INVALID_VALUE,

  NOT_FOUND

};

static 

enum BindStatus

BindSafe (std::string name, std::string value)

{

  for (DefaultValueList::Iterator i = DefaultValueList::Begin ();

       i != DefaultValueList::End (); i++)

    {

      DefaultValueBase *cur = *i;

      if (cur->GetName () == name)

	{

	  if (!cur->ParseValue (value))

	    {

	      return INVALID_VALUE;

	    }

	  return OK;

	}

    }

  return NOT_FOUND;

}

void

Bind (std::string name, std::string value)

{

  switch (BindSafe (name, value)) {

  case INVALID_VALUE:

    NS_FATAL_ERROR ("Invalid value: "<<name<<"="<<value);

    break;

  case NOT_FOUND:

    NS_FATAL_ERROR ("No registered DefaultValue=\"" << name << "\"");

    break;

  case OK:

    break;

  }

}

}

DefaultValueBase::DefaultValueBase (const std::string &name,

				    const std::string &help)

  : m_name (name),

    m_help (help),

    m_dirty (false)

{}

DefaultValueBase::~DefaultValueBase ()

{}

std::string 

DefaultValueBase::GetName (void) const

{

  return m_name;

}

std::string 

DefaultValueBase::GetHelp (void) const

{

  return m_help;

}

bool 

DefaultValueBase::IsDirty (void) const

{

  return m_dirty;

}

void 

DefaultValueBase::ClearDirtyFlag (void)

{

  m_dirty = false;

}

bool 

DefaultValueBase::ParseValue (const std::string &value)

{

  bool ok = DoParseValue (value);

  if (ok)

    {

      m_dirty = true;

    }

  return ok;

}

std::string 

DefaultValueBase::GetType (void) const

{

  return DoGetType ();

}

std::string 

DefaultValueBase::GetDefaultValue (void) const

{

  return DoGetDefaultValue ();

}

DefaultValueList::Iterator 

DefaultValueList::Begin (void)

{

  return GetList ()->begin ();

}

DefaultValueList::Iterator 

DefaultValueList::End (void)

{

  return GetList ()->end ();

}

void

DefaultValueList::Remove (const std::string &name)

{

  DefaultValueList::List *list = GetList ();

  for (List::iterator i = list->begin (); i != list->end (); /* nothing */)

    {

      if ((*i)->GetName () == name)

        {

          i = list->erase (i);

        }

      else

        {

          i++;

        }

    }

}

void 

DefaultValueList::Add (DefaultValueBase *defaultValue)

{

  GetList ()->push_back (defaultValue);

}

DefaultValueList::List *

DefaultValueList::GetList (void)

{

  static List list;

  return &list;

}

BooleanDefaultValue::BooleanDefaultValue (std::string name,

					  std::string help,

					  bool defaultValue)

  : DefaultValueBase (name, help),

    m_defaultValue (defaultValue),

    m_value (defaultValue)

{

  DefaultValueList::Add (this);

}

bool 

BooleanDefaultValue::GetValue (void) const

{

  return m_value;

}

bool 

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

{

  if (value.compare ("0") == 0 ||

      value.compare ("f") == 0 ||

      value.compare ("false") == 0 ||

      value.compare ("FALSE") == 0) 

    {

      m_value = false;

      return true;

    } 

  else if (value.compare ("1") == 0 ||

	   value.compare ("t") == 0 ||

	   value.compare ("true") == 0 ||

	   value.compare ("TRUE") == 0) 

    {

      m_value = true;

      return true;

    } 

  else 

    {

      return false;

    }

}

std::string 

BooleanDefaultValue::DoGetType (void) const

{

  return "bool";

}

std::string 

BooleanDefaultValue::DoGetDefaultValue (void) const

{

  return m_defaultValue?"true":"false";

}

StringEnumDefaultValue::StringEnumDefaultValue (const std::string &name,

                                                const std::string &help)

  : DefaultValueBase (name, help),

    m_oneDefault (false)

{

  DefaultValueList::Add (this);

}

void 

StringEnumDefaultValue::AddDefaultValue (const std::string &value)

{

  if (m_oneDefault)

    {

      NS_FATAL_ERROR ("More than one default value registered: " << value);

    }

  m_oneDefault = true;

  for (std::list<std::string>::iterator i = m_possibleValues.begin ();

       i != m_possibleValues.end (); i++)

    {

      if (value == *i)

        {

          NS_FATAL_ERROR ("Value already exists: " << value);

        }

    }  

  m_possibleValues.push_back (value);

  m_value = value;

  m_defaultValue = value;

}

void 

StringEnumDefaultValue::AddPossibleValue (const std::string &value)

{

  for (std::list<std::string>::iterator i = m_possibleValues.begin ();

       i != m_possibleValues.end (); i++)

    {

      if (value == *i)

        {

          NS_FATAL_ERROR ("Value already exists: " << value);

        }

    }

  m_possibleValues.push_back (value);

}

std::string 

StringEnumDefaultValue::GetValue (void) const

{

  return m_value;

}

bool 

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

{

  for (std::list<std::string>::iterator i = m_possibleValues.begin ();

       i != m_possibleValues.end (); i++)

    {

      if (value == *i)

        {

          m_value = value;

          return true;

        }

    }

  return false;

}

std::string 

StringEnumDefaultValue::DoGetType (void) const

{

  std::string retval;

  retval += "(";

  for (std::list<std::string>::const_iterator i = m_possibleValues.begin ();

       i != m_possibleValues.end (); i++)

    {

      if (i != m_possibleValues.begin ())

	{

	  retval += "|";

	}

      retval += *i;

    }

  retval += ")";

  return retval;

}

std::string 

StringEnumDefaultValue::DoGetDefaultValue (void) const

{

  return m_defaultValue;

}

CommandDefaultValue::CommandDefaultValue (const std::string &name,

					  const std::string &help,

					  Callback<void> cb)

  : DefaultValueBase (name, help),

    m_cb (cb)

{

  DefaultValueList::Add (this);

}

bool 

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

{

  m_cb ();

  return true;

}

std::string 

CommandDefaultValue::DoGetType (void) const

{

  return "";

}

std::string 

CommandDefaultValue::DoGetDefaultValue (void) const

{

  return "";

}

StringDefaultValue::StringDefaultValue (const std::string &name,

                                        const std::string &help,

                                        const std::string defaultValue)

  : DefaultValueBase (name, help),

    m_defaultValue (defaultValue),

    m_value (defaultValue),

    m_minSize (0),

    m_maxSize (-1)

{

  DefaultValueList::Add (this);

}

StringDefaultValue::StringDefaultValue (const std::string &name,

                                        const std::string &help,

                                        const std::string defaultValue,

                                        int maxSize)

  : DefaultValueBase (name, help),

    m_defaultValue (defaultValue),

    m_value (defaultValue),

    m_minSize (0),

    m_maxSize (maxSize)

{

  DefaultValueList::Add (this);

}

StringDefaultValue::StringDefaultValue (const std::string &name,

                                        const std::string &help,

                                        const std::string defaultValue,

                                        int minSize,

                                        int maxSize)

  : DefaultValueBase (name, help),

    m_defaultValue (defaultValue),

    m_value (defaultValue),

    m_minSize (minSize),

    m_maxSize (maxSize)

{

  DefaultValueList::Add (this);

}

std::string 

StringDefaultValue::GetValue (void) const

{

  return m_value;

}

bool 

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

{

  if ((int)value.size () < m_minSize)

    {

      return false;

    }

  if (m_maxSize != -1 && (int)value.size () > m_maxSize)

    {

      return false;

    }

  m_value = value;

  return true;

}

std::string 

StringDefaultValue::DoGetType (void) const

{

  if (m_maxSize == -1)

    {

      return "string:0";

    }

  else 

    {

      std::ostringstream oss;

      oss << "string:0:" << m_maxSize;

      return oss.str ();

    }

}

std::string 

StringDefaultValue::DoGetDefaultValue (void) const

{

  return m_defaultValue;

}

}//namespace ns3

#ifdef RUN_SELF_TESTS

#include "test.h"

namespace ns3 {

enum MyEnum {

  MY_ENUM_A,

  MY_ENUM_B,

  MY_ENUM_C,

  MY_ENUM_D,

};

class DefaultValueTest : public Test

{

public:

  DefaultValueTest ();

  virtual bool RunTests (void);

};

DefaultValueTest::DefaultValueTest ()

  : Test ("DefaultValue")

{}

bool 

DefaultValueTest::RunTests (void)

{

  bool result = true;

  BooleanDefaultValue a ("bool-a", "help a", true);

  NS_TEST_ASSERT (a.GetValue ());

  DefaultValue::Bind ("bool-a", "false");

  NS_TEST_ASSERT (!a.GetValue ());

  BooleanDefaultValue b ("bool-b", "help b", false);

  DefaultValue::Bind ("bool-b", "true");

  NS_TEST_ASSERT (b.GetValue ());

  DefaultValue::Bind ("bool-b", "0");

  NS_TEST_ASSERT (!b.GetValue ());

  DefaultValue::Bind ("bool-b", "1");

  NS_TEST_ASSERT (b.GetValue ());

  DefaultValue::Bind ("bool-b", "f");

  NS_TEST_ASSERT (!b.GetValue ());

  DefaultValue::Bind ("bool-b", "t");

  NS_TEST_ASSERT (b.GetValue ());

  DefaultValue::Bind ("bool-b", "false");

  NS_TEST_ASSERT (!b.GetValue ());

  NS_TEST_ASSERT_EQUAL (DefaultValue::BindSafe ("bool-b", "tr"), DefaultValue::INVALID_VALUE)

  NumericDefaultValue<int32_t> i ("test-i", "help-i", -1);

  NS_TEST_ASSERT_EQUAL (i.GetValue (), -1);

  DefaultValue::Bind ("test-i", "-2");

  NS_TEST_ASSERT_EQUAL (i.GetValue (), -2);

  DefaultValue::Bind ("test-i", "+2");

  NS_TEST_ASSERT_EQUAL (i.GetValue (), 2);

  NS_TEST_ASSERT_EQUAL (i.GetType (), "int32_t(-2147483648:2147483647)");

  NumericDefaultValue<uint32_t> ui32 ("test-ui32", "help-ui32", 10);

  NS_TEST_ASSERT_EQUAL (ui32.GetType (), "uint32_t(0:4294967295)");

  NumericDefaultValue<int8_t> c ("test-c", "help-c", 10);

  NS_TEST_ASSERT_EQUAL (c.GetValue (), 10);

  DefaultValue::Bind ("test-c", "257");  

  NumericDefaultValue<float> x ("test-x", "help-x", 10.0);

  NumericDefaultValue<double> y ("test-y", "help-y", 10.0);

  DefaultValue::Bind ("test-y", "-3");  

  EnumDefaultValue<enum MyEnum> e ("test-e", "help-e",

				   MY_ENUM_C, "C",

				   MY_ENUM_A, "A",

				   MY_ENUM_B, "B",

				   0, (void*)0);

  NS_TEST_ASSERT_EQUAL (e.GetValue (), MY_ENUM_C);

  DefaultValue::Bind ("test-e", "B");

  NS_TEST_ASSERT_EQUAL (e.GetValue (), MY_ENUM_B);

  NS_TEST_ASSERT_EQUAL (DefaultValue::BindSafe ("test-e", "D"), DefaultValue::INVALID_VALUE);

  class MyEnumSubclass : public EnumDefaultValue<enum MyEnum>

  {

  public:

    MyEnumSubclass () 

      : EnumDefaultValue<enum MyEnum> ("test-e1", "help-e1",

				       MY_ENUM_B, "B",

				       MY_ENUM_A, "A",

				       0, (void*)0)

    {

      AddPossibleValue (MY_ENUM_C, "C");

      AddPossibleValue (MY_ENUM_D, "D");

    }

  } e1 ;

  NS_TEST_ASSERT_EQUAL (e1.GetValue (), MY_ENUM_B);

  DefaultValue::Bind ("test-e1", "D");

  NS_TEST_ASSERT_EQUAL (e1.GetValue (), MY_ENUM_D);

  DefaultValueList::Remove ("test-e1");

  DefaultValueList::Remove ("test-e");

  DefaultValueList::Remove ("bool-b");

  DefaultValueList::Remove ("bool-a");

  DefaultValueList::Remove ("test-i");

  DefaultValueList::Remove ("test-c");

  DefaultValueList::Remove ("test-x");

  DefaultValueList::Remove ("test-y");

  DefaultValueList::Remove ("test-ui32");

  return result;

}

static DefaultValueTest g_default_value_tests;

}//namespace ns3

#endif /* RUN_SELF_TESTS */