#include <dlfcn.h>

#include "ns3/boolean.h"

#include "ns3/log.h"

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

#include "ns3/ipv4-interface.h"

#include "ns3/object.h"

#include "ns3/packet.h"

#include "ns3/ptr.h"

#include "ns3/nstime.h"

#include "nsc-glue.h"

#include "node.h"

#include <netinet/ip.h>

#include <arpa/inet.h>

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (NscGlue);

TypeId

NscGlue::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::NscGlue")

    .SetParent <Object> ()

    ;

  return tid;

}

NscGlue::NscGlue(void)

	: m_wakeupCallbacks(0),

	  m_dlopenHandle(0)

{

}

void

NscGlue::SetNode(Ptr<Node> n)

{

  m_node = n;

}

void

NscGlue::PassPacketToNsc (Ptr<const Packet> packet, int idx)

{

  uint32_t packetSize = packet->GetSize();

  const uint8_t *data = const_cast<uint8_t *>(packet->PeekData());

  // deliver complete packet to the NSC network stack

  m_nscStack->if_receive_packet(idx, data, packetSize);

  wakeup ();

}

bool

NscGlue::IsNscProtocol (uint16_t proto)

{

  return proto == 0x0800; // NSC can only handle ipv4 at the moment.

}

static int external_rand(void)

{

  return 1; // XXX: check which NSC stacks actually use this

}

void

NscGlue::SetNscLibrary(const std::string &soname)

{

  NS_ASSERT(!m_dlopenHandle);

  m_dlopenHandle = dlopen(soname.c_str (), RTLD_NOW);

  if (m_dlopenHandle == NULL)

    NS_FATAL_ERROR (dlerror());

  FCreateStack create = (FCreateStack)dlsym(m_dlopenHandle, "nsc_create_stack");

  m_nscStack = create(this, this, external_rand);

  int hzval = m_nscStack->get_hz();

  NS_ASSERT(hzval > 0);

  m_softTimer.SetFunction (&NscGlue::SoftRtcInterrupt, this);

  m_softTimer.SetDelay (MilliSeconds (1000/hzval));

  // This enables stack and NSC debug messages

  m_nscStack->set_diagnostic(10);

  m_nscStack->init(hzval);

  Ptr<Ns3NscStack> nscStack = Create<Ns3NscStack> ();

  nscStack->SetStack (m_nscStack);

  m_node->AggregateObject (nscStack);

  m_softTimer.Schedule ();

  // its likely no ns-3 interface exits at this point, so

  // we delay adding the nsc interface until the start of the simulation.

  Simulator::ScheduleNow(&NscGlue::AddIface, this);

  m_nscLibrary = soname;

}

std::string

NscGlue::GetNscLibrary () const

{

  return m_nscLibrary;

}

void NscGlue::wakeup()

{

  // TODO

  // this should schedule a timer to read from all tcp sockets now... this is

  // an indication that data might be waiting on the socket

  for (std::list<Callback<void> >::iterator i = m_wakeupCallbacks.begin ();

	i != m_wakeupCallbacks.end (); i++)

     {

        Callback<void> cb = *i;

	cb ();

     }

}

void NscGlue::SoftRtcInterrupt (void)

{

  m_nscStack->timer_interrupt ();

  m_nscStack->increment_ticks ();

  m_softTimer.Schedule ();

}

void NscGlue::gettime(unsigned int* sec, unsigned int* usec)

{

  // Only used by the Linux network stack, e.g. during ISN generation

  // and in the kernel rng initialization routine. Also used in Linux

  // printk output.

  Time t = Simulator::Now ();

  int64_t us = t.GetMicroSeconds ();

  *sec = us / (1000*1000);

  *usec = us - *sec * (1000*1000);

}

#ifdef NSC_NEXT

void NscGlue::send_callback(int idx, const void* data, unsigned int datalen)

#else

void NscGlue::send_callback(/* int idx,*/ const void* data, unsigned int datalen)

#endif

{

#ifndef NSC_NEXT

 int idx = 0;

#endif

  Ptr<Packet> p;

  uint32_t ipv4Daddr;

  NS_ASSERT(datalen > 20);

  // FIXME: XXX: This won't really work when NSC is able to use

  // L3 protocols other than AF_INET. We really really really

  // should be able to do all routing decisions inside nsc and just

  // pass packets to whatever network interface without looking at its contents.

  const uint8_t *rawdata = reinterpret_cast<const uint8_t *>(data);

  p = Create<Packet> (rawdata, datalen);

  // we need the destination ipv4 address for Send ().

  const uint32_t *ipheader = reinterpret_cast<const uint32_t *>(data);

  ipv4Daddr = *(ipheader+4);

  Ipv4Address daddr(ntohl(ipv4Daddr));

  Ptr<Ipv4L3Protocol> ipv4 = m_node->GetObject<Ipv4L3Protocol> ();

  NS_ASSERT_MSG (ipv4, "nsc callback invoked, but node has no ipv4 object");

  // FIXME: do _all_ routing via NSC and provide a ns3-nsc mapping that

  // tells us which ns-3 interface the nsc interface "idx" is corresponding to.

//NS_LOG_LOGIC ("ns3: xmit via device number " << idx);

  Ptr<Ipv4Interface> outInterface = ipv4->GetInterface ( idx + 1);

  NS_ASSERT (outInterface);

  outInterface->Send (p, daddr);

  m_nscStack->if_send_finish(0);

}

void NscGlue::RegisterWakeupCallback(Callback<void> cb)

{

  m_wakeupCallbacks.push_back (cb);

}

void NscGlue::AddIface(void)

{

    Ptr<Ipv4> ip = m_node->GetObject<Ipv4> ();

    const uint32_t nInterfaces = ip->GetNInterfaces ();

    // start from 1, ignore the loopback interface (HACK)

    for (uint32_t i = 1; i < nInterfaces; i++)

    {

      Ipv4InterfaceAddress ifAddr = ip->GetAddress (i, 0);

      Ipv4Address addr = ifAddr.GetLocal ();

      Ipv4Mask mask = ifAddr.GetMask ();

      uint16_t mtu = ip->GetMtu (i);

      std::ostringstream addrOss, maskOss;

      addr.Print(addrOss);

      mask.Print(maskOss);

//    NS_LOG_LOGIC ("if_attach " << addrOss.str().c_str() << " " << maskOss.str().c_str() << " " << mtu);

      std::string addrStr = addrOss.str();

      std::string maskStr = maskOss.str();

      const char* addrCStr = addrStr.c_str();

      const char* maskCStr = maskStr.c_str();

      NS_ASSERT_MSG (m_nscStack, "m_nscStackError");

      m_nscStack->if_attach(addrCStr, maskCStr, mtu);

      if (i == 1)

      {

        // We need to come up with a default gateway here. Can't guarantee this to be

        // correct really...

        uint8_t addrBytes[4];

        addr.Serialize(addrBytes);

        // XXX: this is all a bit of a horrible hack

        //

        // Just increment the last octet, this gives a decent chance of this being

        // 'enough'.

        //

        // All we need is another address on the same network as the interface. This

        // will force the stack to output the packet out of the network interface.

        addrBytes[3]++;

        addr.Deserialize(addrBytes);

        addrOss.str("");

        addr.Print(addrOss);

        m_nscStack->add_default_gateway(addrOss.str().c_str());

      }

   }

}

} // namespace ns3