#include "ns3/double.h"

#include "wifi-mac-header.h"

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (WifiRemoteStationManager);

WifiRemoteStationManager::GetTypeId (void)

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

    .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),

                   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 a data packet is bigger than this value, we use an RTS/CTS handshake"

                   " before sending the data. This value will not have any effect on some rate control algorithms.",

                   UintegerValue (1500),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_rtsCtsThreshold),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("FragmentationThreshold", "If a data packet is bigger than this value, we fragment it such that"

                   " the size of the fragments are equal or smaller than this value. This value will not have any effect"

                   " on some rate control algorithms.",

                   UintegerValue (1500),

                   MakeUintegerAccessor (&WifiRemoteStationManager::m_fragmentationThreshold),

                   MakeUintegerChecker<uint32_t> ())

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

                   WifiModeValue (),

                   MakeWifiModeAccessor (&WifiRemoteStationManager::m_nonUnicastMode),

                   MakeWifiModeChecker ())

    .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))

    .AddAttribute("AvgSlrcCoefficient", "The weigh of the slrc count in the slrc avg calculation",

                  DoubleValue (0.9),

                  MakeDoubleAccessor (&WifiRemoteStationManager::m_avgSlrcCoefficient),

                  MakeDoubleChecker<double> ())

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)

{

  m_defaultTxMode = phy->GetMode (0);

  Reset ();

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 m_fragmentationThreshold;

}

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;

WifiRemoteStationManager::SetFragmentationThreshold (uint32_t threshold)

{

  m_fragmentationThreshold = threshold;

} 

void

WifiRemoteStationManager::Reset (Mac48Address address)

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  state->m_modes.clear ();

  AddSupportedMode (address, GetDefaultMode ());

void

WifiRemoteStationManager::AddSupportedMode (Mac48Address address, WifiMode mode)

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStationState *state = LookupState (address);

  for (WifiRemoteStationState::SupportedModes::const_iterator i = state->m_modes.begin (); i != state->m_modes.end (); i++)

    {

      if ((*i) == mode)

        {

          // already in.

          return;

        }

    }

  state->m_modes.push_back (mode);

bool

WifiRemoteStationManager::IsBrandNew (Mac48Address address) const

  if (address.IsGroup ())

    {

      return false;

    }

  return LookupState (address)->m_state == WifiRemoteStationState::BRAND_NEW;

bool

WifiRemoteStationManager::IsAssociated (Mac48Address address) const

{

  if (address.IsGroup ())

    {

      return true;

    }

  return LookupState (address)->m_state == WifiRemoteStationState::GOT_ASSOC_TX_OK;

}

bool

WifiRemoteStationManager::IsWaitAssocTxOk (Mac48Address address) const

  if (address.IsGroup ())

    {

      return false;

    }

  return LookupState (address)->m_state == WifiRemoteStationState::WAIT_ASSOC_TX_OK;

}

void

WifiRemoteStationManager::RecordWaitAssocTxOk (Mac48Address address)

{

  NS_ASSERT (!address.IsGroup ());

  LookupState (address)->m_state = WifiRemoteStationState::WAIT_ASSOC_TX_OK;

void

WifiRemoteStationManager::RecordGotAssocTxOk (Mac48Address address)

{

  NS_ASSERT (!address.IsGroup ());

  LookupState (address)->m_state = WifiRemoteStationState::GOT_ASSOC_TX_OK;

}

void

WifiRemoteStationManager::RecordGotAssocTxFailed (Mac48Address address)

  NS_ASSERT (!address.IsGroup ());

  LookupState (address)->m_state = WifiRemoteStationState::DISASSOC;

void

WifiRemoteStationManager::RecordDisassociated (Mac48Address address)

  NS_ASSERT (!address.IsGroup ());

  LookupState (address)->m_state = WifiRemoteStationState::DISASSOC;

}

void

WifiRemoteStationManager::PrepareForQueue (Mac48Address address, const WifiMacHeader *header,

                                           Ptr<const Packet> packet, uint32_t fullPacketSize)

{

  if (IsLowLatency () || address.IsGroup ())

  TxModeTag tag = TxModeTag (GetRtsMode (address, header, packet), 

                             GetDataMode (address, header, packet, fullPacketSize));

  packet->AddPacketTag (tag);

}

WifiMode

WifiRemoteStationManager::GetDataMode (Mac48Address address, const WifiMacHeader *header,

                                       Ptr<const Packet> packet, uint32_t fullPacketSize)

