#include <iostream>

#include <algorithm>

#include <map>

#include "ns3/object.h"

#include "ns3/pointer.h"

#include "ns3/object-vector.h"

#include "ns3/config.h"

#include "ns3/log.h"

#include "ns3/global-value.h"

#include "ns3/string.h"

#include "ns3/node-container.h"

#include "ns3/csma-channel.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("PrintIntrospectedDoxygen");

namespace

{

  std::string anchor;                        ///< hyperlink anchor

  std::string boldStart;                     ///< start of bold span

  std::string boldStop;                      ///< end of bold span

  std::string breakBoth;                     ///< linebreak

  std::string breakHtmlOnly;                 ///< linebreak for html output only

  std::string breakTextOnly;                 ///< linebreak for text output only

  std::string brief;                         ///< brief tag

  std::string commentStart;                  ///< start of code comment

  std::string commentStop;                   ///< end of code comment

  std::string defgroupAttributeListStart;    ///< start of AttributeList group

  std::string defgroupAttributeListStop;     ///< end of AttributeList group

  std::string defgroupGlobalValueListStart;  ///< start of GlobalValueList group

  std::string defgroupGlobalValueListStop;   ///< end of GlobalValueList group

  std::string defgroupTraceSourceListStart;  ///< start of TraceSourceList group

  std::string defgroupTraceSourceListStop;   ///< end of TraceSourceList group

  std::string flagSpanStart;                 ///< start of Attribute flag value

  std::string flagSpanStop;                  ///< end of Attribute flag value

  std::string functionStart;                 ///< start of a class/function

  std::string functionStop;                  ///< end of a class/function

  std::string headingStart;                  ///< start of section heading (h3)

  std::string headingStop;                   ///< end of section heading (h3)

  std::string indentHtmlOnly;                ///< small indent

  std::string ingroupConstructs;             ///< add to constructs group

  std::string listStart;                     ///< start unordered list

  std::string listStop;                      ///< end unordered list

  std::string listLineStart;                 ///< start unordered list item

  std::string listLineStop;                  ///< end unordered list item

  std::string reference;                     ///< reference tag

  std::string temporaryCharacter;            ///< "%" placeholder

} // anonymous namespace

void

PrintAttributes (TypeId tid, std::ostream &os)

{

  os << listStart << std::endl;

  for (uint32_t j = 0; j < tid.GetAttributeN (); j++)

    {

      struct TypeId::AttributeInformation info = tid.GetAttribute(j);

      os << listLineStart << boldStart << info.name << boldStop << ": "

		<< info.help << std::endl;

      os << "  " << listStart << std::endl 

	 << "    " << listLineStart << "Set with class: " << reference << info.checker->GetValueTypeName () << listLineStop << std::endl;

      if (info.checker->HasUnderlyingTypeInformation ())

	{

	  os << "    " << listLineStart << "Underlying type: ";

	  if (    (info.checker->GetValueTypeName () != "ns3::EnumValue")

	       && (info.checker->GetUnderlyingTypeInformation () != "std::string")

	      )

	    {

	      os << reference;

	    }

	  os << info.checker->GetUnderlyingTypeInformation () << listLineStop << std::endl;

	}

      if (info.flags & TypeId::ATTR_CONSTRUCT && info.accessor->HasSetter ())

	{

	  os << "    " << listLineStart << "Initial value: " << info.initialValue->SerializeToString (info.checker) << listLineStop << std::endl;

	}

      os << "    " << listLineStart << "Flags: ";

      if (info.flags & TypeId::ATTR_CONSTRUCT && info.accessor->HasSetter ())

	{

	  os << flagSpanStart << "construct " << flagSpanStop;

	}

      if (info.flags & TypeId::ATTR_SET && info.accessor->HasSetter ())

	{

	  os << flagSpanStart << "write " << flagSpanStop;

	}

      if (info.flags & TypeId::ATTR_GET && info.accessor->HasGetter ())

	{

	  os << flagSpanStart << "read " << flagSpanStop;

	}

      os << listLineStop << std::endl;

      os << "  " << listStop << " " << std::endl;

    }

  os << listStop << std::endl;

}

