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

/*

 * Copyright (c) 2009 IITP RAS

 *

 * 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

 *

 * This is an example script for OLSR manet routing protocol. 

 *

 * Authors: Pavel Boyko <boyko@iitp.ru>

 */

#include "ns3/olsr-module.h"

#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 "ns3/wifi-module.h" 

#include "ns3/v4ping-helper.h"

#include <iostream>

#include <cmath>

using namespace ns3;

/**

 * \brief Test script.

 * 

 * This script creates 1-dimensional grid topology and then ping last node from the first one:

 * 

 * [10.0.0.1] <-- step --> [10.0.0.2] <-- step --> [10.0.0.3] <-- step --> [10.0.04]

 * 

 * ping 10.0.0.4

 */

static void PingRtt (std::string context, Time rtt)

{

  std::cout << "Received ping reply at " << Simulator::Now ().GetSeconds () 

    << " with RTT of " << rtt.GetMilliSeconds () << "ms" << std::endl;

}

class OlsrExample 

{

public:

  OlsrExample ();

  /// Configure script parameters, \return true on successful configuration

  bool Configure (int argc, char **argv);

  /// Run simulation

  void Run ();

  /// Report results

  void Report (std::ostream & os);

private:

  ///\name parameters

  //\{

  /// Number of nodes

  uint32_t size;

  /// Distance between nodes, meters

  double step;

  /// Simulation time, seconds

  double totalTime;

  /// Ping start time (should allow for unicast routing to settle)

  static const double pingStartTime = 15;

  /// Write per-device PCAP traces if true

  bool pcap;

  /// Write ASCII traces if true

  bool ascii;

  //\}

  ///\name network

  //\{

  NodeContainer nodes;

  NetDeviceContainer devices;

  Ipv4InterfaceContainer interfaces;

  //\}

private:

  void CreateNodes ();

  void CreateDevices ();

  void InstallInternetStack ();

  void InstallApplications ();

  std::ofstream m_ascii;

};

int main (int argc, char **argv)

{

  OlsrExample test;

  if (! test.Configure(argc, argv)) 

    NS_FATAL_ERROR ("Configuration failed. Aborted.");

  test.Run ();

  test.Report (std::cout);

  return 0;

}

//-----------------------------------------------------------------------------

OlsrExample::OlsrExample () :

  size (4),

  step (120),

  totalTime (60),

  pcap (true),

  ascii (true)

{

}

bool

OlsrExample::Configure (int argc, char **argv)

{

  // Enable AODV logs by default. Comment this if too noisy

  // LogComponentEnable("OlsrRoutingProtocol", LOG_LEVEL_ALL);

  SeedManager::SetSeed(12345);

  CommandLine cmd;

  cmd.AddValue ("pcap", "Write PCAP traces.", pcap);

  cmd.AddValue ("ascii", "Write ASCII traces.", ascii);

  cmd.AddValue ("size", "Number of nodes.", size);

  cmd.AddValue ("time", "Simulation time, s.", totalTime);

  cmd.AddValue ("step", "Grid step, m", step);

  cmd.Parse (argc, argv);

  return true;

}

void

OlsrExample::Run ()

{

//  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", UintegerValue (1)); // enable rts cts all the time.

  CreateNodes ();

  CreateDevices ();

  InstallInternetStack ();

  InstallApplications ();

  std::cout << "Starting simulation for " << totalTime << " s ...\n";

  std::cout << "Sending a ping at " << pingStartTime << " s ...\n";

  Simulator::Stop (Seconds (totalTime));

  Simulator::Run ();

  Simulator::Destroy ();

}

void

OlsrExample::Report (std::ostream &)

{ 

}

void

OlsrExample::CreateNodes ()

{

  std::cout << "Creating " << (unsigned)size << " nodes " << step << " m apart.\n";

  nodes.Create (size);

  // Name nodes

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

     {

       std::ostringstream os;

       os << "node-" << i;

       Names::Add (os.str (), nodes.Get (i));

     }

  // Create static grid

  MobilityHelper mobility;

  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",

                                "MinX", DoubleValue (0.0),

                                "MinY", DoubleValue (0.0),

                                "DeltaX", DoubleValue (step),

                                "DeltaY", DoubleValue (0),

                                "GridWidth", UintegerValue (size),

                                "LayoutType", StringValue ("RowFirst"));

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

  mobility.Install (nodes);

}

void

OlsrExample::CreateDevices ()

{

  NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

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

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  wifiPhy.SetChannel (wifiChannel.Create ());

  WifiHelper wifi = WifiHelper::Default ();

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode", StringValue ("wifia-6mbs"), "RtsCtsThreshold", UintegerValue (0));

  devices = wifi.Install (wifiPhy, wifiMac, nodes); 

  if (pcap)

    {

      wifiPhy.EnablePcapAll (std::string ("olsr"));

    }

  if (ascii)

    {

      m_ascii.open ("olsr.tr");

      wifiPhy.EnableAsciiAll (m_ascii);

    }

}

void

OlsrExample::InstallInternetStack ()

{

  OlsrHelper olsr;

  // you can configure OLSR attributes here using olsr.Set(name, value)

  InternetStackHelper stack;

  stack.SetRoutingHelper (olsr);

  stack.Install (nodes);

  Ipv4AddressHelper address;

  address.SetBase ("10.0.0.0", "255.0.0.0");

  interfaces = address.Assign (devices);

}

void

OlsrExample::InstallApplications ()

{

  V4PingHelper ping (interfaces.GetAddress (size - 1));

  //ping.SetAttribute ("Verbose", BooleanValue (true)); Uncomment me after AODV merge

  ApplicationContainer p = ping.Install (nodes.Get (0));

  NS_ASSERT (pingStartTime < totalTime);

  p.Start (Seconds (pingStartTime));

  p.Stop (Seconds (totalTime));

  // print the ping rtt

  Config::Connect ("/NodeList/*/ApplicationList/*/$ns3::V4Ping/Rtt",

                   MakeCallback (&PingRtt));

  // move node away

  Ptr<Node> node = nodes.Get (size/2);

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

  Simulator::Schedule (Seconds (totalTime/3), &MobilityModel::SetPosition, mob, Vector (1e5, 1e5, 1e5));

}

    obj = bld.create_ns3_program('olsr',

                                 ['wifi', 'internet-stack', 'olsr'])

    obj.source = 'olsr.cc'