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

/*

 * 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: John Abraham<john.abraham@gatech.edu>

 */

// Animation Interface helpers

#include "ns3/animation-interface-helper.h"

namespace ns3 {

AnimPacketInfo::AnimPacketInfo()

  : m_nd (0), m_nRx (0), m_nDrop (0), m_nRxEnd (0), m_fbTx (0), m_lbTx (0)

{

}

AnimPacketInfo::AnimPacketInfo(Ptr<const NetDevice> nd, uint32_t nRx,

                               const Time& fbTx, const Time& lbTx)

  : m_nd (nd), m_nRx (nRx), m_nDrop (0), m_nRxEnd (0),

    m_fbTx (fbTx.GetSeconds ()), m_lbTx (lbTx.GetSeconds ())

{

}

void AnimPacketInfo::AddRxBegin (Ptr<const NetDevice> nd, const Time& fbRx)

{

  m_rx.push_back (AnimRxInfo (nd, fbRx));

}

bool AnimPacketInfo::AddRxEnd (Ptr<const NetDevice> nd, const Time& lbRx)

{

  // Find the RxInfo

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

    {

      if (m_rx[i].m_nd == nd)

        { // Found it

          m_rx[i].m_lbRx = lbRx.GetSeconds ();

          m_nRxEnd++;

          if ((m_nRxEnd + m_nDrop) == m_nRx) return true;  // Got them all

          return false; // Still more rxEnd expected

        }

    }

  // This should not happen, but if so we just bump the drop count

  m_nDrop++;

  if ((m_nRxEnd + m_nDrop) == m_nRx) return true;  // Got them all

  return false; // Still more rxEnd expected

}

void AnimPacketInfo::AddRxDrop ()

{

  m_nDrop++;

}

} // namespace ns3

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

/*

 * 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: John Abraham <john.abraham@gatech.edu>

 */

// Animation Interface helpers

#ifndef _ANIMATION_INTERFACE_HELPER_H_

#define _ANIMATION_INTERFACE_HELPER_H_

#include "ns3/node.h"

#include "ns3/mobility-model.h"

#include "ns3/packet.h"

#include "ns3/simulator.h"

#include <vector>

namespace ns3 {

// We use a PacketInfo structure for wireless traces to keep up

// when each receiver has received packets.  Also a PacketRxInfo

// to keep up with each receiver and the time it received the packet

struct AnimRxInfo

{

  AnimRxInfo(Ptr<const NetDevice> nd, const Time& fbRx)

    : m_nd (nd), m_fbRx (fbRx.GetSeconds ()), m_lbRx (0) {}

  Ptr<const NetDevice> m_nd; // The receiving net device

  double m_fbRx;             // First bit rx time

  double m_lbRx;             // Last bit rx time

};

struct AnimPacketInfo

{

  AnimPacketInfo ();

  AnimPacketInfo(Ptr<const NetDevice> nd, uint32_t nRx,

                 const Time& fbTx, const Time& lbTx);

  void AddRxBegin (Ptr<const NetDevice> nd, const Time& fbRx);

  bool AddRxEnd (Ptr<const NetDevice> nd, const Time& fbRx);

  void AddRxDrop ();

  Ptr<const NetDevice> m_nd;

  uint32_t m_nRx;       // Number of receivers expected

  uint32_t m_nDrop;     // Number of drops

  uint32_t m_nRxEnd;    // Number of rxEnd callbacks

  double   m_fbTx;      // Time of first bit tx

  double   m_lbTx;      // Time of last bit tx

  std::vector<AnimRxInfo> m_rx;

};

} // namespace ns3

#endif

#include <string>

#include <iomanip>

#include <map>

#include "ns3/animation-interface-helper.h"

  StopAnimation ();

}

void AnimationInterface::SetXMLOutput ()

