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

/*

 * Copyright (c) 2005,2006,2007 INRIA

 *

 * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include <iostream>

#include "wifi-remote-station-manager.h"

#include "ns3/simulator.h"

#include "ns3/assert.h"

#include "ns3/log.h"

#include "ns3/tag.h"

#include "ns3/boolean.h"

#include "ns3/double.h"

#include "ns3/uinteger.h"

#include "ns3/wifi-phy.h"

#include "ns3/wifi-mac.h"

#include "ns3/trace-source-accessor.h"

#include "wifi-mac-header.h"

#include "wifi-mac-trailer.h"

/***************************************************************

 *           Packet Mode Tagger

 ***************************************************************/

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("WifiRemoteStationManager");

class HighLatencyDataTxVectorTag : public Tag

{

public:

  HighLatencyDataTxVectorTag ();

  HighLatencyDataTxVectorTag (WifiTxVector dataTxVector);

  /**

   * \returns the transmission mode to use to send this packet

   */

  WifiTxVector GetDataTxVector (void) const;

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer i) const;

  virtual void Deserialize (TagBuffer i);

  virtual void Print (std::ostream &os) const;

private:

  WifiTxVector m_dataTxVector;

};

HighLatencyDataTxVectorTag::HighLatencyDataTxVectorTag ()

{

}

HighLatencyDataTxVectorTag::HighLatencyDataTxVectorTag ( WifiTxVector dataTxVector)

  : m_dataTxVector (dataTxVector)

{

}

WifiTxVector 

HighLatencyDataTxVectorTag::GetDataTxVector (void) const

{

  return m_dataTxVector;

}

TypeId

HighLatencyDataTxVectorTag::GetTypeId (void)

{

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

    .SetParent<Tag> ()

    .AddConstructor<HighLatencyDataTxVectorTag> ()  

    ;

  return tid;

}

TypeId

HighLatencyDataTxVectorTag::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

uint32_t

HighLatencyDataTxVectorTag::GetSerializedSize (void) const

{

  return sizeof (WifiTxVector);

}

void

HighLatencyDataTxVectorTag::Serialize (TagBuffer i) const

{

  i.Write ((uint8_t *)&m_dataTxVector, sizeof (WifiTxVector));

}

void

HighLatencyDataTxVectorTag::Deserialize (TagBuffer i)

{

  i.Read ((uint8_t *)&m_dataTxVector, sizeof (WifiTxVector));

}

void

HighLatencyDataTxVectorTag::Print (std::ostream &os) const

{

  os << "Data=" << m_dataTxVector;

}

class HighLatencyRtsTxVectorTag : public Tag

{

public:

  HighLatencyRtsTxVectorTag ();

  HighLatencyRtsTxVectorTag (WifiTxVector rtsTxVector);

  /**

   * \returns the transmission mode to use to send the RTS prior to the

   *          transmission of the data packet itself.

   */

  WifiTxVector GetRtsTxVector (void) const;

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer i) const;

  virtual void Deserialize (TagBuffer i);

  virtual void Print (std::ostream &os) const;

private:

  WifiTxVector m_rtsTxVector;

};

HighLatencyRtsTxVectorTag::HighLatencyRtsTxVectorTag ()

{

}

HighLatencyRtsTxVectorTag::HighLatencyRtsTxVectorTag ( WifiTxVector rtsTxVector)

  : m_rtsTxVector (rtsTxVector)

{

}

WifiTxVector 

HighLatencyRtsTxVectorTag::GetRtsTxVector (void) const

{

  return m_rtsTxVector;

}

TypeId

HighLatencyRtsTxVectorTag::GetTypeId (void)

{

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

    .SetParent<Tag> ()

    .AddConstructor<HighLatencyRtsTxVectorTag> ()  

    ;

  return tid;

}

TypeId

HighLatencyRtsTxVectorTag::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

uint32_t

HighLatencyRtsTxVectorTag::GetSerializedSize (void) const

{

  return sizeof (WifiTxVector);

}

void

HighLatencyRtsTxVectorTag::Serialize (TagBuffer i) const

{

  i.Write ((uint8_t *)&m_rtsTxVector, sizeof (WifiTxVector));

}

void

HighLatencyRtsTxVectorTag::Deserialize (TagBuffer i)

{

  i.Read ((uint8_t *)&m_rtsTxVector, sizeof (WifiTxVector));

}

void

HighLatencyRtsTxVectorTag::Print (std::ostream &os) const

{

  os << "Rts=" << m_rtsTxVector;

}

class HighLatencyCtsToSelfTxVectorTag : public Tag

{

public:

  HighLatencyCtsToSelfTxVectorTag ();

  HighLatencyCtsToSelfTxVectorTag (WifiTxVector ctsToSelfTxVector);

  /**

   * \returns the transmission mode to use for the CTS-to-self.

   */

  WifiTxVector GetCtsToSelfTxVector (void) const;

  static TypeId GetTypeId (void);

  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer i) const;

  virtual void Deserialize (TagBuffer i);

  virtual void Print (std::ostream &os) const;

