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

 */

// Interface between ns3 and the network animator

// 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/animation-interface-helper.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 <cstdio>

#include <unistd.h>

#include <sstream>

#include <fstream>

#include <string>

#include <iomanip>

#include <map>

NS_LOG_COMPONENT_DEFINE ("AnimationInterface");

namespace ns3 {

#define PURGE_INTERVAL 5

static bool initialized = false;

std::map <uint32_t, std::string> AnimationInterface::nodeDescriptions;

std::map <uint32_t, Rgb> AnimationInterface::nodeColors;

std::map <P2pLinkNodeIdPair, LinkProperties, LinkPairCompare> AnimationInterface::linkProperties;

AnimationInterface::AnimationInterface (const std::string fn, uint64_t maxPktsPerFile, bool usingXML)

    m_outputFileName (fn),

    m_outputFileSet (false), gAnimUid (0), m_randomPosition (true),

    m_writeCallback (0), m_started (false), 

    m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000)),

{

  m_uniformRandomVariable = CreateObject<UniformRandomVariable> ();

  initialized = true;

  StartAnimation ();

}

AnimationInterface::~AnimationInterface ()

{

  StopAnimation ();

}

void AnimationInterface::SetXMLOutput ()

{

  NS_LOG_INFO ("XML output set");

  m_xml = true;

}

void AnimationInterface::StartNewTraceFile ()

{

  static int i = 0;

  std::ostringstream oss;

  oss << i;

  ++m_currentPktCount;

  if (m_currentPktCount <= m_maxPktsPerFile)

    {

      return;

    }

  StopAnimation ();

  m_outputFileName = m_originalFileName + "-" + oss.str ();

  StartAnimation (true);

  ++i;

}

std::string AnimationInterface::GetNetAnimVersion ()

{

  return "netanim-3.102";

}

void AnimationInterface::SetStartTime (Time t)

{

  m_startTime = t;

}

void AnimationInterface::SetStopTime (Time t)

{

  m_stopTime = t;

}

bool AnimationInterface::SetOutputFile (const std::string& fn)

{

  if (m_outputFileSet)

    {

      return true;

    }

  NS_LOG_INFO ("Creating new trace file:" << fn.c_str ());

  m_f = std::fopen (fn.c_str (), "w");

  if (!m_f)

    {

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

      return false; // Can't open

    }

  m_outputFileName = fn;

  m_outputFileSet = true;

  return true;

}

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;

}

bool AnimationInterface::IsInTimeWindow ()

{

  if ((Simulator::Now () >= m_startTime) && 

      (Simulator::Now () <= m_stopTime))

    return true;

  else

    return false;

}

bool AnimationInterface::UanPacketIsPending (uint64_t AnimUid)

{

  return (m_pendingUanPackets.find (AnimUid) != m_pendingUanPackets.end ());

}

bool AnimationInterface::WifiPacketIsPending (uint64_t AnimUid)

{

  return (m_pendingWifiPackets.find (AnimUid) != m_pendingWifiPackets.end ());

}

bool AnimationInterface::CsmaPacketIsPending (uint64_t AnimUid)

{

  return (m_pendingCsmaPackets.find (AnimUid) != m_pendingCsmaPackets.end ());

}

bool AnimationInterface::WimaxPacketIsPending (uint64_t AnimUid)

{

  return (m_pendingWimaxPackets.find (AnimUid) != m_pendingWimaxPackets.end ());

}

bool AnimationInterface::LtePacketIsPending (uint64_t AnimUid)

{

  return (m_pendingLtePackets.find (AnimUid) != m_pendingLtePackets.end ());

}

void AnimationInterface::SetMobilityPollInterval (Time t)

{

  m_mobilityPollInterval = t;

}

void AnimationInterface::SetRandomPosition (bool setRandPos)

{

  m_randomPosition = setRandPos;

}

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

{

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

  if (loc)

    {

      m_nodeLocation[n->GetId ()] = loc->GetPosition ();

    }

  else

   {

     NS_LOG_UNCOND ( "AnimationInterface WARNING:Node:" << n->GetId () << " Does not have a mobility model. Use SetConstantPosition if it is stationary");

     Vector deterministicVector (100,100,0);

     Vector randomVector (m_uniformRandomVariable->GetValue (0, m_topoMaxX - m_topoMinX), m_uniformRandomVariable->GetValue (0, m_topoMaxY - m_topoMinY), 0);

     if (m_randomPosition)

       {

         m_nodeLocation[n->GetId ()] = randomVector;

       }

     else

       {

         m_nodeLocation[n->GetId ()] = deterministicVector;

       }

   }

  return m_nodeLocation[n->GetId ()];

}

Vector AnimationInterface::UpdatePosition (Ptr <Node> n, Vector v)

