/* -*- 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: George F. Riley<riley@ece.gatech.edu>

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

 * Contributions: Eugene Kalishenko <ydginster@gmail.com> (Open Source and Linux Laboratory http://dev.osll.ru/)

 */

// Interface between ns-3 and the network animator

#include <cstdio>

#include <unistd.h>

#include <sstream>

#include <fstream>

#include <string>

#include <iomanip>

#include <map>

// ns3 includes

#include "ns3/animation-interface.h"

#include "ns3/channel.h"

#include "ns3/config.h"

#include "ns3/node.h"

#include "ns3/mobility-model.h"

#include "ns3/packet.h"

#include "ns3/simulator.h"

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

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

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

#include "ns3/wifi-mac.h"

#include "ns3/constant-position-mobility-model.h"

#include "ns3/lte-ue-phy.h"

#include "ns3/lte-enb-phy.h"

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

#include "ns3/uan-mac.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4-routing-protocol.h"

#include "ns3/energy-source-container.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("AnimationInterface");

// Globals

static bool initialized = false;

// Public methods

AnimationInterface::AnimationInterface (const std::string fn)

  : m_f (0),

    m_routingF (0),

    m_mobilityPollInterval (Seconds (0.25)), 

    m_outputFileName (fn),

    gAnimUid (0), 

    m_writeCallback (0), 

    m_started (false), 

    m_enablePacketMetadata (false), 

    m_startTime (Seconds (0)), 

    m_stopTime (Seconds (3600 * 1000)),

    m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE), 

    m_originalFileName (fn),

    m_routingStopTime (Seconds (0)), 

    m_routingFileName (""),

    m_routingPollInterval (Seconds (5)), 

    m_trackPackets (true)

{

  initialized = true;

  StartAnimation ();

}

AnimationInterface::~AnimationInterface ()

{

  StopAnimation ();

}

void 

AnimationInterface::SkipPacketTracing ()

{

  m_trackPackets = false;

}

void

AnimationInterface::EnableWifiPhyCounters (Time startTime, Time stopTime, Time pollInterval)

{

  m_wifiPhyCountersStopTime = stopTime;

  m_wifiPhyCountersPollInterval = pollInterval;

  m_wifiPhyTxDropCounterId = AddNodeCounter ("WifiPhy TxDrop", AnimationInterface::DOUBLE_COUNTER);

  m_wifiPhyRxDropCounterId = AddNodeCounter ("WifiPhy RxDrop", AnimationInterface::DOUBLE_COUNTER);

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

    {

      Ptr<Node> n = *i;

      m_nodeWifiPhyTxDrop[n->GetId ()] = 0;

      m_nodeWifiPhyRxDrop[n->GetId ()] = 0;

      UpdateNodeCounter (m_wifiPhyTxDropCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_wifiPhyRxDropCounterId, n->GetId (), 0);

    }

  Simulator::Schedule (startTime, &AnimationInterface::TrackWifiPhyCounters, this);

}

void

AnimationInterface::EnableWifiMacCounters (Time startTime, Time stopTime, Time pollInterval)

{

  m_wifiMacCountersStopTime = stopTime;

  m_wifiMacCountersPollInterval = pollInterval;

  m_wifiMacTxCounterId = AddNodeCounter ("WifiMac Tx", AnimationInterface::DOUBLE_COUNTER);

  m_wifiMacTxDropCounterId = AddNodeCounter ("WifiMac TxDrop", AnimationInterface::DOUBLE_COUNTER);

  m_wifiMacRxCounterId = AddNodeCounter ("WifiMac Rx", AnimationInterface::DOUBLE_COUNTER);

  m_wifiMacRxDropCounterId = AddNodeCounter ("WifiMac RxDrop", AnimationInterface::DOUBLE_COUNTER);

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

    {

      Ptr<Node> n = *i;

      m_nodeWifiMacTx[n->GetId ()] = 0;

      m_nodeWifiMacTxDrop[n->GetId ()] = 0;

      m_nodeWifiMacRx[n->GetId ()] = 0;

      m_nodeWifiMacRxDrop[n->GetId ()] = 0;

      UpdateNodeCounter (m_wifiMacTxCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_wifiMacTxDropCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_wifiMacRxCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_wifiMacRxDropCounterId, n->GetId (), 0);

    }

  Simulator::Schedule (startTime, &AnimationInterface::TrackWifiMacCounters, this);

}

