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

/*

 * Copyright (c) 2005,2006 INRIA

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

 * Author: Mirko Banchi <mk.banchi@gmail.com>

 */

#include "ns3/assert.h"

#include "ns3/packet.h"

#include "ns3/simulator.h"

#include "ns3/tag.h"

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/double.h"

#include "mac-low.h"

#include "wifi-phy.h"

#include "wifi-mac-trailer.h"

#include "qos-utils.h"

#include "edca-txop-n.h"

#include "snr-tag.h"

#include "yans-wifi-phy.h"

#include "ampdu-tag.h"

#include "wifi-mac-queue.h"

#include "mpdu-aggregator.h"

#undef NS_LOG_APPEND_CONTEXT

#define NS_LOG_APPEND_CONTEXT std::clog << "[mac=" << m_self << "] "

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("MacLow");

MacLowTransmissionListener::MacLowTransmissionListener ()

{

}

MacLowTransmissionListener::~MacLowTransmissionListener ()

{

}

void

MacLowTransmissionListener::GotBlockAck (const CtrlBAckResponseHeader *blockAck, Mac48Address source, WifiMode mode)

{

}

void

MacLowTransmissionListener::MissedBlockAck (void)

{

}

MacLowDcfListener::MacLowDcfListener ()

{

}

MacLowDcfListener::~MacLowDcfListener ()

{

}

MacLowBlockAckEventListener::MacLowBlockAckEventListener ()

{

}

MacLowBlockAckEventListener::~MacLowBlockAckEventListener ()

{

}

void MacLowBlockAckEventListener::SetAmpdu (bool ampdu)

{

}

void MacLowBlockAckEventListener::CompleteTransfer(Mac48Address address, uint8_t tid)

{

}

void

MacLowBlockAckEventListener::CompleteMpduTx (Ptr<const Packet> packet, WifiMacHeader hdr, Time tstamp)

{

}

uint16_t 

MacLowBlockAckEventListener::GetNextSequenceNumberfor (WifiMacHeader *hdr)

{

 return 0;

}

uint16_t 

MacLowBlockAckEventListener::PeekNextSequenceNumberfor (WifiMacHeader *hdr)

{

 return 0;

}

Ptr<const Packet> 

MacLowBlockAckEventListener::PeekNextPacketInBaQueue (WifiMacHeader &header, Mac48Address recipient, uint8_t tid, Time *timestamp)

{

 return 0;

}

void 

MacLowBlockAckEventListener::RemoveFromBaQueue (uint8_t tid, Mac48Address recipient, uint16_t seqnumber)

{

}

uint32_t 

MacLowBlockAckEventListener::GetNOutstandingPackets (Mac48Address recipient, uint8_t tid)

{

  return 0;

}

uint32_t 

MacLowBlockAckEventListener::GetNRetryNeededPackets (Mac48Address recipient, uint8_t tid) const

{

  return 0;

}

MacLowTransmissionParameters::MacLowTransmissionParameters ()

  : m_nextSize (0),

    m_waitAck (ACK_NONE),

    m_sendRts (false),

    m_overrideDurationId (Seconds (0))

{

}

void

MacLowTransmissionParameters::EnableNextData (uint32_t size)

{

  m_nextSize = size;

}

void

MacLowTransmissionParameters::DisableNextData (void)

{

  m_nextSize = 0;

}

void

MacLowTransmissionParameters::EnableOverrideDurationId (Time durationId)

{

  m_overrideDurationId = durationId;

}

void

MacLowTransmissionParameters::DisableOverrideDurationId (void)

{

  m_overrideDurationId = Seconds (0);

}

void

MacLowTransmissionParameters::EnableSuperFastAck (void)

{

  m_waitAck = ACK_SUPER_FAST;

}

void

MacLowTransmissionParameters::EnableBasicBlockAck (void)

{

  m_waitAck = BLOCK_ACK_BASIC;

}

void

MacLowTransmissionParameters::EnableCompressedBlockAck (void)

{

  m_waitAck = BLOCK_ACK_COMPRESSED;

}

void

MacLowTransmissionParameters::EnableMultiTidBlockAck (void)

{

  m_waitAck = BLOCK_ACK_MULTI_TID;

}

void

MacLowTransmissionParameters::EnableFastAck (void)

{

  m_waitAck = ACK_FAST;

}

void

MacLowTransmissionParameters::EnableAck (void)

{

  m_waitAck = ACK_NORMAL;

}

void

MacLowTransmissionParameters::DisableAck (void)

