#include <iostream>
#include <fstream>
#include "ns3/simulator-module.h"
#include "ns3/node-module.h"
#include "ns3/core-module.h"
#include "ns3/csma-module.h"
#include "ns3/wifi-module.h"
#include "ns3/internet-stack-module.h"
#include "ns3/onoff-module.h"
#include "ns3/packet-sink-module.h"
#include "ns3/mobility-module.h"
#include "ns3/global-route-manager.h"
#include "ns3/contrib-module.h"
#include "ns3/common-module.h"

using namespace ns3;

static Ptr<CsmaNetDevice> 
AddCsma (Ptr<Node> node, Ptr<CsmaChannel> channel)
{
  Ptr<CsmaNetDevice> dev = CreateObject<CsmaNetDevice> ();
  dev->SetAddress (Mac48Address::Allocate ());
  node->AddDevice (dev);
  Ptr<Queue> queue = CreateObject<DropTailQueue> ();
  dev->SetQueue (queue);
  dev->Attach (channel);
  return dev;
}

static Ptr<WifiNetDevice>
AddWifi (Ptr<Node> node, Ptr<YansWifiChannel> channel)
{
  Ptr<WifiNetDevice> device = CreateObject<WifiNetDevice> ();

  Ptr<YansWifiPhy> phy = CreateObject<YansWifiPhy> ();
  Ptr<ErrorRateModel> error = CreateObject<YansErrorRateModel> ();
  phy->SetErrorRateModel (error);
  phy->SetChannel (channel);
  phy->SetMobility (node);
  phy->SetDevice (device);

  Ptr<WifiRemoteStationManager> manager = CreateObject<ArfWifiManager> ();
  Ptr<WifiMac> mac = CreateObject<AdhocWifiMac> ();
  mac->SetAddress (Mac48Address::Allocate ());

  device->SetMac (mac);
  device->SetPhy (phy);
  device->SetRemoteStationManager (manager);
  node->AddDevice (device);

  return device;
}

static Ptr<PositionAllocator>
GetPositionAllocator (void)
{
  static Ptr<PositionAllocator> allocator = 0;
  if (allocator == 0)
    {
      allocator = CreateObject<RandomDiscPositionAllocator> ();
      allocator->SetAttribute ("X", StringValue ("100.0"));
      allocator->SetAttribute ("Y", StringValue ("100.0"));
      allocator->SetAttribute ("Rho", StringValue ("Uniform:0:30"));
    }
  return allocator;
}

static void
AddMobility (Ptr<Node> node)
{
  Ptr<StaticMobilityModel> mobility = CreateObject<StaticMobilityModel> ();
  mobility->SetPosition (GetPositionAllocator ()->GetNext ());
  node->AggregateObject (mobility);
}

static void
AddIpv4Interface (Ptr<NetDevice> device,
		  const char * ip, 
		  const char * mask)
{
  Ptr<Node> node = device->GetNode ();
  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();
  int32_t ifIndex = ipv4->AddInterface (device);
  ipv4->SetAddress (ifIndex, Ipv4Address (ip));
  ipv4->SetNetworkMask (ifIndex, Ipv4Mask (mask));
  ipv4->SetMetric (ifIndex, 1);
  ipv4->SetUp (ifIndex);
}

static Ptr<Application>
AddUdpSource (Ptr<Node> node,
	      const char *ip, uint16_t port)
{
  Ptr<OnOffApplication> application = CreateObject<OnOffApplication> ();
  application->SetAttribute ("Protocol", StringValue ("ns3::UdpSocketFactory"));
  application->SetAttribute ("Remote", AddressValue (InetSocketAddress (Ipv4Address (ip), port)));
  application->SetAttribute ("OnTime", StringValue ("Constant:1.0"));
  application->SetAttribute ("OffTime", StringValue ("Constant:0.0"));
  node->AddApplication (application);
  return application;
}

static Ptr<Application>
AddUdpSink (Ptr<Node> node, const char *ip, uint16_t port)
{
  Ptr<PacketSink> sink = CreateObject<PacketSink> ();
  sink->SetAttribute ("Protocol", StringValue ("ns3::UdpSocketFactory"));
  sink->SetAttribute ("Local", AddressValue (InetSocketAddress (Ipv4Address (ip), port)));
  node->AddApplication (sink);
  return sink;
}