void

AnimationInterface::EnableQueueCounters (Time startTime, Time stopTime, Time pollInterval)

{

  m_queueCountersStopTime = stopTime;

  m_queueCountersPollInterval = pollInterval;

  m_queueEnqueueCounterId = AddNodeCounter ("Enqueue", AnimationInterface::DOUBLE_COUNTER);

  m_queueDequeueCounterId = AddNodeCounter ("Dequeue", AnimationInterface::DOUBLE_COUNTER);

  m_queueDropCounterId = AddNodeCounter ("Queue Drop", AnimationInterface::DOUBLE_COUNTER);

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

    {

      Ptr<Node> n = *i;

      m_nodeQueueEnqueue[n->GetId ()] = 0;

      m_nodeQueueDequeue[n->GetId ()] = 0;

      m_nodeQueueDrop[n->GetId ()] = 0;

      UpdateNodeCounter (m_queueEnqueueCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_queueDequeueCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_queueDropCounterId, n->GetId (), 0);

    }

  Simulator::Schedule (startTime, &AnimationInterface::TrackQueueCounters, this);

}

void

AnimationInterface::EnableIpv4L3ProtocolCounters (Time startTime, Time stopTime, Time pollInterval)

{

  m_ipv4L3ProtocolCountersStopTime = stopTime;

  m_ipv4L3ProtocolCountersPollInterval = pollInterval;

  m_ipv4L3ProtocolTxCounterId = AddNodeCounter ("Ipv4 Tx", AnimationInterface::DOUBLE_COUNTER);

  m_ipv4L3ProtocolRxCounterId = AddNodeCounter ("Ipv4 Rx", AnimationInterface::DOUBLE_COUNTER);

  m_ipv4L3ProtocolDropCounterId = AddNodeCounter ("Ipv4 Drop", AnimationInterface::DOUBLE_COUNTER);

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

    {

      Ptr<Node> n = *i;

      m_nodeIpv4Tx[n->GetId ()] = 0;

      m_nodeIpv4Rx[n->GetId ()] = 0;

      m_nodeIpv4Drop[n->GetId ()] = 0;

      UpdateNodeCounter (m_ipv4L3ProtocolTxCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_ipv4L3ProtocolRxCounterId, n->GetId (), 0);

      UpdateNodeCounter (m_ipv4L3ProtocolDropCounterId, n->GetId (), 0);

    }

  Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4L3ProtocolCounters, this);

}

AnimationInterface & 

AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, Time pollInterval)

{

  SetOutputFile (fileName, true);

  m_routingStopTime = stopTime;

  m_routingPollInterval = pollInterval;

  WriteXmlAnim (true);

  Simulator::Schedule (startTime, &AnimationInterface::TrackIpv4Route, this);

  return *this;

}

AnimationInterface & 

AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, NodeContainer nc, Time pollInterval)

{

  m_routingNc = nc;

  return EnableIpv4RouteTracking (fileName, startTime, stopTime, pollInterval);

}

AnimationInterface & 

AnimationInterface::AddSourceDestination (uint32_t fromNodeId, std::string ipv4Address)

{

  Ipv4RouteTrackElement element = { ipv4Address, fromNodeId };

  m_ipv4RouteTrackElements.push_back (element);

  return *this;

}

void 

AnimationInterface::SetStartTime (Time t)

{

  m_startTime = t;

}

void 

AnimationInterface::SetStopTime (Time t)

