/* -*- 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"

#include <iostream>

namespace ns3 {

AnimPacketInfo::AnimPacketInfo()

  : m_txnd (0), m_nRx (0), m_nRxEnd (0), m_fbTx (0), m_lbTx (0), 

    transmitter_loc (Vector (0,0,0))

{

}

AnimPacketInfo::AnimPacketInfo(Ptr<const NetDevice> nd, const Time& fbTx, 

  const Time& lbTx, Vector txLoc)

  : m_txnd (nd), m_nRx (0), m_nRxEnd (0),

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

    reception_range (0) 

{

}

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

                                 Vector rxLoc)

{

  m_rx[nd->GetNode ()->GetId ()] = AnimRxInfo (fbRx,nd);

  m_nRx++;

  reception_range = std::max (reception_range,CalculateDistance (transmitter_loc,rxLoc));

}

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

{

  uint32_t NodeId = nd->GetNode ()->GetId (); 

  // Find the RxInfo

  if (m_rx.find(NodeId) != m_rx.end ())

    { 

      if (m_rx[NodeId].m_rxnd != nd) 

        {

          return false; 

        }

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

      m_nRxEnd++;

      if (m_nRxEnd == m_nRx) 

        {

          return true;

        }

      return false; // Still more rxEnd expected

    }

  return false; // Still more rxEnd expected

}

void AnimPacketInfo::AddRxDrop (Ptr<const NetDevice> nd)

{

  if (m_rx.find (nd->GetNode ()->GetId ()) == m_rx.end()) 

    {

      return;

    }

  m_rx.erase (m_rx.find (nd->GetNode ()->GetId ()));

  m_nRx--;

}

} // 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>

#include <map>

namespace ns3 {

// We use an AnimPacketInfo structure for wireless traces to keep up

// when each receiver has received packets.  Also an AnimPacketRxInfo

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

struct AnimRxInfo

{

  AnimRxInfo () {};

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

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

  double m_fbRx;             // First bit rx time

  double m_lbRx;             // Last bit rx time

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

};

struct AnimPacketInfo

{

  AnimPacketInfo ();

  AnimPacketInfo(Ptr<const NetDevice> nd,

                 const Time& fbTx, const Time& lbTxi,Vector txLoc);

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

                   Vector rxLoc);

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

  void AddRxDrop (Ptr <const NetDevice> nd);

  Ptr<const NetDevice> m_txnd; //Transmitter NetDevice

  uint32_t m_nRx;       // Number of receivers

  uint32_t m_nRxEnd;    // Number of rxEnd callbacks

  double   m_fbTx;      // Time of first bit tx

  double   m_lbTx;      // Time of last bit tx

  Vector   transmitter_loc;

  double reception_range;

  std::map<uint32_t,AnimRxInfo> m_rx; //collection of receivers

};

} // namespace ns3

#endif

#include <string>

#include <iomanip>

#include <map>

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

  StopAnimation ();

}

void AnimationInterface::SetXMLOutput ()

{

  m_xml = true;

      NS_FATAL_ERROR ("Unable to output Animation output file");

Vector AnimationInterface::GetPosition (Ptr <Node> n)

{

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

  Vector v(0,0,0);

  if (!loc)

    {

      return v;

    }

  if (loc)

    {

      v = loc->GetPosition ();

    }

  return v;

}

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

  topo_minX = 0;

  topo_minY = 0;

  topo_maxX = 1000;

  topo_maxY = 1000;

  bool   first = true;

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

    {

      Ptr<Node> n = *i;

      Vector v = GetPosition (n); 

      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

      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);

    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      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::RecalcTopoBounds (Vector v)

{

  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);

}

Ptr <NetDevice>

AnimationInterface::GetNetDeviceFromContext (std::string context)

{

  // Use "NodeList/*/DeviceList/*/ as reference

  // where element [1] is the Node Id

  // element [2] is the NetDevice Id

  vector <std::string> elements = GetElementsFromContext (context);

  Ptr <Node> n = NodeList::GetNode (atoi (elements[1].c_str ()));

  NS_ASSERT (n);

  return n->GetDevice (atoi (elements[3].c_str ()));

}

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

                                          Ptr<const Packet> p)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context); 

  NS_ASSERT (ndev);

  Ptr <Node> n = ndev->GetNode ();

  NS_ASSERT (n);

  // Add a new pending wireless

  pendingWifiPackets[p->GetUid ()] =

  AnimPacketInfo (ndev, Simulator::Now (), Simulator::Now ()+Seconds(0.5), GetPosition (n));

}

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

                                            Ptr<const Packet> p)

{

}

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

                                          Ptr<const Packet> p)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  // Erase pending wifi

  pendingWifiPackets.erase (pendingWifiPackets.find (p->GetUid ()));

}

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

                                          Ptr<const Packet> p)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  Ptr <Node> n = ndev->GetNode ();

  NS_ASSERT (n);

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

}

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

                                        Ptr<const Packet> p)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  uint32_t uid = p->GetUid ();

  AnimPacketInfo& pkt = pendingWifiPackets[uid];

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

    {

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

      OutputWirelessPacket (uid, pkt);

      pendingWifiPackets.erase (pendingWifiPackets.find (uid));;

    }

}

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

                                         Ptr<const Packet> p)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  pendingWifiPackets[p->GetUid ()].AddRxDrop (ndev);

}

void AnimationInterface::WimaxTxTrace (std::string context, Ptr<const Packet> p, const Mac48Address & m)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  Ptr <Node> n = ndev->GetNode ();

  NS_ASSERT (n);

  pendingWimaxPackets[p->GetUid ()] =

  AnimPacketInfo (ndev, Simulator::Now (), Simulator::Now ()+Seconds(0.5), GetPosition (n));

}

void AnimationInterface::WimaxRxTrace (std::string context, Ptr<const Packet> p, const Mac48Address & m)

{

  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);

  NS_ASSERT (ndev);

  Ptr <Node> n = ndev->GetNode ();

  NS_ASSERT (n);

  uint32_t uid = p->GetUid ();

  AnimPacketInfo& pktinfo = pendingWimaxPackets[uid];

  pktinfo.AddRxBegin (ndev, Simulator::Now (), GetPosition (n));

  pktinfo.AddRxEnd (ndev, Simulator::Now ()+ Seconds (0.0001));

  OutputWirelessPacket (p->GetUid (), pktinfo);

}

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

{

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

  if (!n) return;

  if (!mobility) return; 

  Vector v ;

  v = mobility->GetPosition ();

  RecalcTopoBounds (v);

  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 ();

      RecalcTopoBounds (v);

      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_txnd->GetNode ()->GetId ();

  double lbTx = pktInfo.m_lbTx;

  // Oops, need to figure out about range

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

  // Now add each rx

  map <uint32_t, AnimRxInfo>::iterator p;

  for (p = pktInfo.m_rx.begin (); p != pktInfo.m_rx.end (); p++)

    {

      AnimRxInfo& rx = p->second;

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

      if(rx.m_lbRx)

      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 ();

}

std::vector<std::string> AnimationInterface::GetElementsFromContext (std::string context)

{

  vector <std::string> elements;

  size_t pos1=0, pos2;

  while (pos1 != context.npos)

  {

    pos1 = context.find ("/",pos1);

    pos2 = context.find ("/",pos1+1);

    elements.push_back (context.substr (pos1+1,pos2-(pos1+1)));

    pos1 = pos2; 

    pos2 = context.npos;

  }

  return elements;

}

 * Modified by: John Abraham <john.abraham@gatech.edu>

 * @brief Specify that animation commands are to be written

 * in XML format.

 *

 * @returns none

 */

  void SetXMLOutput ();