void

PrintTraceSources (TypeId tid, std::ostream &os)

{

  os << listStart << std::endl;

  for (uint32_t i = 0; i < tid.GetTraceSourceN (); ++i)

    {

      struct TypeId::TraceSourceInformation info = tid.GetTraceSource (i);

      os << listLineStart << boldStart << info.name << boldStop << ": "

	 << info.help

	 << std::endl;

      os << listLineStop << std::endl;

    }

  os << listStop << std::endl;

}

/**

 * Gather aggregation and configuration path information from registered types.

 */

class StaticInformation

{

public:

  /**

   * Record the a -> b aggregation relation.

   *

   * \param a [in] the source(?) TypeId name

   * \param b [in] the destination(?) TypeId name

   */

  void RecordAggregationInfo (std::string a, std::string b);

  /**

   * Gather aggregation and configuration path information for tid

   *

   * \param tid [in] the TypeId to gather information from

   */

  void Gather (TypeId tid);

  /**

   * Print output in "a -> b" form on std::cout

   */

  void Print (void) const;

  /**

   * \return the configuration paths for tid

   *

   * \param tid [in] the TypeId to return information for

   */

  std::vector<std::string> Get (TypeId tid);

private:

  /**

   * \return the current configuration path

   */

  std::string GetCurrentPath (void) const;

  /**

   * Gather attribute, configuration path information for tid

   *

   * \param tid [in] the TypeId to gather information from

   */

  void DoGather (TypeId tid);

  /**

   *  Record the current config path for tid.

   *

   * \param tid [in] the TypeId to record.

   */

  void RecordOutput (TypeId tid);

  /**

   * \return whether the tid has already been processed

   *

   * \param tid [in] the TypeId to check.

   */

  bool HasAlreadyBeenProcessed (TypeId tid) const;

  /**

   * (Inplace) find and replace all instances of string

   *

   * \param source [inout] string to search and replace in

   * \param find [in] string to search for

   * \param replace [in] string to insert in place of find

   */

  void find_and_replace (std::string &source, const std::string find, std::string replace );

  /**

   * Configuration path for each TypeId

   */

  std::vector<std::pair<TypeId,std::string> > m_output;

  /**

   * Current configuration path

   */

  std::vector<std::string> m_currentPath;

  /**

   * List of TypeIds we've already processed

   */

  std::vector<TypeId> m_alreadyProcessed;

  /**

   * List of aggregation relationships.

   */

  std::vector<std::pair<TypeId,TypeId> > m_aggregates;

};

void 

StaticInformation::RecordAggregationInfo (std::string a, std::string b)

{

  m_aggregates.push_back (std::make_pair (TypeId::LookupByName (a), TypeId::LookupByName (b)));

}

void 

StaticInformation::Print (void) const

{

  for (std::vector<std::pair<TypeId,std::string> >::const_iterator i = m_output.begin (); i != m_output.end (); ++i)

    {

      std::pair<TypeId,std::string> item = *i;

      std::cout << item.first.GetName () << " -> " << item.second << std::endl;

    }

}

std::string

StaticInformation::GetCurrentPath (void) const

{

  std::ostringstream oss;

  for (std::vector<std::string>::const_iterator i = m_currentPath.begin (); i != m_currentPath.end (); ++i)

    {

      std::string item = *i;

      oss << "/" << item;

    }

  return oss.str ();

}

void

StaticInformation::RecordOutput (TypeId tid)

{

  m_output.push_back (std::make_pair (tid, GetCurrentPath ()));

}

bool

StaticInformation::HasAlreadyBeenProcessed (TypeId tid) const

{

  for (uint32_t i = 0; i < m_alreadyProcessed.size (); ++i)

    {

      if (m_alreadyProcessed[i] == tid)

	{

	  return true;

	}

    }

  return false;

}

