#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
  // by the creation of the above node.  To manually list other common
  // aggregation relationships that you would like to see show up in
  // the list of configuration paths in the doxygen, add additional
  // statements below.
  StaticInformation info;
  info.RecordAggregationInfo ("ns3::Node", "ns3::TcpSocketFactory");
  info.RecordAggregationInfo ("ns3::Node", "ns3::UdpSocketFactory");
  info.RecordAggregationInfo ("ns3::Node", "ns3::PacketSocketFactory");
  info.RecordAggregationInfo ("ns3::Node", "ns3::olsr::RoutingProtocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::MobilityModel");
  info.RecordAggregationInfo ("ns3::Node", "ns3::Ipv4L3Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::ArpL3Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::Icmpv4L4Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::UdpL4Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::Ipv6L3Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::Icmpv6L4Protocol");
  info.RecordAggregationInfo ("ns3::Node", "ns3::TcpL4Protocol");

  // Create a channel object so that channels appear in the namespace
  // paths that will be generated here.
  Ptr<CsmaChannel> csma;
  csma = CreateObject<CsmaChannel> ();

  for (uint32_t i = 0; i < Config::GetRootNamespaceObjectN (); ++i)
    {
      Ptr<Object> object = Config::GetRootNamespaceObject (i);
      info.Gather (object->GetInstanceTypeId ());
    }

  std::map< std::string, uint32_t> nameMap;
  std::map< std::string, uint32_t>::const_iterator nameMapIterator;

  // Create a map from the class names to their index in the vector of
  // TypeId's so that the names will end up in alphabetical order.
  for (uint32_t i = 0; i < TypeId::GetRegisteredN (); i++)
    {
      TypeId tid = TypeId::GetRegistered (i);
      if (tid.MustHideFromDocumentation ())
	{
	  continue;
	}

      // Capitalize all of letters in the name so that it sorts
      // correctly in the map.
      std::string name = tid.GetName ();
      for (uint32_t j = 0; j < name.length (); j++)
	{
	  name[j] = toupper (name[j]);
	}

      // Save this name's index.
      nameMap[name] = i;
    }

  // Iterate over the map, which will print the class names in
  // alphabetical order.
  for (nameMapIterator = nameMap.begin ();
       nameMapIterator != nameMap.end ();
       nameMapIterator++)
    {
      // Get the class's index out of the map;
      uint32_t i = nameMapIterator->second;

      std::cout << commentStart << std::endl;
      TypeId tid = TypeId::GetRegistered (i);
      if (tid.MustHideFromDocumentation ())
	{
	  continue;
	}
      std::cout << functionStart << tid.GetName () << std::endl;
      std::cout << std::endl;
      std::vector<std::string> paths = info.Get (tid);

      // Config --------------
      if (paths.empty ())
	{
	  std::cout << "Doxygen introspection did not find any typical Config paths."
		    << breakBoth << std::endl;
	}
      else
	{
	  std::cout << headingStart
		    << "Config Paths"
		    << headingStop << std::endl;
	  std::cout << std::endl;
	  std::cout << tid.GetName ()
		    << " is accessible through the following paths"
		    << " with Config::Set and Config::Connect:"
		    << std::endl;
	  std::cout << listStart << std::endl;
	  for (uint32_t k = 0; k < paths.size (); ++k)
	    {
	      std::string path = paths[k];
	      std::cout << listLineStart << path
			<< listLineStop  << breakTextOnly << std::endl;
	    }
	  std::cout << listStop << std::endl;
	}  // Config

      // Attributes ----------
      if (tid.GetAttributeN () == 0)
	{
	  std::cout << "No Attributes are defined for this type."
		    << breakBoth << std::endl;
	}
      else
	{
	  std::cout << headingStart << "Attributes"
		    << headingStop  << std::endl;
	  PrintAttributes (tid, std::cout);

	  TypeId tmp = tid.GetParent ();
	  while (tmp.GetParent () != tmp)
	    {
	      if (tmp.GetAttributeN () != 0)
		{
		  std::cout << headingStart
			    << "Attributes defined in parent class "
			    << tmp.GetName ()
			    << headingStop << std::endl;
		  PrintAttributes (tmp, std::cout);
		}
	      tmp = tmp.GetParent ();
	    }
	}  // Attributes

      // Tracing -------------
      if (tid.GetTraceSourceN () == 0)
	{
	  std::cout << "No TraceSources are defined for this type."
		    << breakBoth << std::endl;
	}
      else
	{
	  std::cout << headingStart << "TraceSources"
		    << headingStop  << std::endl;
	  PrintTraceSources (tid, std::cout);
	}
      {
	TypeId tmp = tid.GetParent ();
	while (tmp.GetParent () != tmp)
	  {
	    if (tmp.GetTraceSourceN () != 0)
	      {
		std::cout << headingStart
			  << "TraceSources defined in parent class "
			  << tmp.GetName ()
			  << headingStop << std::endl;
		PrintTraceSources (tmp, std::cout);
	      }
	    tmp = tmp.GetParent ();
	  }
      }
      std::cout << commentStop << std::endl;
    }  // class documentation


  std::cout << commentStart << std::endl
            << ingroupConstructs
            << defgroupTraceSourceListStart << "The list of all trace sources."
	    << defgroupTraceSourceListStop << std::endl;
  for (uint32_t i = 0; i < TypeId::GetRegisteredN (); ++i)
    {
      TypeId tid = TypeId::GetRegistered (i);
      if (tid.GetTraceSourceN () == 0 ||
	  tid.MustHideFromDocumentation ())
	{
	  continue;
	}
      std::cout << boldStart << tid.GetName ()
		<< boldStop  << breakHtmlOnly << std::endl
		<< listStart << std::endl;
      for (uint32_t j = 0; j < tid.GetTraceSourceN (); ++j)
	{
	  struct TypeId::TraceSourceInformation info = tid.GetTraceSource(j);
	  std::cout << listLineStart << info.name << ": " << info.help
		    << listLineStop  << std::endl;
	}
      std::cout << listStop << std::endl;
    }
  std::cout << commentStop << std::endl;

  std::cout << commentStart << std::endl
            << ingroupConstructs
            << defgroupAttributeListStart << "The list of all attributes."
	    << defgroupAttributeListStop  << std::endl;
  for (uint32_t i = 0; i < TypeId::GetRegisteredN (); ++i)
    {
      TypeId tid = TypeId::GetRegistered (i);
      if (tid.GetAttributeN () == 0 ||
	  tid.MustHideFromDocumentation ())
	{
	  continue;
	}
      std::cout << boldStart << tid.GetName ()
		<< boldStop  << breakHtmlOnly << std::endl
		<< listStart << std::endl;
      for (uint32_t j = 0; j < tid.GetAttributeN (); ++j)
	{
	  struct TypeId::AttributeInformation info = tid.GetAttribute(j);
	  std::cout << listLineStart << info.name << ": " << info.help
		    << listLineStop  << std::endl;
	}
      std::cout << listStop << std::endl;
    }
  std::cout << commentStop << std::endl;



  std::cout << commentStart << std::endl
            << ingroupConstructs
            << defgroupGlobalValueListStart << "The list of all global values."
	    << defgroupGlobalValueListStop  << std::endl
            << listStart << std::endl;
  for (GlobalValue::Iterator i = GlobalValue::Begin ();
       i != GlobalValue::End ();
       ++i)
    {
      StringValue val;
      (*i)->GetValue (val);
      std::cout << indentHtmlOnly
		<<   listLineStart
		<<     boldStart
		<<       anchor
		<< "GlobalValue" << (*i)->GetName () << " " << (*i)->GetName ()
		<<     boldStop
		<< ": " << (*i)->GetHelp () << ".  Default value: " << val.Get () << "."
		<<   listLineStop << std::endl;
    }
  std::cout << listStop    << std::endl
	    << commentStop << std::endl;


  return 0;
}
