/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2009 The Boeing Company

 *

 * 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: Guangyu Pei <guangyu.pei@boeing.com>

 */

#include "ns3/core-module.h"

#include "ns3/common-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/mobility-module.h"

#include "ns3/contrib-module.h"

#include <iostream>

#include <fstream>

#include <vector>

#include <string>

NS_LOG_COMPONENT_DEFINE ("Main");

using namespace ns3;

class Experiment

{

public:

  Experiment ();

  Experiment (std::string name);

  uint32_t Run (const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy,

                const NqosWifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel);

private:

  void ReceivePacket (Ptr<Socket> socket);

  void SetPosition (Ptr<Node> node, Vector position);

  Vector GetPosition (Ptr<Node> node);

  Ptr<Socket> SetupPacketReceive (Ptr<Node> node);

  void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, 

                             uint32_t pktCount, Time pktInterval );

  uint32_t m_pktsTotal;

  Gnuplot2dDataset m_output;

};

Experiment::Experiment ()

{}

Experiment::Experiment (std::string name)

  : m_output (name)

{

  m_output.SetStyle (Gnuplot2dDataset::LINES);

}

void

Experiment::SetPosition (Ptr<Node> node, Vector position)

{

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

  mobility->SetPosition (position);

}

Vector

Experiment::GetPosition (Ptr<Node> node)

{

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

  return mobility->GetPosition ();

}

void

Experiment::ReceivePacket (Ptr<Socket> socket)

{

  Ptr<Packet> packet;

  while (packet = socket->Recv ())

    {

      m_pktsTotal ++;

    }

}

Ptr<Socket>

Experiment::SetupPacketReceive (Ptr<Node> node)

{

  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

  Ptr<Socket> sink = Socket::CreateSocket (node, tid);

  InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80);

  sink->Bind (local);

  sink->SetRecvCallback (MakeCallback (&Experiment::ReceivePacket, this));

  return sink;

}

void

Experiment::GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, 

                             uint32_t pktCount, Time pktInterval )

{

  if (pktCount > 0)

    {

      socket->Send (Create<Packet> (pktSize));

      Simulator::Schedule (pktInterval, &Experiment::GenerateTraffic, this, 

                           socket, pktSize,pktCount-1, pktInterval);

    }

  else

    {

      socket->Close ();

    }

}

uint32_t

Experiment::Run (const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy,

                 const NqosWifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel)

{

  m_pktsTotal = 0;

  NodeContainer c;

  c.Create (2);

  InternetStackHelper internet;

  internet.Install (c);

  YansWifiPhyHelper phy = wifiPhy;

  phy.SetChannel (wifiChannel.Create ());

  NqosWifiMacHelper mac = wifiMac;

  NetDeviceContainer devices = wifi.Install (phy, mac, c);

  MobilityHelper mobility;

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

  positionAlloc->Add (Vector (0.0, 0.0, 0.0));

  positionAlloc->Add (Vector (5.0, 0.0, 0.0));

  mobility.SetPositionAllocator (positionAlloc);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.Install (c);

  Ipv4AddressHelper ipv4;

  NS_LOG_INFO ("Assign IP Addresses.");

  ipv4.SetBase ("10.1.1.0", "255.255.255.0");

  Ipv4InterfaceContainer i = ipv4.Assign (devices);

  Ptr<Socket> recvSink = SetupPacketReceive (c.Get (0));

  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

  Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);

  InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);

  source->Connect (remote);

  uint32_t packetSize = 1014;

  uint32_t maxPacketCount = 200;

  Time interPacketInterval = Seconds (1.);

  Simulator::Schedule (Seconds (1.0), &Experiment::GenerateTraffic, 

                       this, source, packetSize, maxPacketCount,interPacketInterval);

  Simulator::Run ();

  Simulator::Destroy ();

  return m_pktsTotal;

}

int main (int argc, char *argv[])

{

  std::ofstream outfile ("clear-channel.plt");

  std::vector <std::string> modes;

  modes.push_back ("wifib-1mbs");

  modes.push_back ("wifib-2mbs");

  modes.push_back ("wifib-5.5mbs");

  modes.push_back ("wifib-11mbs");

  // disable fragmentation

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2200"));

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("2200"));

  CommandLine cmd;

  cmd.Parse (argc, argv);

  Gnuplot gnuplot = Gnuplot ("clear-channel.eps");

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

  {

   std::cout << modes[i] << std::endl;

   Gnuplot2dDataset dataset (modes[i]);

   for (double rss = -102.0; rss <= -80.0; rss += 0.5)

   {

     Experiment experiment;

     dataset.SetStyle (Gnuplot2dDataset::LINES);

     WifiHelper wifi;

     NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

     Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode", 

                         StringValue (modes[i]));

     wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                   "DataMode",StringValue(modes[i]),

                                   "ControlMode",StringValue(modes[i]));

     wifiMac.SetType ("ns3::AdhocWifiMac");

     YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

     YansWifiChannelHelper wifiChannel ;

     wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");

     wifiChannel.AddPropagationLoss ("ns3::FixedRssLossModel","Rss",DoubleValue(rss));

     NS_LOG_DEBUG (modes[i]);

     experiment = Experiment (modes[i]);

     wifiPhy.Set ("Standard", StringValue ("802.11b") );

     wifiPhy.Set ("EnergyDetectionThreshold", DoubleValue (-110.0) );

     wifiPhy.Set ("CcaMode1Threshold", DoubleValue (-110.0) );

     wifiPhy.Set ("TxPowerStart", DoubleValue (15.0) );

     wifiPhy.Set ("RxGain", DoubleValue (0) ); 

     wifiPhy.Set ("RxNoiseFigure", DoubleValue (7) ); 

     uint32_t pktsRecvd = experiment.Run (wifi, wifiPhy, wifiMac, wifiChannel);

     dataset.Add (rss, pktsRecvd);

   }

   gnuplot.AddDataset (dataset);

  }

  gnuplot.SetTerminal ("postscript eps color enh \"Times-BoldItalic\"");

  gnuplot.SetLegend ("RSS(dBm)", "Number of packets received");

  gnuplot.SetExtra  ("set xrange [-102:-83]");

  gnuplot.GenerateOutput (outfile);

  outfile.close ();

  return 0;

}