{

  m_stopTime = t;

}

void 

AnimationInterface::SetMaxPktsPerTraceFile (uint64_t maxPacketsPerFile)

{

  m_maxPktsPerFile = maxPacketsPerFile;

}

uint32_t 

AnimationInterface::AddNodeCounter (std::string counterName, CounterType counterType)

{

  m_nodeCounters.push_back (counterName);

  uint32_t counterId = m_nodeCounters.size () - 1; // counter ID is zero-indexed

  WriteXmlAddNodeCounter (counterId, counterName, counterType);

  return counterId; 

}

uint32_t 

AnimationInterface::AddResource (std::string resourcePath)

{

  m_resources.push_back (resourcePath);

  uint32_t resourceId = m_resources.size () -  1; // resource ID is zero-indexed

  WriteXmlAddResource (resourceId, resourcePath);

  return resourceId; 

}

void 

AnimationInterface::EnablePacketMetadata (bool enable)

{

   m_enablePacketMetadata = enable;

   if (enable)

     {

       Packet::EnablePrinting ();

     }

}

bool 

AnimationInterface::IsInitialized ()

{

  return initialized;

}

bool 

AnimationInterface::IsStarted ()

{

  return m_started;

}

void 

AnimationInterface::SetAnimWriteCallback (AnimWriteCallback cb)

{

  m_writeCallback = cb;

}

void 

AnimationInterface::ResetAnimWriteCallback ()

{

  m_writeCallback = 0;

}

void 

AnimationInterface::SetMobilityPollInterval (Time t)

{

  m_mobilityPollInterval = t;

}

void 

AnimationInterface::SetConstantPosition (Ptr <Node> n, double x, double y, double z)

{

  NS_ASSERT (n);

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

  if (loc == 0)

    {

      loc = CreateObject<ConstantPositionMobilityModel> ();

      n->AggregateObject (loc);

    }

  Vector hubVec (x, y, z);

  loc->SetPosition (hubVec);

  NS_LOG_INFO ("Node:" << n->GetId () << " Position set to:(" << x << "," << y << "," << z << ")");

}

void 

AnimationInterface::UpdateNodeImage (uint32_t nodeId, uint32_t resourceId)

{

  NS_LOG_INFO ("Setting node image for Node Id:" << nodeId);

  if (resourceId > (m_resources.size ()-1))

    {

      NS_FATAL_ERROR ("Resource Id:" << resourceId << " not found. Did you use AddResource?");

    }

  WriteXmlUpdateNodeImage (nodeId, resourceId);

}

void 

AnimationInterface::UpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counter)

{

  if (nodeCounterId > (m_nodeCounters.size () - 1))

    {

      NS_FATAL_ERROR ("NodeCounter Id:" << nodeCounterId << " not found. Did you use AddNodeCounter?");

    }

  WriteXmlUpdateNodeCounter (nodeCounterId, nodeId, counter);

}

void 

AnimationInterface::SetBackgroundImage (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)

{

  if ((opacity < 0) || (opacity > 1))

    {

      NS_FATAL_ERROR ("Opacity must be between 0.0 and 1.0");

    }

  WriteXmlUpdateBackground (fileName, x, y, scaleX, scaleY, opacity);

}

void 

AnimationInterface::UpdateNodeSize (uint32_t nodeId, double width, double height)

{

  AnimationInterface::NodeSize s = { width, height };

  m_nodeSizes[nodeId] = s;

  WriteXmlUpdateNodeSize (nodeId, s.width, s.height);

}

void 

AnimationInterface::UpdateNodeColor (Ptr <Node> n, uint8_t r, uint8_t g, uint8_t b)

{

  UpdateNodeColor (n->GetId (), r, g, b);

}

void 

AnimationInterface::UpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b)

