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

/*

 * Copyright (c) 2008 INESC Porto

 *

 * 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: Gustavo Carneiro  <gjc@inescporto.pt>

 */

#include <cstdlib>

#include "pyviz.h"

#include "ns3/simulator.h"

#include "ns3/config.h"

#include "ns3/node-list.h"

#include "ns3/wifi-net-device.h"

#include "ns3/ppp-header.h"

#include "ns3/wifi-mac-header.h"

#include "ns3/ethernet-header.h"

#include "ns3/log.h"

#include "ns3/abort.h"

#include "visual-simulator-impl.h"

#include <sstream>

NS_LOG_COMPONENT_DEFINE ("PyViz");

#define NUM_LAST_PACKETS 10

static

std::vector<std::string>

PathSplit (std::string str)

{

  std::vector<std::string> results;

  size_t cutAt;

  while ((cutAt = str.find_first_of ('/')) != str.npos)

    {

      if(cutAt > 0)

        {

          results.push_back (str.substr (0,cutAt));

        }

      str = str.substr (cutAt+1);

    }

  if (str.length () > 0)

    {

      results.push_back (str);

    }

  return results;

}

namespace ns3 {

static PyViz* g_visualizer = NULL;

struct PyVizPacketTag : public Tag

{

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer buf) const;

  virtual void Deserialize (TagBuffer buf);

  virtual void Print (std::ostream &os) const;

  PyVizPacketTag ();

  uint32_t m_packetId;

};

TypeId 

PyVizPacketTag::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::PyVizPacketTag")

    .SetParent<Tag> ()

    .SetGroupName ("Visualizer")

    .AddConstructor<PyVizPacketTag> ()

  ;

  return tid;

}

TypeId 

PyVizPacketTag::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

uint32_t 

PyVizPacketTag::GetSerializedSize (void) const

{

  return 4;

}

void 

PyVizPacketTag::Serialize (TagBuffer buf) const

{

  buf.WriteU32 (m_packetId);

}

void 

PyVizPacketTag::Deserialize (TagBuffer buf)

{

  m_packetId = buf.ReadU32 ();

}

void 

PyVizPacketTag::Print (std::ostream &os) const

{

  os << "PacketId=" << m_packetId;

}

PyVizPacketTag::PyVizPacketTag ()

  : Tag () 

{

}

PyViz::PyViz ()

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT (g_visualizer == NULL);

  g_visualizer = this;

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx",

                   MakeCallback (&PyViz::TraceNetDevTxWifi, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx",

                   MakeCallback (&PyViz::TraceNetDevRxWifi, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacTx",

                   MakeCallback (&PyViz::TraceNetDevTxCsma, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacRx",

                   MakeCallback (&PyViz::TraceNetDevRxCsma, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacPromiscRx",

                   MakeCallback (&PyViz::TraceNetDevPromiscRxCsma, this));

  Config::Connect ("/NodeList/*/DeviceList/*/TxQueue/Drop",

                   MakeCallback (&PyViz::TraceDevQueueDrop, this));

  Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Drop",

                   MakeCallback (&PyViz::TraceIpv4Drop, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/MacTx",

                   MakeCallback (&PyViz::TraceNetDevTxPointToPoint, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/MacRx",

                   MakeCallback (&PyViz::TraceNetDevRxPointToPoint, this));

  // WiMax

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Tx",

                   MakeCallback (&PyViz::TraceNetDevTxWimax, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Rx",

                   MakeCallback (&PyViz::TraceNetDevRxWimax, this));

  // LTE

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Tx",

                   MakeCallback (&PyViz::TraceNetDevTxLte, this));

  Config::Connect ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Rx",

                   MakeCallback (&PyViz::TraceNetDevRxLte, this));

}

void

PyViz::RegisterCsmaLikeDevice (std::string const &deviceTypeName)

{

  TypeId::LookupByName (deviceTypeName); // this will assert if the type name is invalid

  std::ostringstream sstream;

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/MacTx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevTxCsma, this));

  sstream.str ("");

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/Rx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevRxCsma, this));

  sstream.str ("");

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/PromiscRx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevPromiscRxCsma, this));

}

void

PyViz::RegisterWifiLikeDevice (std::string const &deviceTypeName)

{

  TypeId::LookupByName (deviceTypeName); // this will assert if the type name is invalid

  std::ostringstream sstream;

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/Tx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevTxWifi, this));

  sstream.str ("");

  sstream <<"/NodeList/*/DeviceList/*/$" << deviceTypeName << "/Rx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevRxWifi, this));

}

void

PyViz::RegisterPointToPointLikeDevice (std::string const &deviceTypeName)