{

  m_xml = true;

  // Find the min/max x/y for the xml topology element

  topo_minX = 0;

  topo_minY = 0;

  topo_maxX = 0;

  topo_maxY = 0;

  bool   first = true;

  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)

    {

      Ptr<Node> n = *i;

      Ptr<MobilityModel> loc = n->GetObject<MobilityModel> ();

      Vector v;

      if (!loc) continue;

      if (loc)

        {

          v = loc->GetPosition ();

        }

      if (first)

        {

          topo_minX = v.x;

          topo_minY = v.y;

          topo_maxX = v.x;

          topo_maxY = v.y;

          first = false;

        }

      else

        {

          topo_minX = min (topo_minX, v.x);

          topo_minY = min (topo_minY, v.y);

          topo_maxX = max (topo_maxX, v.x);

          topo_maxY = max (topo_maxY, v.y);

        }

    }

  if (m_xml)

    { // output the xml headers

      // Compute width/height, and add a small margin

      double w = topo_maxX - topo_minX;

      double h = topo_maxY - topo_minY;

      topo_minX -= w * 0.05;

      topo_minY -= h * 0.05;

      topo_maxX = topo_minX + w * 1.10;

      topo_maxY = topo_minY + h * 1.10;

      ostringstream oss;

      oss << GetXMLOpen_anim (0);

      oss << GetXMLOpen_topology (topo_minX,topo_minY,topo_maxX,topo_maxY);

      WriteN (m_fHandle, oss.str ());

    }

      WriteN (m_fHandle, oss.str ().c_str (), oss.str ().length ());

  if (m_xml)

    {

      WriteN (m_fHandle, GetXMLClose ("topology"));

      Simulator::Schedule (mobilitypollinterval, &AnimationInterface::MobilityAutoCheck, this);

    }

//#if 0 // To be implemented after trace sources are installed

  Config::Connect ("NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxBegin",

                   MakeCallback (&AnimationInterface::PhyTxBeginTrace, this));

  Config::Connect ("NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxEnd",

                   MakeCallback (&AnimationInterface::PhyTxEndTrace, this));

  Config::Connect ("NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxBegin",

                   MakeCallback (&AnimationInterface::PhyRxBeginTrace, this));

  Config::Connect ("NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxEnd",

                   MakeCallback (&AnimationInterface::PhyRxEndTrace, this));

  Config::Connect ("NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop",

                   MakeCallback (&AnimationInterface::PhyRxDropTrace, this));

  Config::ConnectWithoutContext ("/NodeList/1/$ns3::MobilityModel/CourseChange",

                   MakeCallback (&AnimationInterface::MobilityCourseChangeTrace, this));

//#endif

      if (m_xml)

        { // Terminate the anim element

          WriteN (m_fHandle, GetXMLClose ("anim"));

        }

      m_fHandle = 0;

int AnimationInterface::WriteN (int h, const string& st)

{

  return WriteN (h, st.c_str (), st.length ());

}

void AnimationInterface::PhyTxBeginTrace (std::string context,

                                          Ptr<const Packet> p,

                                          Ptr<const Object> nd, 

                                          const Time& txTime, 

                                          uint32_t nReceivers)

{

  // Add a new pending wireless

  Ptr<const NetDevice> ndev =  DynamicCast<const NetDevice>(nd);

  NS_ASSERT (ndev);

  pendingWirelessPackets[p->GetUid ()] =

  AnimPacketInfo (ndev, nReceivers, Simulator::Now (), Simulator::Now () + txTime);

}

void AnimationInterface::PhyTxEndTrace (std::string context,

                                        Ptr<const Packet> p,

                                        Ptr<const Object> nd)

{

}

void AnimationInterface::PhyRxBeginTrace (std::string context,

                                          Ptr<const Packet> p,

                                          Ptr<const Object> nd)

{

  Ptr<const NetDevice> ndev =  DynamicCast<const NetDevice>(nd);

  NS_ASSERT (ndev);

  pendingWirelessPackets[p->GetUid ()].AddRxBegin (ndev, Simulator::Now ());

}

void AnimationInterface::PhyRxEndTrace (std::string context,

                                        Ptr<const Packet> p,

                                        Ptr<const Object> nd)

{

  Ptr<const NetDevice> ndev =  DynamicCast<const NetDevice>(nd);

  NS_ASSERT (ndev);

  uint32_t uid = p->GetUid ();

  AnimPacketInfo& pkt = pendingWirelessPackets[uid];

  if (pkt.AddRxEnd (ndev, Simulator::Now ()))

    {

      //cout << "Packet " << uid << " complete" << endl;

      OutputWirelessPacket (uid, pkt);

      pendingWirelessPackets.erase (pendingWirelessPackets.find (uid));;

    }

}