{

  NS_ASSERT (NodeList::GetNode (nodeId));

  NS_LOG_INFO ("Setting node color for Node Id:" << nodeId); 

  Rgb rgb = {r, g, b};

  m_nodeColors[nodeId] = rgb;

  WriteXmlUpdateNodeColor (nodeId, r, g, b);

}

void 

AnimationInterface::UpdateLinkDescription (uint32_t fromNode, uint32_t toNode,

                                                std::string linkDescription)

{

  WriteXmlUpdateLink (fromNode, toNode, linkDescription);

}

void 

AnimationInterface::UpdateLinkDescription (Ptr <Node> fromNode, Ptr <Node> toNode,

                                                std::string linkDescription)

{

  NS_ASSERT (fromNode);

  NS_ASSERT (toNode);

  WriteXmlUpdateLink (fromNode->GetId (), toNode->GetId (), linkDescription);

}

void 

AnimationInterface::UpdateNodeDescription (Ptr <Node> n, std::string descr)

{

  UpdateNodeDescription (n->GetId (), descr);

}

void 

AnimationInterface::UpdateNodeDescription (uint32_t nodeId, std::string descr)

{

  NS_ASSERT (NodeList::GetNode (nodeId));

  m_nodeDescriptions[nodeId] = descr;

  WriteXmlUpdateNodeDescription (nodeId);

}

// Private methods

double 

AnimationInterface::GetNodeEnergyFraction (Ptr <const Node> node) const

{

  const EnergyFractionMap::const_iterator fractionIter = m_nodeEnergyFraction.find (node->GetId ());

  NS_ASSERT (fractionIter != m_nodeEnergyFraction.end ());

  return fractionIter->second;

}

void 

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

{

  if (!m_started || !IsInTimeWindow () || !m_trackPackets)

    return;

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

  NS_ASSERT (n);

  Vector v ;

  if (!mobility)

    {

      v = GetPosition (n);

    } 

  else

    {

      v = mobility->GetPosition ();

    }

  UpdatePosition (n, v);

  WriteXmlUpdateNodePosition (n->GetId (), v.x, v.y);

}

bool 

AnimationInterface::NodeHasMoved (Ptr <Node> n, Vector newLocation)

{

  Vector oldLocation = GetPosition (n);

  if ((ceil (oldLocation.x) == ceil (newLocation.x)) &&

    (ceil (oldLocation.y) == ceil (newLocation.y)))

    {

      return false;

    }

  else

    {

      return true;

    }

}

void 

AnimationInterface::MobilityAutoCheck ()

{

  if (!m_started || !IsInTimeWindow ())

    return;

  std::vector <Ptr <Node> > MovedNodes = GetMovedNodes ();

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

    {

      Ptr <Node> n = MovedNodes [i];

      NS_ASSERT (n);

      Vector v = GetPosition (n);

      WriteXmlUpdateNodePosition (n->GetId () , v.x, v.y);

    }

  if (!Simulator::IsFinished ())

    {

      PurgePendingPackets (AnimationInterface::WIFI);

      PurgePendingPackets (AnimationInterface::WIMAX);

      PurgePendingPackets (AnimationInterface::LTE);

      PurgePendingPackets (AnimationInterface::CSMA);

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

    }

}

std::vector <Ptr <Node> >  

AnimationInterface::GetMovedNodes ()

{

  std::vector < Ptr <Node> > movedNodes;

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

    {

      Ptr<Node> n = *i;

      NS_ASSERT (n);

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

      Vector newLocation;

      if (!mobility)

        {

          newLocation = GetPosition (n);

        }

      else

        {

          newLocation = mobility->GetPosition ();

        }

      if (!NodeHasMoved (n, newLocation))

        {

          continue; //Location has not changed

        }

      else

        {

          UpdatePosition (n, newLocation);

          movedNodes.push_back (n);

        }

    }

  return movedNodes;

}

int 

AnimationInterface::WriteN (const std::string& st, FILE * f)

{

  if (!f)

    return 0;

  if (m_writeCallback)

    {