/**

private:

  void DevTxTrace (std::string context,

                   Ptr<const Packet> p,

                   Ptr<NetDevice> tx,

                   Ptr<NetDevice> rx,

                   Time txTime,

                   Time rxTime);

  void WifiPhyTxBeginTrace (std::string context,

                        Ptr<const Packet> p);

  void WifiPhyTxEndTrace (std::string context,

                          Ptr<const Packet> p);

  void WifiPhyTxDropTrace (std::string context,

                           Ptr<const Packet> p);

  void WifiPhyRxBeginTrace (std::string context,

                            Ptr<const Packet> p);

  void WifiPhyRxEndTrace (std::string context,

                          Ptr<const Packet> p);

  void WifiPhyRxDropTrace (std::string context,

                           Ptr<const Packet> p);

  // 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> pendingWifiPackets;

  std::map<uint32_t, AnimPacketInfo> pendingWimaxPackets;

  Vector GetPosition (Ptr <Node> n);

  // Recalculate topology bounds

  void RecalcTopoBounds (Vector v);

  // Path helper

  std::vector<std::string> GetElementsFromContext (std::string context);

  Ptr <NetDevice> GetNetDeviceFromContext (std::string context);

  // 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;

def configure (conf) :

	conf.check (header_name='sys/socket.h', define_name='HAVE_SYS_SOCKET_H')

	conf.check (header_name='netinet/in.h', define_name='HAVE_NETINET_IN_H')