void AnimationInterface::PhyRxDropTrace (std::string context,

                                         Ptr<const Packet> p,

                                         Ptr<const Object> nd)

{

  pendingWirelessPackets[p->GetUid ()].AddRxDrop ();

}

void AnimationInterface::MobilityCourseChangeTrace (Ptr <const MobilityModel> mobility)

{

  Ptr <Node> n = mobility->GetObject <Node> ();

  if (!n) return;

  if (!mobility) return; 

  Vector v ;

  v = mobility->GetPosition ();

  ostringstream oss; 

  oss << GetXMLOpen_topology (topo_minX,topo_minY,topo_maxX,topo_maxY);

  oss << GetXMLOpenClose_node (0,n->GetId (),v.x,v.y);

  oss << GetXMLClose ("topology");

  WriteN (m_fHandle, oss.str ());

}

void AnimationInterface::MobilityAutoCheck ()

{

  Simulator::Schedule (mobilitypollinterval, &AnimationInterface::MobilityAutoCheck, this);

  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)

    {

      Ptr <Node> n = *i;

      if (!n) continue;

      Ptr <MobilityModel> mobility = n->GetObject <MobilityModel> ();

      if (!mobility) continue;

      Vector v ;

      v = mobility->GetPosition ();

      ostringstream oss;

      oss << GetXMLOpen_topology (topo_minX,topo_minY,topo_maxX,topo_maxY);

      oss << GetXMLOpenClose_node (0,n->GetId (),v.x,v.y);

      oss << GetXMLClose ("topology");

      WriteN (m_fHandle, oss.str ());

    }

}

// Helper to output a wireless packet.

// For now, only the XML interface is supported

void AnimationInterface::OutputWirelessPacket (uint32_t uid, AnimPacketInfo& pktInfo)

{

  if (!m_xml) return;

  ostringstream oss;

  uint32_t nodeId = pktInfo.m_nd->GetNode ()->GetId ();

  double lbTx = pktInfo.m_lbTx;

#if 0 // To be tested

  // This is a hack until the notify tx end is working

  if (lbTx == 0)

    {

      if (pktInfo.m_rx.empty ())

        {

          lbTx = pktInfo.m_fbTx + 100E-6; // 100 microsec

        }

      else

        {

          lbTx = pktInfo.m_fbTx +

            pktInfo.m_rx[0].m_lbRx - pktInfo.m_rx[0].m_fbRx;

        }

    }

#endif

  // Oops, need to figure out about range

  oss << GetXMLOpen_wpacket (0,nodeId,pktInfo.m_fbTx,lbTx,500);

  // Now add each rx

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

    {

      AnimRxInfo& rx = pktInfo.m_rx[i];

      uint32_t rxId = rx.m_nd->GetNode ()->GetId ();

      oss << GetXMLOpenClose_rx (0,rxId,rx.m_fbRx,rx.m_lbRx);

    }

  oss << GetXMLClose ("wpacket");

  WriteN (m_fHandle, oss.str ());

}

// XML Private Helpers

std::string AnimationInterface::GetXMLOpen_anim (uint32_t lp)