{

  m_waitAck = ACK_NONE;

}

void

MacLowTransmissionParameters::EnableRts (void)

{

  m_sendRts = true;

}

void

MacLowTransmissionParameters::DisableRts (void)

{

  m_sendRts = false;

}

bool

MacLowTransmissionParameters::MustWaitAck (void) const

{

  return (m_waitAck != ACK_NONE);

}

bool

MacLowTransmissionParameters::MustWaitNormalAck (void) const

{

  return (m_waitAck == ACK_NORMAL);

}

bool

MacLowTransmissionParameters::MustWaitFastAck (void) const

{

  return (m_waitAck == ACK_FAST);

}

bool

MacLowTransmissionParameters::MustWaitSuperFastAck (void) const

{

  return (m_waitAck == ACK_SUPER_FAST);

}

bool

MacLowTransmissionParameters::MustWaitBasicBlockAck (void) const

{

  return (m_waitAck == BLOCK_ACK_BASIC) ? true : false;

}

bool

MacLowTransmissionParameters::MustWaitCompressedBlockAck (void) const

{

  return (m_waitAck == BLOCK_ACK_COMPRESSED) ? true : false;

}

bool

MacLowTransmissionParameters::MustWaitMultiTidBlockAck (void) const

{

  return (m_waitAck == BLOCK_ACK_MULTI_TID) ? true : false;

}

bool

MacLowTransmissionParameters::MustSendRts (void) const

{

  return m_sendRts;

}

bool

MacLowTransmissionParameters::HasDurationId (void) const

{

  return (m_overrideDurationId != Seconds (0));

}

Time

MacLowTransmissionParameters::GetDurationId (void) const

{

  NS_ASSERT (m_overrideDurationId != Seconds (0));

  return m_overrideDurationId;

}

bool

MacLowTransmissionParameters::HasNextPacket (void) const

{

  return (m_nextSize != 0);

}

uint32_t

MacLowTransmissionParameters::GetNextPacketSize (void) const

{

  NS_ASSERT (HasNextPacket ());

  return m_nextSize;

}

std::ostream &operator << (std::ostream &os, const MacLowTransmissionParameters &params)

{

  os << "["

  << "send rts=" << params.m_sendRts << ", "

  << "next size=" << params.m_nextSize << ", "

  << "dur=" << params.m_overrideDurationId << ", "

  << "ack=";

  switch (params.m_waitAck)

    {

    case MacLowTransmissionParameters::ACK_NONE:

      os << "none";

      break;

    case MacLowTransmissionParameters::ACK_NORMAL:

      os << "normal";

      break;

    case MacLowTransmissionParameters::ACK_FAST:

      os << "fast";

      break;

    case MacLowTransmissionParameters::ACK_SUPER_FAST:

      os << "super-fast";

      break;

    case MacLowTransmissionParameters::BLOCK_ACK_BASIC:

      os << "basic-block-ack";

      break;

    case MacLowTransmissionParameters::BLOCK_ACK_COMPRESSED:

      os << "compressed-block-ack";

      break;

    case MacLowTransmissionParameters::BLOCK_ACK_MULTI_TID:

      os << "multi-tid-block-ack";

      break;

    }

  os << "]";

  return os;

}

/**

 * Listener for PHY events. Forwards to MacLow

 */

class PhyMacLowListener : public ns3::WifiPhyListener

{

public:

  /**

   * Create a PhyMacLowListener for the given MacLow.

   *

   * \param macLow

   */

  PhyMacLowListener (ns3::MacLow *macLow)

    : m_macLow (macLow)

  {

  }

  virtual ~PhyMacLowListener ()

  {

  }

  virtual void NotifyRxStart (Time duration)

  {

  }

  virtual void NotifyRxEndOk (void)

  {

  }

  virtual void NotifyRxEndError (void)

  {

  }

  virtual void NotifyTxStart (Time duration, double txPowerDbm)

  {

  }

  virtual void NotifyMaybeCcaBusyStart (Time duration)

  {

  }

  virtual void NotifySwitchingStart (Time duration)

  {

    m_macLow->NotifySwitchingStartNow (duration);

  }

  virtual void NotifySleep (void)

  {

    m_macLow->NotifySleepNow ();

  }

  virtual void NotifyWakeup (void)

  {

  }

private:

  ns3::MacLow *m_macLow;

};