{

  TypeId::LookupByName (deviceTypeName); // this will assert if the type name is invalid

  std::ostringstream sstream;

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/TxQueue/Dequeue";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevTxPointToPoint, this));

  sstream.str ("");

  sstream << "/NodeList/*/DeviceList/*/$" << deviceTypeName << "/Rx";

  Config::Connect (sstream.str (), MakeCallback (&PyViz::TraceNetDevRxPointToPoint, this));

}

void

PyViz::SetPacketCaptureOptions (uint32_t nodeId, PacketCaptureOptions options)

{

  NS_LOG_DEBUG ("  SetPacketCaptureOptions " << nodeId

                                             << " PacketCaptureOptions (headers size = " << options.headers.size ()

                                             << " mode = " << options.mode << " numLastPackets = " << options.numLastPackets

                                             << ")");

  m_packetCaptureOptions[nodeId] = options;

}

void

PyViz::RegisterDropTracePath (std::string const &tracePath)

{

  Config::Connect (tracePath, MakeCallback (&PyViz::TraceDevQueueDrop, this));

}

PyViz::~PyViz ()

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT (g_visualizer == this);

  g_visualizer = NULL;

}

void PyViz::DoPause (std::string const &message)

{

  m_pauseMessages.push_back (message);

  m_stop = true;

  NS_LOG_LOGIC (Simulator::Now ().GetSeconds () << ": Have "

                                                << g_visualizer->m_pauseMessages.size () << " pause messages");

}

void PyViz::Pause (std::string const &message)

{

  NS_ASSERT (g_visualizer);

  g_visualizer->DoPause (message);

}

std::vector<std::string>

PyViz::GetPauseMessages () const

{

  NS_LOG_LOGIC (Simulator::Now ().GetSeconds () << ": GetPauseMessages: have "

                                                << g_visualizer->m_pauseMessages.size () << " pause messages");

  return m_pauseMessages;

}

void

PyViz::CallbackStopSimulation ()

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_runUntil <= Simulator::Now ())

    {

      Simulator::Stop (Seconds (0)); // Stop right now

      m_stop = true;

    }

}

void

PyViz::SimulatorRunUntil (Time time)

{

  NS_LOG_LOGIC ("SimulatorRunUntil " << time << " (now is " << Simulator::Now () << ")");

  m_pauseMessages.clear ();

  m_transmissionSamples.clear ();

  m_packetDrops.clear ();

  Time expirationTime = Simulator::Now () - Seconds (10);

  // Clear very old transmission records

  for (std::map<TxRecordKey, TxRecordValue>::iterator iter = m_txRecords.begin ();

       iter != m_txRecords.end ();)

    {

      if (iter->second.time < expirationTime)

        {

          m_txRecords.erase (iter++);

        }

      else

        {

          iter++;

        }

    }

  // Clear very old packets of interest

  for (std::map<uint32_t, Time>::iterator iter = m_packetsOfInterest.begin ();

       iter != m_packetsOfInterest.end ();)

    {

      if (iter->second < expirationTime)

        {

          m_packetsOfInterest.erase (iter++);

        }

      else

        {

          iter++;

        }

    }

  if (Simulator::Now () >= time)

    {

      return;

    }

  // Schedule a dummy callback function for the target time, to make

  // sure we stop at the right time.  Otherwise, simulations with few

  // events just appear to "jump" big chunks of time.

  NS_LOG_LOGIC ("Schedule dummy callback to be called in " << (time - Simulator::Now ()));

  m_runUntil = time;

  m_stop = false;

  Simulator::ScheduleWithContext (0xffffffff, time - Simulator::Now (), &PyViz::CallbackStopSimulation, this);

  Ptr<SimulatorImpl> impl = Simulator::GetImplementation ();

  Ptr<VisualSimulatorImpl> visualImpl = DynamicCast<VisualSimulatorImpl> (impl);

  if (visualImpl)

    {

      visualImpl->RunRealSimulator ();

    }

  else

    {

      impl->Run ();

    }

}

bool PyViz::TransmissionSampleKey::operator < (PyViz::TransmissionSampleKey const &other) const

{

  if (this->transmitter < other.transmitter)

    {

      return true;

    }

  if (this->transmitter != other.transmitter)

    {

      return false;

    }

  if (this->receiver < other.receiver)

    {

      return true;

    }

  if (this->receiver != other.receiver)

    {

      return false;

    }

  if (this->channel < other.channel)

    {

      return true;

    }

  else

    {

      return false;

    }

}

bool PyViz::TransmissionSampleKey::operator == (PyViz::TransmissionSampleKey const &other) const

{

  bool retval = (transmitter == other.transmitter) &&

    (receiver == other.receiver) &&

    (channel == other.channel);

  return retval;

}

PyViz::NetDeviceStatistics &

PyViz::FindNetDeviceStatistics (int node, int interface)