std::vector<std::string> 

StaticInformation::Get (TypeId tid)

{

  std::vector<std::string> paths;

  for (uint32_t i = 0; i < m_output.size (); ++i)

    {

      std::pair<TypeId,std::string> tmp = m_output[i];

      if (tmp.first == tid)

	{

	  paths.push_back (tmp.second);

	}

    }

  return paths;

}

void

StaticInformation::Gather (TypeId tid)

{

  DoGather (tid);

  std::sort (m_output.begin (), m_output.end ());

  m_output.erase (std::unique (m_output.begin (), m_output.end ()), m_output.end ());

}

void 

StaticInformation::DoGather (TypeId tid)

{

  NS_LOG_FUNCTION (this);

  if (HasAlreadyBeenProcessed (tid))

    {

      return;

    }

  RecordOutput (tid);

  for (uint32_t i = 0; i < tid.GetAttributeN (); ++i)

    {

      struct TypeId::AttributeInformation info = tid.GetAttribute(i);

      const PointerChecker *ptrChecker = dynamic_cast<const PointerChecker *> (PeekPointer (info.checker));

      if (ptrChecker != 0)

        {

          TypeId pointee = ptrChecker->GetPointeeTypeId ();

	  // See if this is a pointer to an Object.

	  Ptr<Object> object = CreateObject<Object> ();

	  TypeId objectTypeId = object->GetTypeId ();

	  if (objectTypeId == pointee)

	    {

	      // Stop the recursion at this attribute if it is a

	      // pointer to an Object, which create too many spurious

	      // paths in the list of attribute paths because any

	      // Object can be in that part of the path.

	      continue;

	    }

          m_currentPath.push_back (info.name);

          m_alreadyProcessed.push_back (tid);

          DoGather (pointee);

          m_alreadyProcessed.pop_back ();

          m_currentPath.pop_back ();

          continue;

        }

      // attempt to cast to an object vector.

      const ObjectPtrContainerChecker *vectorChecker = dynamic_cast<const ObjectPtrContainerChecker *> (PeekPointer (info.checker));

      if (vectorChecker != 0)

        {

          TypeId item = vectorChecker->GetItemTypeId ();

          m_currentPath.push_back (info.name + "/[i]");

          m_alreadyProcessed.push_back (tid);

          DoGather (item);

          m_alreadyProcessed.pop_back ();

          m_currentPath.pop_back ();

          continue;

        }

    }

  for (uint32_t j = 0; j < TypeId::GetRegisteredN (); j++)

    {

      TypeId child = TypeId::GetRegistered (j);

      if (child.IsChildOf (tid))

        {

          //please take a look at the following note for an explanation 

          std::string childName = "$" + temporaryCharacter + child.GetName ();

          std::string replaceWith = "::" + temporaryCharacter;

          find_and_replace(childName,"::",replaceWith);

          m_currentPath.push_back (childName);

          m_alreadyProcessed.push_back (tid);

          DoGather (child);

          m_alreadyProcessed.pop_back ();

          m_currentPath.pop_back ();

        }

    }

  for (uint32_t k = 0; k < m_aggregates.size (); ++k)

    {

      std::pair<TypeId,TypeId> tmp = m_aggregates[k];

      if (tmp.first == tid || tmp.second == tid)

        {

          TypeId other;

          if (tmp.first == tid)

            {

              other = tmp.second;

            }

          if (tmp.second == tid)

            {

              other = tmp.first;

            }

          /**

           * Note: for the Doxygen version only, we insert a % in the

           * path below to ensure that doxygen does not attempt to

           * resolve the typeid names included in the string.  if the

           * name contains ::, using the % sign will remove that sign

           * resulting for instance in $ns3MobilityModel instead of

           * $ns3::MobilityModel hence the output must be in the form

           * $%ns3::%MobilityModel in order to show correctly

           * $ns3::MobilityModel We add at the beginning of the name

           * $% and we replace all the :: in the string by ::%.

           */  

          std::string name = "$" + temporaryCharacter + other.GetName ();

          //finding and replacing :: by ::% (for Doxygen version only).

          std::string replaceWith = "::" + temporaryCharacter;

          find_and_replace(name,"::",replaceWith);

          m_currentPath.push_back (name);

          m_alreadyProcessed.push_back (tid);

          DoGather (other);

          m_alreadyProcessed.pop_back ();

          m_currentPath.pop_back ();	  

        }

    }

}