MacLow::MacLow ()

  : m_normalAckTimeoutEvent (),

    m_fastAckTimeoutEvent (),

    m_superFastAckTimeoutEvent (),

    m_fastAckFailedTimeoutEvent (),

    m_blockAckTimeoutEvent (),

    m_ctsTimeoutEvent (),

    m_sendCtsEvent (),

    m_sendAckEvent (),

    m_sendDataEvent (),

    m_waitSifsEvent (),

    m_endTxNoAckEvent (),

    m_mpduAggregator (0),

    m_currentPacket (0),

    m_listener (0),

    m_phyMacLowListener (0),

    m_ctsToSelfSupported (false),

    m_receivedAtLeastOneMpdu (false)

{

  NS_LOG_FUNCTION (this);

  m_lastNavDuration = Seconds (0);

  m_lastNavStart = Seconds (0);

  m_promisc = false;

  m_ampdu = false;

  m_sentMpdus = 0;

  m_aggregateQueue = CreateObject<WifiMacQueue> ();

}

MacLow::~MacLow ()

{

  NS_LOG_FUNCTION (this);

}

void

MacLow::SetupPhyMacLowListener (Ptr<WifiPhy> phy)

{

  m_phyMacLowListener = new PhyMacLowListener (this);

  phy->RegisterListener (m_phyMacLowListener);

}

void

MacLow::RemovePhyMacLowListener (Ptr<WifiPhy> phy)

{

  if (m_phyMacLowListener != 0 )

    {

      phy->UnregisterListener (m_phyMacLowListener);

      delete m_phyMacLowListener;

      m_phyMacLowListener = 0;

    }

}

void

MacLow::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

  m_normalAckTimeoutEvent.Cancel ();

  m_fastAckTimeoutEvent.Cancel ();

  m_superFastAckTimeoutEvent.Cancel ();

  m_fastAckFailedTimeoutEvent.Cancel ();

  m_blockAckTimeoutEvent.Cancel ();

  m_ctsTimeoutEvent.Cancel ();

  m_sendCtsEvent.Cancel ();

  m_sendAckEvent.Cancel ();

  m_sendDataEvent.Cancel ();

  m_waitSifsEvent.Cancel ();

  m_endTxNoAckEvent.Cancel ();

   m_waitRifsEvent.Cancel();

  m_phy = 0;

  m_stationManager = 0;

  if (m_phyMacLowListener != 0)

    {

	  delete m_phyMacLowListener;

	  m_phyMacLowListener = 0;

    }

  m_mpduAggregator = 0;

  m_sentMpdus = 0;

  m_aggregateQueue = 0;

  m_ampdu = false;

}

void

MacLow::CancelAllEvents (void)

{

  NS_LOG_FUNCTION (this);

  bool oneRunning = false;

  if (m_normalAckTimeoutEvent.IsRunning ())

    {

      m_normalAckTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_fastAckTimeoutEvent.IsRunning ())

    {

      m_fastAckTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_superFastAckTimeoutEvent.IsRunning ())

    {

      m_superFastAckTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_fastAckFailedTimeoutEvent.IsRunning ())

    {

      m_fastAckFailedTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_blockAckTimeoutEvent.IsRunning ())

    {

      m_blockAckTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_ctsTimeoutEvent.IsRunning ())

    {

      m_ctsTimeoutEvent.Cancel ();

      oneRunning = true;

    }

  if (m_sendCtsEvent.IsRunning ())

    {

      m_sendCtsEvent.Cancel ();

      oneRunning = true;

    }

  if (m_sendAckEvent.IsRunning ())

    {

      m_sendAckEvent.Cancel ();

      oneRunning = true;

    }

  if (m_sendDataEvent.IsRunning ())

    {

      m_sendDataEvent.Cancel ();

      oneRunning = true;

    }

  if (m_waitSifsEvent.IsRunning ())

    {

      m_waitSifsEvent.Cancel ();

      oneRunning = true;

    }

  if (m_waitRifsEvent.IsRunning ())

    {

      m_waitRifsEvent.Cancel ();

      oneRunning = true;

    }

  if (m_endTxNoAckEvent.IsRunning ()) 

    {

      m_endTxNoAckEvent.Cancel ();

      oneRunning = true;

    }

  if (oneRunning && m_listener != 0)

    {

      m_listener->Cancel ();

      m_listener = 0;

    }

}

void

MacLow::SetPhy (Ptr<WifiPhy> phy)

{

  m_phy = phy;

  m_phy->SetReceiveOkCallback (MakeCallback (&MacLow::DeaggregateAmpduAndReceive, this));