{

  m_nodeLocation[n->GetId ()] = v;

  return v;

}

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

{

  #ifdef NS_LOG

  if (m_nodeLocation.find (n->GetId()) == m_nodeLocation.end ())

    {

      NS_FATAL_ERROR ("Node:" <<n->GetId() << " not found in Location table");

    }  

  #endif

  return m_nodeLocation[n->GetId ()];

}

void AnimationInterface::PurgePendingWifi ()

{

  if (m_pendingWifiPackets.empty ())

    return;

  std::vector <uint64_t> purgeList;

  for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingWifiPackets.begin ();

       i != m_pendingWifiPackets.end ();

       ++i)

    {

      AnimPacketInfo pktInfo = i->second; 

      double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);

      if (delta > PURGE_INTERVAL)

        {

          purgeList.push_back (i->first);

        }

    }

  for (std::vector <uint64_t>::iterator i = purgeList.begin ();

       i != purgeList.end ();

       ++i)

    {

      m_pendingWifiPackets.erase (*i);

    }

}

void AnimationInterface::PurgePendingWimax ()

{

  if (m_pendingWimaxPackets.empty ())

    return;

  std::vector <uint64_t> purgeList;

  for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingWimaxPackets.begin ();

       i != m_pendingWimaxPackets.end ();

       ++i)

    {

      AnimPacketInfo pktInfo = i->second;

      double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);

      if (delta > PURGE_INTERVAL)

        {

          purgeList.push_back (i->first);

        }

    }

  for (std::vector <uint64_t>::iterator i = purgeList.begin ();

       i != purgeList.end ();

       ++i)

    {

      m_pendingWimaxPackets.erase (*i);

    }

}

void AnimationInterface::PurgePendingLte ()

{

  if (m_pendingLtePackets.empty ())

    return;

  std::vector <uint64_t> purgeList;

  for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingLtePackets.begin ();

       i != m_pendingLtePackets.end ();

       ++i)

    {

      AnimPacketInfo pktInfo = i->second;

      double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);

      if (delta > PURGE_INTERVAL)

        {

          purgeList.push_back (i->first);

        }

    }

  for (std::vector <uint64_t>::iterator i = purgeList.begin ();

       i != purgeList.end ();

       ++i)

    {

      m_pendingLtePackets.erase (*i);

    }

}

void AnimationInterface::PurgePendingCsma ()

{

  if (m_pendingCsmaPackets.empty ())

    return;

  std::vector <uint64_t> purgeList;

  for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingCsmaPackets.begin ();

       i != m_pendingCsmaPackets.end ();

       ++i)

    {

      AnimPacketInfo pktInfo = i->second;

      double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);

      if (delta > PURGE_INTERVAL)

        { 

          purgeList.push_back (i->first);

        }

    }

  for (std::vector <uint64_t>::iterator i = purgeList.begin ();

       i != purgeList.end ();

       ++i)

    {

      m_pendingCsmaPackets.erase (*i);

    }

}

std::string AnimationInterface::GetMacAddress (Ptr <NetDevice> nd)

{

  Address nodeAddr = nd->GetAddress();

  std::ostringstream oss;

  oss << nodeAddr;

  return oss.str ().substr (6); // Skip the first 6 chars to get the Mac

}

std::string AnimationInterface::GetIpv4Address (Ptr <NetDevice> nd)

{

  Ptr<Ipv4> ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject <Ipv4> ();

  if (!ipv4)

    return "0.0.0.0";

  int32_t ifIndex = ipv4->GetInterfaceForDevice (nd);

  if (ifIndex == -1)

    {

      NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice");

      return "0.0.0.0";

    }

  Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, 0);

  std::ostringstream oss;

  oss << addr.GetLocal ();

  return oss.str ();

}

void AnimationInterface::StartAnimation (bool restart)

{

  m_currentPktCount = 0;

  m_started = true;

  SetOutputFile (m_outputFileName);

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

  m_topoMinX = -2;

  m_topoMinY = -2;

  m_topoMaxX = 2;

  m_topoMaxY = 2;

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

    {

      Ptr<Node> n = *i;

      NS_LOG_INFO ("Update Position for Node: " << n->GetId ());

      Vector v = UpdatePosition (n); 

      m_topoMinX = std::min (m_topoMinX, v.x);

      m_topoMinY = std::min (m_topoMinY, v.y);

      m_topoMaxX = std::max (m_topoMaxX, v.x);

      m_topoMaxY = std::max (m_topoMaxY, v.y);

      struct Rgb rgb = {255, 0, 0};

      if (nodeColors.find (n->GetId ()) == nodeColors.end ())

      {

        nodeColors[n->GetId ()] = rgb;

      }

    }