{

  std::map<uint32_t, std::vector<NetDeviceStatistics> >::iterator nodeStatsIter = m_nodesStatistics.find (node);

  std::vector<NetDeviceStatistics> *stats;

  if (nodeStatsIter == m_nodesStatistics.end ())

    {

      stats = &m_nodesStatistics[node];

      stats->resize (NodeList::GetNode (node)->GetNDevices ());

    }

  else

    {

      stats = &(nodeStatsIter->second);

    }

  NetDeviceStatistics &devStats = (*stats)[interface];

  return devStats;

}

bool PyViz::GetPacketCaptureOptions (uint32_t nodeId, const PacketCaptureOptions **outOptions) const

{

  std::map<uint32_t, PacketCaptureOptions>::const_iterator iter = m_packetCaptureOptions.find (nodeId);

  if (iter == m_packetCaptureOptions.end ())

    {

      return false;

    }

  else

    {

      *outOptions = &iter->second;

      return true;

    }

}

bool PyViz::FilterPacket (Ptr<const Packet> packet, const PacketCaptureOptions &options)

{

  switch (options.mode)

    {

    case PACKET_CAPTURE_DISABLED:

      return false;

    case PACKET_CAPTURE_FILTER_HEADERS_OR:

      {

        PacketMetadata::ItemIterator metadataIterator = packet->BeginItem ();

        while (metadataIterator.HasNext ())

          {

            PacketMetadata::Item item = metadataIterator.Next ();

            if (options.headers.find (item.tid) != options.headers.end ())

              {

                return true;

              }

          }

        return false;

      }

    case PACKET_CAPTURE_FILTER_HEADERS_AND:

      {

        std::set<TypeId> missingHeaders (options.headers);

        PacketMetadata::ItemIterator metadataIterator = packet->BeginItem ();

        while (metadataIterator.HasNext ())

          {

            PacketMetadata::Item item = metadataIterator.Next ();

            std::set<TypeId>::iterator missingIter = missingHeaders.find (item.tid);

            if (missingIter != missingHeaders.end ())

              {

                missingHeaders.erase (missingIter);

              }

          }

        if (missingHeaders.size () == 0)

          {

            return true;

          }

        else

          {

            return false;

          }

      }

    default:

      NS_FATAL_ERROR ("should not be reached");

      return false;

    }

}

void

PyViz::TraceDevQueueDrop (std::string context, Ptr<const Packet> packet)

{

  NS_LOG_FUNCTION (context << packet->GetUid ());

  std::vector<std::string> splitPath = PathSplit (context);

  int nodeIndex = std::atoi (splitPath[1].c_str ());

  Ptr<Node> node = NodeList::GetNode (nodeIndex);

  if (m_nodesOfInterest.find (nodeIndex) == m_nodesOfInterest.end ())

    {

      // if the transmitting node is not "of interest", we still

      // record the transmission if it is a packet of interest.

      if (m_packetsOfInterest.find (packet->GetUid ()) == m_packetsOfInterest.end ())

        {

          NS_LOG_DEBUG ("Packet " << packet->GetUid () << " is not of interest");

          return;

        }

    }

  // ---- "last packets"

  const PacketCaptureOptions *captureOptions;

  if (GetPacketCaptureOptions (nodeIndex, &captureOptions) && FilterPacket (packet, *captureOptions))

    {

      LastPacketsSample &last = m_lastPackets[nodeIndex];

      PacketSample lastPacket;

      lastPacket.time = Simulator::Now ();

      lastPacket.packet = packet->Copy ();

      lastPacket.device = NULL;

      last.lastDroppedPackets.push_back (lastPacket);

      while (last.lastDroppedPackets.size () > captureOptions->numLastPackets)

        {

          last.lastDroppedPackets.erase (last.lastDroppedPackets.begin ());

        }

    }

  std::map<Ptr<Node>, uint32_t>::iterator iter = m_packetDrops.find (node);

  if (iter == m_packetDrops.end ())

    {

      m_packetDrops[node] = packet->GetSize ();

    }

  else

    {

      iter->second += packet->GetSize ();

    }

}

void

PyViz::TraceIpv4Drop (std::string context, ns3::Ipv4Header const &hdr, Ptr<const Packet> packet,

                      ns3::Ipv4L3Protocol::DropReason reason, Ptr<Ipv4> dummy_ipv4, uint32_t interface)

{

  Ptr<Packet> packetCopy = packet->Copy ();

  packetCopy->AddHeader (hdr);

  TraceDevQueueDrop (context, packetCopy);

}

// --------- TX device tracing -------------------

void

PyViz::TraceNetDevTxCommon (std::string const &context, Ptr<const Packet> packet,

                            Mac48Address const &destinationAddress)

{

  NS_LOG_FUNCTION (context << packet->GetUid () << *packet);

  std::vector<std::string> splitPath = PathSplit (context);