static void PcapPhyRxEvent (Ptr<PcapWriter> writer, 
                            Ptr<const Packet> packet, double snr, WifiMode mode, 
                            enum WifiPreamble preamble)
{
  writer->WritePacket (packet);
}
static void PcapPhyTxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet,
                            WifiMode mode, WifiPreamble preamble, 
                            uint8_t txLevel)
{
  writer->WritePacket (packet);
}


static void
WifiEnablePcap (Ptr<WifiNetDevice> wifi, const char *filename)
{
  uint32_t nodeId = wifi->GetNode ()->GetId ();
  uint32_t deviceId = wifi->GetIfIndex ();
  std::ostringstream oss;
  oss << filename << "-" << nodeId << "-" << deviceId << ".pcap";
  Ptr<PcapWriter> pcap = ::ns3::Create<PcapWriter> ();
  pcap->Open (oss.str ());
  pcap->WriteWifiHeader ();
  oss.str ("");
  oss << "/NodeList/" << nodeId << "/DeviceList/" << deviceId 
      << "/$ns3::WifiNetDevice/Phy/State/Tx";
  Config::ConnectWithoutContext (oss.str (), 
				 MakeBoundCallback (&PcapPhyTxEvent, pcap));
  oss.str ("");
  oss << "/NodeList/" << nodeId << "/DeviceList/" << deviceId 
      << "/$ns3::WifiNetDevice/Phy/State/RxOk";
  Config::ConnectWithoutContext (oss.str (), 
				 MakeBoundCallback (&PcapPhyRxEvent, pcap));
}

int main (int argc, char *argv[])
{
  Ptr<Node> node0 = CreateObject<Node> ();
  Ptr<Node> node1 = CreateObject<Node> ();
  Ptr<Node> node2 = CreateObject<Node> ();
  Ptr<Node> node3 = CreateObject<Node> ();
  Ptr<Node> node4 = CreateObject<Node> ();

  Ptr<CsmaChannel> csmaChannel = CreateObject<CsmaChannel> ();
  csmaChannel->SetAttribute ("DataRate", StringValue ("5Mbps"));
  csmaChannel->SetAttribute ("Delay", StringValue ("2ms"));
  Ptr<CsmaNetDevice> csmaDev0 = AddCsma (node0, csmaChannel);
  Ptr<CsmaNetDevice> csmaDev1 = AddCsma (node1, csmaChannel);

  Ptr<YansWifiChannel> wifiChannel = CreateObject<YansWifiChannel> ();
  wifiChannel->SetPropagationDelayModel (CreateObject<ConstantSpeedPropagationDelayModel> ());
  Ptr<PropagationLossModel> loss = CreateObject<LogDistancePropagationLossModel> ();
  wifiChannel->SetPropagationLossModel (loss);

  Ptr<WifiNetDevice> wifiDev0 = AddWifi (node1, wifiChannel);
  Ptr<WifiNetDevice> wifiDev1 = AddWifi (node2, wifiChannel);
  Ptr<WifiNetDevice> wifiDev2 = AddWifi (node3, wifiChannel);
  Ptr<WifiNetDevice> wifiDev3 = AddWifi (node4, wifiChannel);

  AddMobility (node1);
  AddMobility (node2);
  AddMobility (node3);
  AddMobility (node4);

  AddInternetStack (node0);
  AddInternetStack (node1);
  AddInternetStack (node2);
  AddInternetStack (node3);
  AddInternetStack (node4);

  AddIpv4Interface (csmaDev0, "10.1.1.1", "255.255.255.0");
  AddIpv4Interface (csmaDev1, "10.1.1.2", "255.255.255.0");
  AddIpv4Interface (wifiDev0, "10.1.2.1", "255.255.255.0");
  AddIpv4Interface (wifiDev1, "10.1.2.2", "255.255.255.0");
  AddIpv4Interface (wifiDev2, "10.1.2.3", "255.255.255.0");
  AddIpv4Interface (wifiDev3, "10.1.2.4", "255.255.255.0");

  GlobalRouteManager::PopulateRoutingTables ();

  Ptr<Application> app;
  app = AddUdpSource (node0, "10.1.2.2", 1025);
  app->Start (Seconds (1.0));
  app->Stop (Seconds (4.0));
  app = AddUdpSink (node2, "10.1.2.2", 1025);
  app->Start (Seconds (0.0));
  app->Stop (Seconds (4.0));

  WifiEnablePcap (wifiDev2, "wns3-lowlevel");

  GtkConfigStore config;
  config.Configure ();

  Simulator::Stop (Seconds (4.5));

  Simulator::Run ();
  Simulator::Destroy ();


  return 0;
}