void 

StaticInformation::find_and_replace( std::string &source, const std::string find, std::string replace )

{

  size_t j; 

  j = source.find (find);

  while (j != std::string::npos ) 

    {

      source.replace (j, find.length (),replace);

      j = source.find (find,j+1);

    }

}

void

PrintHelp (const char *program_name)

{

  std::cout << "Usage: " << program_name << " [options]" << std::endl

            << std::endl

            << "Options:" << std::endl

            << "  --help        : print these options" << std::endl

            << "  --output-text : format output as plain text" << std::endl;  

}

int main (int argc, char *argv[])

{

  bool outputText = false;

  char *programName = argv[0];

  argv++;

  while (*argv != 0)

    {

      char *arg = *argv;

      if (strcmp (arg, "--help") == 0)

        {

          PrintHelp (programName);

          return 0;

        }

      else if (strcmp(arg, "--output-text") == 0)

        {

          outputText = true;

        }

      else

        {

          // un-recognized command-line argument

          PrintHelp (programName);

          return 0;

        }

      argv++;

    }

  if (outputText)

    {

      anchor                       = "";

      boldStart                    = "";

      boldStop                     = "";

      breakBoth                    = "\n";

      breakHtmlOnly                = "";

      breakTextOnly                = "\n";

      brief                        = "";

      commentStart                 = "===============================================================\n";

      commentStop                  = "";

      defgroupAttributeListStart   = "";

      defgroupAttributeListStop    = "\n";

      defgroupGlobalValueListStart = "";

      defgroupGlobalValueListStop  = "";

      defgroupTraceSourceListStart = "";

      defgroupTraceSourceListStop  = "\n";

      flagSpanStart                = "";

      flagSpanStop                 = "";

      functionStart                = "";

      functionStop                 = "\n\n";

      headingStart                 = "";

      headingStop                  = "";

      indentHtmlOnly               = "";

      ingroupConstructs            = "";

      listStart                    = "";

      listStop                     = "";

      listLineStart                = "    * ";

      listLineStop                 = "";

      reference                    = "";

      temporaryCharacter           = "";

    }

  else

    {

      anchor                       = "\\anchor ";

      boldStart                    = "<b>";

      boldStop                     = "</b>";

      breakBoth                    = "<br>";

      breakHtmlOnly                = "<br>";

      breakTextOnly                = "";

      brief                        = "\\brief ";

      commentStart                 = "/*!";

      commentStop                  = "*/";

      defgroupAttributeListStart   = "\\defgroup AttributeList ";

      defgroupAttributeListStop    = "";

      defgroupGlobalValueListStart = "\\defgroup GlobalValueList ";

      defgroupGlobalValueListStop  = "";

      defgroupTraceSourceListStart = "\\defgroup TraceSourceList ";

      defgroupTraceSourceListStop  = "";

      flagSpanStart                = "<span class=\"mlabel\">";

      flagSpanStop                 = "</span>";

      functionStart                = "\\class ";

      functionStop                 = "";

      headingStart                 = "<h3>";

      headingStop                  = "</h3>";

      indentHtmlOnly               = "  ";

      ingroupConstructs            = "\\ingroup constructs\n";

      listStart                    = "<ul>";

      listStop                     = "</ul>";

      listLineStart                = "<li>";

      listLineStop                 = "</li>";

      reference                    = "\\ref ";

      temporaryCharacter           = "%";

    }

  NodeContainer c; c.Create (1);

  // The below statements register typical aggregation relationships

  // in ns-3 programs, that otherwise aren't picked up automatically