/* -*- 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 "pyviz.h"

#include "ns3/simulator.h"

#include "ns3/config.h"

#include "ns3/node-list.h"

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 {

PyViz::PyViz ()

{

  Config::Connect ("/NodeList/*/DeviceList/*/Tx", MakeCallback (&PyViz::TraceNetDevTx, this));

  Config::Connect ("/NodeList/*/DeviceList/*/Rx", MakeCallback (&PyViz::TraceNetDevRx, this));

}

PyViz::~PyViz ()

{

}

void

PyViz::SimulatorRunUntil (Time time)

{

  m_transmissionSamples.clear ();

  while (!Simulator::IsFinished () && Simulator::Now () < time)

    {

      Simulator::RunOneEvent ();

    }

}

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

{

  if (transmitter < other.transmitter)

    return true;

  if (transmitter > other.transmitter)

    return false;

  if (receiver < other.receiver)

    return true;

  if (receiver > other.receiver)

    return false;

  return (channel < other.channel);

}

void

PyViz::TraceNetDevTx (std::string context, Ptr<const Packet> packet, Mac48Address address)

{

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

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

  int devIndex = atoi (splitPath[3].c_str ());

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

  Ptr<NetDevice> device = node->GetDevice (devIndex);

  TxRecord record = { node };

  if (address == device->GetBroadcast ())

    {

      TransmissionSampleKey key = { node, NULL, device->GetChannel() };

      TransmissionSampleValue &sample = m_transmissionSamples[key];

      sample.bytes += packet->GetSize ();

    }

  else

    {

      m_txRecords[packet->GetUid ()] = record;

    }

}

void

PyViz::TraceNetDevRx (std::string context, Ptr<const Packet> packet, Mac48Address address)

{

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

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

  int devIndex = atoi (splitPath[3].c_str ());

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

  Ptr<NetDevice> device = node->GetDevice (devIndex);

  Ptr<Channel> channel = device->GetChannel ();

  std::map<uint32_t, TxRecord>::iterator recordIter = m_txRecords.find (packet->GetUid ());

  if (recordIter == m_txRecords.end ())

    {

      return;

    }

  TxRecord &record = recordIter->second;

  TransmissionSampleKey key = { record.srcNode, node, channel };

  TransmissionSampleValue &sample = m_transmissionSamples[key];

  sample.bytes += packet->GetSize ();

  m_txRecords.erase (recordIter);

}

PyViz::TransmissionSampleList

PyViz::GetTransmissionSamples () const

{

  TransmissionSampleList list;

  for (std::map<TransmissionSampleKey, TransmissionSampleValue>::const_iterator

         iter = m_transmissionSamples.begin ();

       iter !=  m_transmissionSamples.end ();

       iter++)

    {

      TransmissionSample sample;

      sample.transmitter = iter->first.transmitter;

      sample.receiver = iter->first.receiver;

      sample.channel = iter->first.channel;

      sample.bytes = iter->second.bytes;

      list.push_back (sample);

    }

  return list;

}

}