private:

  WifiTxVector m_ctsToSelfTxVector;

};

HighLatencyCtsToSelfTxVectorTag::HighLatencyCtsToSelfTxVectorTag ()

{

}

HighLatencyCtsToSelfTxVectorTag::HighLatencyCtsToSelfTxVectorTag ( WifiTxVector ctsToSelfTxVector)

  : m_ctsToSelfTxVector (ctsToSelfTxVector)

{

}

WifiTxVector 

HighLatencyCtsToSelfTxVectorTag::GetCtsToSelfTxVector (void) const

{

  return m_ctsToSelfTxVector;

}

TypeId

HighLatencyCtsToSelfTxVectorTag::GetTypeId (void)

{

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

    .SetParent<Tag> ()

    .AddConstructor<HighLatencyCtsToSelfTxVectorTag> ()  

    ;

  return tid;

}

TypeId

HighLatencyCtsToSelfTxVectorTag::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

uint32_t

HighLatencyCtsToSelfTxVectorTag::GetSerializedSize (void) const

{

  return sizeof (WifiTxVector);

}

void

HighLatencyCtsToSelfTxVectorTag::Serialize (TagBuffer i) const

{

  i.Write ((uint8_t *)&m_ctsToSelfTxVector, sizeof (WifiTxVector));

}

void

HighLatencyCtsToSelfTxVectorTag::Deserialize (TagBuffer i)

{

  i.Read ((uint8_t *)&m_ctsToSelfTxVector, sizeof (WifiTxVector));

}

void

HighLatencyCtsToSelfTxVectorTag::Print (std::ostream &os) const

{

  os << "Cts To Self=" << m_ctsToSelfTxVector;

}

} // namespace ns3

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (WifiRemoteStationManager);

TypeId

WifiRemoteStationManager::GetTypeId (void)

{

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

    .SetParent<Object> ()

    .AddAttribute ("IsLowLatency", "If true, we attempt to modelize a so-called low-latency device: a device"

                   " where decisions about tx parameters can be made on a per-packet basis and feedback about the"

                   " transmission of each packet is obtained before sending the next. Otherwise, we modelize a "

                   " high-latency device, that is a device where we cannot update our decision about tx parameters"

                   " after every packet transmission.",

                   BooleanValue (true), // this value is ignored because there is no setter

                   MakeBooleanAccessor (&WifiRemoteStationManager::IsLowLatency),

                   MakeBooleanChecker ())

    .AddAttribute ("MaxSsrc", "The maximum number of retransmission attempts for an RTS. This value"

                   " will not have any effect on some rate control algorithms.",

                   UintegerValue (7),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_maxSsrc),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("MaxSlrc", "The maximum number of retransmission attempts for a DATA packet. This value"

                   " will not have any effect on some rate control algorithms.",

                   UintegerValue (7),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_maxSlrc),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("RtsCtsThreshold", "If  the size of the data packet + LLC header + MAC header + FCS trailer is bigger than "

                   "this value, we use an RTS/CTS handshake before sending the data, as per IEEE Std. 802.11-2012, Section 9.3.5. "

                   "This value will not have any effect on some rate control algorithms.",

                   UintegerValue (2346),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_rtsCtsThreshold),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("FragmentationThreshold", "If the size of the data packet + LLC header + MAC header + FCS trailer is bigger"

                   "than this value, we fragment it such that the size of the fragments are equal or smaller "

                   "than this value, as per IEEE Std. 802.11-2012, Section 9.5. "

                   "This value will not have any effect on some rate control algorithms.",

                   UintegerValue (2346),

                   MakeUintegerAccessor (&WifiRemoteStationManager::DoSetFragmentationThreshold,

                                         &WifiRemoteStationManager::DoGetFragmentationThreshold),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("NonUnicastMode", "Wifi mode used for non-unicast transmissions.",

                   WifiModeValue (),

                   MakeWifiModeAccessor (&WifiRemoteStationManager::m_nonUnicastMode),

                   MakeWifiModeChecker ())

    .AddAttribute ("DefaultTxPowerLevel", "Default power level to be used for transmissions. "

                   "This is the power level that is used by all those WifiManagers that do not"

                   "implement TX power control.",

                   UintegerValue (0),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_defaultTxPowerLevel),

                   MakeUintegerChecker<uint8_t> ())

    .AddTraceSource ("MacTxRtsFailed",

                     "The transmission of a RTS by the MAC layer has failed",

                     MakeTraceSourceAccessor (&WifiRemoteStationManager::m_macTxRtsFailed))

    .AddTraceSource ("MacTxDataFailed",

                     "The transmission of a data packet by the MAC layer has failed",

                     MakeTraceSourceAccessor (&WifiRemoteStationManager::m_macTxDataFailed))

    .AddTraceSource ("MacTxFinalRtsFailed",

                     "The transmission of a RTS has exceeded the maximum number of attempts",

                     MakeTraceSourceAccessor (&WifiRemoteStationManager::m_macTxFinalRtsFailed))

    .AddTraceSource ("MacTxFinalDataFailed",

                     "The transmission of a data packet has exceeded the maximum number of attempts",

                     MakeTraceSourceAccessor (&WifiRemoteStationManager::m_macTxFinalDataFailed))

  ;

  return tid;

}