{

  ostringstream oss;

  oss <<"<anim lp = \"" << lp << "\" >\n";

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpen_topology (double minX,double minY,double maxX,double maxY)

{

  ostringstream oss;

  oss <<"<topology minX = \"" << minX << "\" minY = \"" << minY

      << "\" maxX = \"" << maxX << "\" maxY = \"" << maxY

      << "\">" << endl;

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpenClose_node (uint32_t lp,uint32_t id,double locX,double locY)

{

  ostringstream oss;

  oss <<"<node lp = \"" << lp << "\" id = \"" << id << "\"" << " locX = \"" 

      << locX << "\" " << "locY = \"" << locY << "\" />\n";

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpenClose_link (uint32_t fromLp,uint32_t fromId, uint32_t toLp, uint32_t toId)

{

  ostringstream oss;

  oss << "<link fromLP = \"0\" fromId = \"" << fromId

      << "\" toLp = \"0\" toId = \"" << toId

      << "\"/>" << endl;

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpen_packet (uint32_t fromLp,uint32_t fromId, double fbTx, double lbTx)

{

  ostringstream oss;

  oss << setprecision (10);

  oss << "<packet fromLp = \"" << fromLp << "\" fromId = \"" << fromId

      << "\" fbTx = \"" << fbTx

      << "\" lbTx = \"" << lbTx

      << "\">" << endl;

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpen_wpacket (uint32_t fromLp,uint32_t fromId, double fbTx, double lbTx, double range)

{

  ostringstream oss;

  oss << setprecision (10);

  oss << "<wpacket fromLp = \"" << fromLp << "\" fromId = \"" << fromId

      << "\" fbTx = \"" << fbTx

      << "\" lbTx = \"" << lbTx

      << "\" range = \"" << range << "\">" << endl;

  return oss.str ();

}

std::string AnimationInterface::GetXMLOpenClose_rx (uint32_t toLp, uint32_t toId, double fbRx, double lbRx)

{

  ostringstream oss;

  oss << setprecision (10);

  oss << "<rx toLp = \"" << toLp <<"\" toId = \"" << toId

      << "\" fbRx = \"" << fbRx

      << "\" lbRx = \"" << lbRx

      << "\"/>" << endl;

  return oss.str ();

}

 * @brief Specify that animation commands are to be written

 * in XML format.

 *

 * @returns none

 */

  void SetXMLOutput ();

/**

  // Write a string to the specified handle;

  int  WriteN (int, const std::string&);

  //Helper to output xml wireless packet

  void OutputWirelessPacket (uint32_t, AnimPacketInfo&);

  void MobilityAutoCheck ();

  void SetMobilityPollInterval (Time t) {mobilitypollinterval = t;}

  bool      m_xml;      // True if xml format desired

  std::map<uint32_t, AnimPacketInfo> pendingWirelessPackets;

// XML helpers

  // Topology element dimensions

  double topo_minX;

  double topo_minY;

  double topo_maxX;

  double topo_maxY;

  std::string GetXMLOpen_anim (uint32_t lp);

  std::string GetXMLOpen_topology (double minX,double minY,double maxX,double maxY);

  std::string GetXMLOpenClose_node (uint32_t lp,uint32_t id,double locX,double locY);

  std::string GetXMLOpenClose_link (uint32_t fromLp,uint32_t fromId, uint32_t toLp, uint32_t toId);

  std::string GetXMLOpen_packet (uint32_t fromLp,uint32_t fromId, double fbTx, double lbTx);

  std::string GetXMLOpenClose_rx (uint32_t toLp, uint32_t toId, double fbRx, double lbRx);

  std::string GetXMLOpen_wpacket (uint32_t fromLp,uint32_t fromId, double fbTx, double lbTx, double range);

  std::string GetXMLClose (std::string name) {return "</" + name + ">\n"; }

  Time mobilitypollinterval;

   * \param Ptr to packet to be transmitted

   * \param Ptr to device used to transmit

   * \param Duration for Transmission

   * \param Number of reeivers for the transmission

   * \param Ptr to packet transmitted

   * \param Ptr to device used to transmit

   * \param Ptr to packet to be dropped before transmission

   * \param Ptr to device used to transmit

   * \param Ptr to packet to be received

   * \param Ptr to device used to receive

   * \param Ptr to packet received

   * \param Ptr to device used to receive

   * \param Ptr to packet to be dropped on reception

   * \param Ptr to device used to receive

   * \param Ptr to packet transmitted

   * \param Ptr to device used to transmit

   * \param Ptr to packet to be dropped before transmission

   * \param Ptr to device used to transmit

   * \param Ptr to packet to be received

   * \param Ptr to device used to receive

   * \param Ptr to packet received

   * \param Ptr to device used to receive

   * \param Ptr to packet to be dropped on reception

   * \param Ptr to device used to receive

  uint32_t nReceivers = 0;

          nReceivers++;

  return nReceivers;

   * returns the number of receivers that will receive the packet

  /**

   * returns the size of m_phyList (number of nodes in range in this channel)

   *

   */

  uint32_t GetPhyListCount () 

    { 

      return m_phyList.size ();

    }