{

  if (address.IsGroup ())

    {

      return GetNonUnicastMode ();

    }

  if (!IsLowLatency ())

    {

      // Note: removing the packet below is wrong: what happens in case of retransmissions ???

      TxModeTag tag;

      bool found;

      found = ConstCast<Packet> (packet)->RemovePacketTag (tag);

      NS_ASSERT (found);

      return tag.GetDataMode ();

    }

  return DoGetDataMode (Lookup (address, header), fullPacketSize);

}

WifiMode

WifiRemoteStationManager::GetRtsMode (Mac48Address address, const WifiMacHeader *header,

                                      Ptr<const Packet> packet)

{

  NS_ASSERT (!address.IsGroup ());

  if (!IsLowLatency ())

    {

      TxModeTag tag;

      bool found;

      found = ConstCast<Packet> (packet)->RemovePacketTag (tag);

      NS_ASSERT (found);

      return tag.GetRtsMode ();

    }

  return DoGetRtsMode (Lookup (address, header));

}

void

WifiRemoteStationManager::ReportRtsFailed (Mac48Address address, const WifiMacHeader *header)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_ssrc++;

  m_macTxRtsFailed (address);

  DoReportRtsFailed (station);

}

void

WifiRemoteStationManager::ReportDataFailed (Mac48Address address, const WifiMacHeader *header)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_slrc++;

  m_macTxDataFailed (address);

  DoReportDataFailed (station);

}

void

WifiRemoteStationManager::ReportRtsOk (Mac48Address address, const WifiMacHeader *header,

                                       double ctsSnr, WifiMode ctsMode, double rtsSnr)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_ssrc = 0;

  DoReportRtsOk (station, ctsSnr, ctsMode, rtsSnr);

}

void

WifiRemoteStationManager::ReportDataOk (Mac48Address address, const WifiMacHeader *header,

                                        double ackSnr, WifiMode ackMode, double dataSnr)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_avgSlrc = station->m_avgSlrc * m_avgSlrcCoefficient + (double) station->m_slrc * (1 - m_avgSlrcCoefficient);

  station->m_slrc = 0;

  DoReportDataOk (station, ackSnr, ackMode, dataSnr);

}

void

WifiRemoteStationManager::ReportFinalRtsFailed (Mac48Address address, const WifiMacHeader *header)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_ssrc = 0;

  m_macTxFinalRtsFailed (address);

  DoReportFinalRtsFailed (station);

}

void

WifiRemoteStationManager::ReportFinalDataFailed (Mac48Address address, const WifiMacHeader *header)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  station->m_slrc = 0;

  m_macTxFinalDataFailed (address);

  DoReportFinalDataFailed (station);

}

void

WifiRemoteStationManager::ReportRxOk (Mac48Address address, const WifiMacHeader *header,

                                      double rxSnr, WifiMode txMode)

{

  if (address.IsGroup ())

    {

      return;

    }

  WifiRemoteStation *station = Lookup (address, header);

  DoReportRxOk (station, rxSnr, txMode);

}

bool

WifiRemoteStationManager::NeedRts (Mac48Address address, const WifiMacHeader *header,

                                   Ptr<const Packet> packet)

{

  if (address.IsGroup ())

    {

      return false;

    }

  bool normally = packet->GetSize () > GetRtsCtsThreshold ();

  return DoNeedRts (Lookup (address, header), packet, normally);

}

bool

WifiRemoteStationManager::NeedRtsRetransmission (Mac48Address address, const WifiMacHeader *header,

                                                 Ptr<const Packet> packet)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  bool normally = station->m_ssrc < GetMaxSsrc ();

  return DoNeedRtsRetransmission (station, packet, normally);

}

bool

WifiRemoteStationManager::NeedDataRetransmission (Mac48Address address, const WifiMacHeader *header,

                                                  Ptr<const Packet> packet)

{

  NS_ASSERT (!address.IsGroup ());

  WifiRemoteStation *station = Lookup (address, header);

  bool normally = station->m_slrc < GetMaxSlrc ();

  return DoNeedDataRetransmission (station, packet, normally);

}

bool

WifiRemoteStationManager::NeedFragmentation (Mac48Address address, const WifiMacHeader *header,

                                             Ptr<const Packet> packet)

{

  if (address.IsGroup ())

    {

      return false;

    }

  WifiRemoteStation *station = Lookup (address, header);

  bool normally = packet->GetSize () > GetFragmentationThreshold ();

  return DoNeedFragmentation (station, packet, normally);

}

uint32_t

WifiRemoteStationManager::GetNFragments (Ptr<const Packet> packet)

{

  uint32_t nFragments = packet->GetSize () / GetFragmentationThreshold () + 1;

  return nFragments;

uint32_t

WifiRemoteStationManager::GetFragmentSize (Mac48Address address, const WifiMacHeader *header,