WifiRemoteStationManager::WifiRemoteStationManager ()

{

}

WifiRemoteStationManager::~WifiRemoteStationManager ()

{

}

void

WifiRemoteStationManager::DoDispose (void)

{

  for (StationStates::const_iterator i = m_states.begin (); i != m_states.end (); i++)

    {

      delete (*i);

    }

  m_states.clear ();

  for (Stations::const_iterator i = m_stations.begin (); i != m_stations.end (); i++)

    {

      delete (*i);

    }

  m_stations.clear ();

}

void

WifiRemoteStationManager::SetupPhy (Ptr<WifiPhy> phy)

{

  // We need to track our PHY because it is the object that knows the

  // full set of transmit rates that are supported. We need to know

  // this in order to find the relevant mandatory rates when chosing a

  // transmit rate for automatic control responses like

  // acknowledgements.

  m_wifiPhy = phy;

  m_defaultTxMode = phy->GetMode (0);

  if(HasHtSupported())

    {

       m_defaultTxMcs = phy->GetMcs (0);

    }

  else

    {

      m_defaultTxMcs = 0;

    }

  Reset ();

}

void

WifiRemoteStationManager::SetupMac (Ptr<WifiMac> mac)

{

  // We need to track our MAC because it is the object that knows the

  // full set of interframe spaces.

  m_wifiMac = mac;

  Reset ();

}

void

WifiRemoteStationManager::SetHtSupported (bool enable)

{

  m_htSupported=enable;

}

bool

WifiRemoteStationManager::HasHtSupported (void) const

{

  return m_htSupported;

}

uint32_t

WifiRemoteStationManager::GetMaxSsrc (void) const

{

  return m_maxSsrc;

}

uint32_t

WifiRemoteStationManager::GetMaxSlrc (void) const

{

  return m_maxSlrc;

}

uint32_t

WifiRemoteStationManager::GetRtsCtsThreshold (void) const

{

  return m_rtsCtsThreshold;

}

uint32_t

WifiRemoteStationManager::GetFragmentationThreshold (void) const

{

  return DoGetFragmentationThreshold ();

}

void

WifiRemoteStationManager::SetMaxSsrc (uint32_t maxSsrc)

{

  m_maxSsrc = maxSsrc;

}

void

WifiRemoteStationManager::SetMaxSlrc (uint32_t maxSlrc)

{

  m_maxSlrc = maxSlrc;

}

void

WifiRemoteStationManager::SetRtsCtsThreshold (uint32_t threshold)

{

  m_rtsCtsThreshold = threshold;

}

void

WifiRemoteStationManager::SetFragmentationThreshold (uint32_t threshold)

{

  DoSetFragmentationThreshold (threshold);

}

void

WifiRemoteStationManager::Reset (Mac48Address address)

{

  NS_LOG_FUNCTION (this << address);

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  state->m_operationalRateSet.clear ();

  state->m_operationalMcsSet.clear ();

  AddSupportedMode (address, GetDefaultMode ());

  AddSupportedMcs(address,GetDefaultMcs());

}

void

WifiRemoteStationManager::AddSupportedMode (Mac48Address address, WifiMode mode)

{

  NS_LOG_FUNCTION (this << address << mode);

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  for (WifiModeListIterator i = state->m_operationalRateSet.begin (); i != state->m_operationalRateSet.end (); i++)

    {

      if ((*i) == mode)

        {

          // already in.

          return;

        }

    }

  state->m_operationalRateSet.push_back (mode);

}

/*void

WifiRemoteStationManager::AddBssMembershipParameters(Mac48Address address, uint32_t selector)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  WifiMode mode;

  WifiModeList membershipselectormodes = m_wifiPhy->GetMembershipSelectorModes(selector);

  for (WifiModeListIterator j = membershipselectormodes.begin (); j != membershipselectormodes.end (); j++)

    {

      mode=(*j);

     for (WifiModeListIterator i = state->m_operationalRateSet.begin (); i != state->m_operationalRateSet.end (); i++)

      {

        if ((*i) == mode)

          {

            // already in.

            break;

          }

      }

    state->m_operationalRateSet.push_back (mode);

  }

}*/

void 

WifiRemoteStationManager::AddSupportedMcs (Mac48Address address, uint8_t mcs)

{

  NS_LOG_FUNCTION (this << address << (uint16_t) mcs);

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  for (WifiMcsListIterator i = state->m_operationalMcsSet.begin (); i != state->m_operationalMcsSet.end (); i++)

    {

      if ((*i) == mcs)

        {

          // already in.

          return;

        }

    }

  state->m_operationalMcsSet.push_back (mcs);

}

bool

WifiRemoteStationManager::IsBrandNew (Mac48Address address) const

{