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

/*

 * Copyright (c) 2006, 2009 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/log.h"

#include "ns3/assert.h"

#include "ns3/pointer.h"

#include "edca-txop-n.h"

#include "mac-low.h"

#include "dcf-manager.h"

#include "mac-tx-middle.h"

#include "wifi-mac-trailer.h"

#include "wifi-mac.h"

#include "random-stream.h"

#include "wifi-mac-queue.h"

#include "msdu-aggregator.h"

#include "mgt-headers.h"

#include "qos-blocked-destinations.h"

#undef NS_LOG_APPEND_CONTEXT

#define NS_LOG_APPEND_CONTEXT if (m_low != 0) { std::clog << "[mac=" << m_low->GetAddress () << "] "; }

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("EdcaTxopN");

class EdcaTxopN::Dcf : public DcfState

{

public:

  Dcf (EdcaTxopN * txop)

    : m_txop (txop)

  {

  }

private:

  virtual void DoNotifyAccessGranted (void)

  {

    m_txop->NotifyAccessGranted ();

  }

  virtual void DoNotifyInternalCollision (void)

  {

    m_txop->NotifyInternalCollision ();

  }

  virtual void DoNotifyCollision (void)

  {

    m_txop->NotifyCollision ();

  }

  virtual void DoNotifyChannelSwitching (void)

  {

    m_txop->NotifyChannelSwitching ();

  }

  virtual void DoNotifySleep (void)

  {

    m_txop->NotifySleep ();

  }

  virtual void DoNotifyWakeUp (void)

  {

    m_txop->NotifyWakeUp ();

  }

  EdcaTxopN *m_txop;

};

class EdcaTxopN::TransmissionListener : public MacLowTransmissionListener

{

public:

  TransmissionListener (EdcaTxopN * txop)

    : MacLowTransmissionListener (),

      m_txop (txop) {

  }

  virtual ~TransmissionListener () {}

  virtual void GotCts (double snr, WifiMode txMode)

  {

    m_txop->GotCts (snr, txMode);

  }

  virtual void MissedCts (void)

  {

    m_txop->MissedCts ();

  }

  virtual void GotAck (double snr, WifiMode txMode)

  {

    m_txop->GotAck (snr, txMode);

  }

  virtual void MissedAck (void)

  {

    m_txop->MissedAck ();

  }

  {

  }

  virtual void MissedBlockAck (void)

  {

    m_txop->MissedBlockAck ();

  }

  virtual void StartNext (void)

  {

    m_txop->StartNext ();

  }

  virtual void Cancel (void)

  {

    m_txop->Cancel ();

  }

  virtual void EndTxNoAck (void)

  {

    m_txop->EndTxNoAck ();

  }

private:

  EdcaTxopN *m_txop;

};

class EdcaTxopN::BlockAckEventListener : public MacLowBlockAckEventListener

{

public:

  BlockAckEventListener (EdcaTxopN * txop)

    : MacLowBlockAckEventListener (),

      m_txop (txop) {

  }

  virtual ~BlockAckEventListener () {}

  virtual void BlockAckInactivityTimeout (Mac48Address address, uint8_t tid)

  {

    m_txop->SendDelbaFrame (address, tid, false);

  }

private:

  EdcaTxopN *m_txop;

};

NS_OBJECT_ENSURE_REGISTERED (EdcaTxopN);

TypeId

EdcaTxopN::GetTypeId (void)

{

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

    .SetParent (ns3::Dcf::GetTypeId ())

    .AddConstructor<EdcaTxopN> ()

    .AddAttribute ("BlockAckThreshold", "If number of packets in this queue reaches this value,\

                                         block ack mechanism is used. If this value is 0, block ack is never used.",

                   UintegerValue (0),

                   MakeUintegerAccessor (&EdcaTxopN::SetBlockAckThreshold,

                                         &EdcaTxopN::GetBlockAckThreshold),

                   MakeUintegerChecker<uint8_t> (0, 64))

    .AddAttribute ("BlockAckInactivityTimeout", "Represents max time (blocks of 1024 micro seconds) allowed for block ack\

                                                 inactivity. If this value isn't equal to 0 a timer start after that a\

                                                 block ack setup is completed and will be reset every time that a block\

                                                 ack frame is received. If this value is 0, block ack inactivity timeout won't be used.",

                   UintegerValue (0),

                   MakeUintegerAccessor (&EdcaTxopN::SetBlockAckInactivityTimeout),

                   MakeUintegerChecker<uint16_t> ())

    .AddAttribute ("Queue", "The WifiMacQueue object",

                   PointerValue (),

                   MakePointerChecker<WifiMacQueue> ())

  ;

  return tid;

}

EdcaTxopN::EdcaTxopN ()

  : m_manager (0),

    m_currentPacket (0),

    m_aggregator (0),

{

  NS_LOG_FUNCTION (this);

  m_transmissionListener = new EdcaTxopN::TransmissionListener (this);

  m_blockAckListener = new EdcaTxopN::BlockAckEventListener (this);

  m_dcf = new EdcaTxopN::Dcf (this);

  m_queue = CreateObject<WifiMacQueue> ();

  m_rng = new RealRandomStream ();

  m_qosBlockedDestinations = new QosBlockedDestinations ();

  m_baManager = new BlockAckManager ();

  m_baManager->SetQueue (m_queue);

  m_baManager->SetBlockAckType (m_blockAckType);

  m_baManager->SetBlockDestinationCallback (MakeCallback (&QosBlockedDestinations::Block, m_qosBlockedDestinations));

  m_baManager->SetUnblockDestinationCallback (MakeCallback (&QosBlockedDestinations::Unblock, m_qosBlockedDestinations));

  m_baManager->SetMaxPacketDelay (m_queue->GetMaxDelay ());

}

EdcaTxopN::~EdcaTxopN ()

{

  NS_LOG_FUNCTION (this);

}

void

EdcaTxopN::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

  m_queue = 0;

  m_low = 0;

  m_stationManager = 0;

  delete m_transmissionListener;

  delete m_dcf;

  delete m_rng;

  delete m_qosBlockedDestinations;

  delete m_baManager;

  delete m_blockAckListener;

  m_transmissionListener = 0;

  m_dcf = 0;

  m_rng = 0;

  m_qosBlockedDestinations = 0;

  m_baManager = 0;

  m_blockAckListener = 0;

  m_txMiddle = 0;

  m_aggregator = 0;

}

void

EdcaTxopN::SetManager (DcfManager *manager)

{

  NS_LOG_FUNCTION (this << manager);

  m_manager = manager;

  m_manager->Add (m_dcf);

}

void

EdcaTxopN::SetTxOkCallback (TxOk callback)

{

  NS_LOG_FUNCTION (this << &callback);

  m_txOkCallback = callback;

}

void

EdcaTxopN::SetTxFailedCallback (TxFailed callback)

{

  NS_LOG_FUNCTION (this << &callback);

  m_txFailedCallback = callback;

}

void

EdcaTxopN::SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> remoteManager)

{

  NS_LOG_FUNCTION (this << remoteManager);

  m_stationManager = remoteManager;

}

void

EdcaTxopN::SetTypeOfStation (enum TypeOfStation type)

{

  NS_LOG_FUNCTION (this << static_cast<uint32_t> (type));

  m_typeOfStation = type;

}

enum TypeOfStation

EdcaTxopN::GetTypeOfStation (void) const

{

  NS_LOG_FUNCTION (this);

  return m_typeOfStation;

}

Ptr<WifiMacQueue >

{

  NS_LOG_FUNCTION (this);

  return m_queue;

}

void

EdcaTxopN::SetMinCw (uint32_t minCw)

{

  NS_LOG_FUNCTION (this << minCw);

  m_dcf->SetCwMin (minCw);

}

void

EdcaTxopN::SetMaxCw (uint32_t maxCw)

{

  NS_LOG_FUNCTION (this << maxCw);

  m_dcf->SetCwMax (maxCw);

}

void

EdcaTxopN::SetAifsn (uint32_t aifsn)

{

  NS_LOG_FUNCTION (this << aifsn);

  m_dcf->SetAifsn (aifsn);

}

uint32_t

EdcaTxopN::GetMinCw (void) const

{

  NS_LOG_FUNCTION (this);

  return m_dcf->GetCwMin ();

}

uint32_t

EdcaTxopN::GetMaxCw (void) const

{

  NS_LOG_FUNCTION (this);

  return m_dcf->GetCwMax ();

}

uint32_t

EdcaTxopN::GetAifsn (void) const

{

  NS_LOG_FUNCTION (this);

  return m_dcf->GetAifsn ();

}

void

EdcaTxopN::SetTxMiddle (MacTxMiddle *txMiddle)

{

  NS_LOG_FUNCTION (this << txMiddle);

  m_txMiddle = txMiddle;

}

Ptr<MacLow>

EdcaTxopN::Low (void)

{

  NS_LOG_FUNCTION (this);

  return m_low;

}

void

EdcaTxopN::SetLow (Ptr<MacLow> low)

{

  NS_LOG_FUNCTION (this << low);

  m_low = low;

}

bool

EdcaTxopN::NeedsAccess (void) const

{

  NS_LOG_FUNCTION (this);

  return !m_queue->IsEmpty () || m_currentPacket != 0 || m_baManager->HasPackets ();

}

void

EdcaTxopN::NotifyAccessGranted (void)

{

  NS_LOG_FUNCTION (this);

  if (m_currentPacket == 0)

    {

      if (m_queue->IsEmpty () && !m_baManager->HasPackets ())

        {

          NS_LOG_DEBUG ("queue is empty");

          return;

        }

      if (m_baManager->HasBar (m_currentBar))

        {

          SendBlockAckRequest (m_currentBar);

          return;

        }

      /* check if packets need retransmission are stored in BlockAckManager */

      m_currentPacket = m_baManager->GetNextPacket (m_currentHdr);

      if (m_currentPacket == 0)

        {

          if (m_queue->PeekFirstAvailable (&m_currentHdr, m_currentPacketTimestamp, m_qosBlockedDestinations) == 0)

            {

              NS_LOG_DEBUG ("no available packets in the queue");

              return;

            }

          if (m_currentHdr.IsQosData () && !m_currentHdr.GetAddr1 ().IsBroadcast ()

              && m_blockAckThreshold > 0

              && !m_baManager->ExistsAgreement (m_currentHdr.GetAddr1 (), m_currentHdr.GetQosTid ())

              && SetupBlockAckIfNeeded ())

            {

              return;

            }

          m_currentPacket = m_queue->DequeueFirstAvailable (&m_currentHdr, m_currentPacketTimestamp, m_qosBlockedDestinations);

          NS_ASSERT (m_currentPacket != 0);

          uint16_t sequence = m_txMiddle->GetNextSequenceNumberfor (&m_currentHdr);

          m_currentHdr.SetSequenceNumber (sequence);

          m_currentHdr.SetFragmentNumber (0);

          m_currentHdr.SetNoMoreFragments ();

          m_currentHdr.SetNoRetry ();

          m_fragmentNumber = 0;

          NS_LOG_DEBUG ("dequeued size=" << m_currentPacket->GetSize () <<

                        ", to=" << m_currentHdr.GetAddr1 () <<

                        ", seq=" << m_currentHdr.GetSequenceControl ());

          if (m_currentHdr.IsQosData () && !m_currentHdr.GetAddr1 ().IsBroadcast ())

            {

              VerifyBlockAck ();

            }

        }

    }

  MacLowTransmissionParameters params;

  params.DisableOverrideDurationId ();

  if (m_currentHdr.GetAddr1 ().IsGroup ())

    {

      params.DisableRts ();

      params.DisableAck ();