/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 MIRKO BANCHI
 *
 * 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: Mirko Banchi <mk.banchi@gmail.com>
 */
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/mobility-module.h"
#include "ns3/ipv4-global-routing-helper.h"
#include "ns3/internet-module.h"

//This is a simple example in order to show how 802.11n frame aggregation feature (A-MSDU) works.
//
//Network topology:
// 
//  Wifi 192.168.1.0
// 
//             AP
//   *    *    *
//   |    |    |
//   n1   n2   n3 
//
//Packets in this simulation aren't marked with a QosTag so they are considered
//belonging to BestEffort Access Class (AC_BE).

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("DataRates");

double rxBytessum=0;
double throughput=0;


//===========================================================================
//Set position of the nodes
//===========================================================================
static void
SetPosition (Ptr<Node> node, Vector position)
{
  Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();
  mobility->SetPosition (position);
}

//==========================================================================
//==========================================================================

int main (int argc, char *argv[])
{
  std::cout << "DataRate" <<"  " << "Throughput" << '\n';
  bool udp = true;
  int i=2;
  for (;i <= 2; i++)
  {
    uint32_t nWifi = 1;
    CommandLine cmd;
    cmd.AddValue ("nWifi", "Number of wifi STA devices", nWifi);
    cmd.Parse (argc,argv);
    Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("990000"));
    // disable rts cts all the time.
    Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("99000"));
    NodeContainer wifiNodes;
    wifiNodes.Create (1);
    NodeContainer wifiApNode;
    wifiApNode.Create (1);
 
    YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
    YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
    phy.SetChannel (channel.Create ());
    if (i ==3 || i == 4)
      phy.Set ("ShortGuardEnabled",BooleanValue(true));
      //phy.Set ("GreenfieldEnabled",BooleanValue(true));

    WifiHelper wifi = WifiHelper::Default ();
    wifi.SetStandard (WIFI_PHY_STANDARD_80211n_2_4GHZ);
    HtWifiMacHelper mac = HtWifiMacHelper::Default ();
 

    Ssid ssid = Ssid ("ns380211n");
    double datarate;
    StringValue DataRate;
    if (i==0)
      {
        DataRate = StringValue("OfdmRate6_5MbpsBW20MHz");
        datarate = 6.5;
      }
    else if (i==1)
      {
        DataRate = StringValue("OfdmRate58_5MbpsBW20MHz");
        datarate = 58.5;
      }
    else if (i == 2)
      {
        DataRate = StringValue("OfdmRate65MbpsBW20MHz");
        datarate = 65;
      }
    else if (i == 3)
      {
        DataRate = StringValue("OfdmRate57_8MbpsBW20MHz");
        datarate = 57.8;
      }
    else if (i == 4)
      {
        DataRate = StringValue("OfdmRate72_2MbpsBW20MHz");
        datarate = 72.2;
      }

    wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager","DataMode", DataRate,
                                   "ControlMode", DataRate);
    mac.SetType ("ns3::StaWifiMac",
                 "Ssid", SsidValue (ssid),
                 "ActiveProbing", BooleanValue (false));
    
    NetDeviceContainer staDevices;
    staDevices = wifi.Install (phy, mac, wifiNodes);

    mac.SetType ("ns3::ApWifiMac",
                 "Ssid", SsidValue (ssid));
   
    NetDeviceContainer apDevice;
    apDevice = wifi.Install (phy, mac, wifiApNode);
   /* Ptr<WifiRemoteStationManager> apStationManager =
              DynamicCast<WifiNetDevice>(apDevice.Get (0))->GetRemoteStationManager ();
    apStationManager->AddBasicMode (WifiMode ("OfdmRate13MbpsBW20MHz"));
    apStationManager->AddBasicMode (WifiMode ("OfdmRate19_5MbpsBW20MHz"));
    apStationManager->AddBasicMode (WifiMode ("OfdmRate26MbpsBW20MHz"));
    apStationManager->AddBasicMode (WifiMode ("OfdmRate39MbpsBW20MHz"));
    Ptr<WifiRemoteStationManager> staStationManager =
              DynamicCast<WifiNetDevice> (staDevices.Get (0))->GetRemoteStationManager ();
    staStationManager->AddBasicMode (WifiMode ("OfdmRate13MbpsBW20MHz"));
    staStationManager->AddBasicMode (WifiMode ("OfdmRate19_5MbpsBW20MHz"));
    staStationManager->AddBasicMode (WifiMode ("OfdmRate26MbpsBW20MHz"));
    staStationManager->AddBasicMode (WifiMode ("OfdmRate39MbpsBW20MHz"));*/
              
   // mobility.
   MobilityHelper mobility;
   mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
   mobility.Install (wifiNodes);
   mobility.Install (wifiApNode);
    
   SetPosition (wifiNodes.Get(0), Vector (1.0,0.0,0.0));
   SetPosition (wifiApNode.Get(0), Vector (0.0,0.0,0.0));
 

   /* Internet stack*/
   InternetStackHelper stack;
   stack.Install (wifiApNode);
   stack.Install (wifiNodes);

   Ipv4AddressHelper address;

   address.SetBase ("10.1.3.0", "255.255.255.0");
   Ipv4InterfaceContainer wifiNodesInterfaces;
   Ipv4InterfaceContainer apNodeInterface;

   wifiNodesInterfaces = address.Assign (staDevices);
   apNodeInterface = address.Assign (apDevice);

   ApplicationContainer serverApps,sink1App;

   double t=10;

   /* Setting applications */
   if (udp)
     {
       UdpServerHelper myServer (9);
       serverApps = myServer.Install (wifiNodes.Get (0));
       serverApps.Start (Seconds (0.0));
       serverApps.Stop (Seconds (t));

       UdpClientHelper myClient (wifiNodesInterfaces.GetAddress (0), 9);
       myClient.SetAttribute ("MaxPackets", UintegerValue (64707202));
       myClient.SetAttribute ("Interval", TimeValue (Time ("0.00002")));
       myClient.SetAttribute ("PacketSize", UintegerValue (1500));
 
       ApplicationContainer clientApps = myClient.Install (wifiApNode.Get (0));
       clientApps.Start (Seconds (0.0));
       clientApps.Stop (Seconds (t));
     }
   else
     {

       //TCP flow
       uint16_t port = 50000;
       Address apLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
       PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", apLocalAddress);
       sink1App = packetSinkHelper.Install (wifiNodes.Get (0));

       sink1App.Start (Seconds (0.0));
       sink1App.Stop (Seconds (t));
            
       OnOffHelper onoff ("ns3::TcpSocketFactory",Ipv4Address::GetAny ());
       onoff.SetAttribute ("OnTime", RandomVariableValue (ConstantVariable(30)));//in seconds
       onoff.SetAttribute ("OffTime", RandomVariableValue (ConstantVariable(0)));
       onoff.SetAttribute ("PacketSize", UintegerValue (1500-30));//1024
       onoff.SetAttribute ("DataRate", DataRateValue (100000000));//51200
       ApplicationContainer apps;

       AddressValue remoteAddress (InetSocketAddress (wifiNodesInterfaces.GetAddress(0), port));
       onoff.SetAttribute ("Remote", remoteAddress);
       apps.Add (onoff.Install (wifiApNode.Get (0)));
       apps.Start (Seconds (0.0));
       apps.Stop (Seconds (t));
     }

  
   Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

   Simulator::Stop (Seconds (t));
   Simulator::Run ();
   Simulator::Destroy ();

   //UDP
   if (udp)
     {
       uint32_t totalPacketsThrough = DynamicCast<UdpServer>(serverApps.Get (0))->GetReceived ();
       throughput=totalPacketsThrough*1500*8/(t*1000000.0);
     }
   else
     {
       //TCP
       uint32_t totalPacketsThrough = DynamicCast<PacketSink>(sink1App.Get (0))->GetTotalRx ();
       throughput=totalPacketsThrough*8/((t-3)*1000000.0);
     }
  
   std::cout << datarate <<"  " << throughput << '\n';
   }
  return 0;
}