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

/*

 * Copyright (c) 2005,2006 INRIA

 * All rights reserved.

 *

 * 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 <cassert>

#include "ns3/packet.h"

#include "ns3/simulator.h"

#include "ns3/tag.h"

#include "mac-low.h"

#include "wifi-phy.h"

#include "wifi-mac-trailer.h"

#include "wifi-net-device.h"

#include "mac-stations.h"

#include "mac-parameters.h"

#define noMAC_LOW_TRACE 1

#ifdef MAC_LOW_TRACE

#  include <iostream>

#  define TRACE(x) \

  std::cout << "MAC LOW " << x << std::endl;

#else /* MAC_LOW_TRACE */

# define TRACE(x)

#endif /* MAC_LOW_TRACE */

namespace ns3 {

class SnrTag : public Tag

{

public:

  SnrTag ();

  SnrTag (const SnrTag &o);

  ~SnrTag ();

  static uint32_t GetUid (void);

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

  uint32_t GetSerializedSize (void) const;

  void Serialize (Buffer::Iterator i) const;

  uint32_t Deserialize (Buffer::Iterator i);

  void Set (double snr);

  double Get (void) const;

private:

  double m_snr;

};

SnrTag::SnrTag ()

  : m_snr (0.0)

{}

SnrTag::SnrTag (const SnrTag &o)

  : m_snr (o.m_snr)

{}

SnrTag::~SnrTag ()

{}

uint32_t 

SnrTag::GetUid (void)

{

  static uint32_t uid = AllocateUid<SnrTag> ("SnrTag.ns3.inria.fr");

  return uid;

}

void 

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

{

  os << "snr="<<m_snr;

}

uint32_t 

SnrTag::GetSerializedSize (void) const

{

  return 0;

}

void 

SnrTag::Serialize (Buffer::Iterator i) const

{

  // would need to serialize double to platform-independent format.

}

{

  // would need to deserialize double from platform-independent format.

  return 0;

}

void 

SnrTag::Set (double snr)

{

  m_snr = snr;

}

double 

SnrTag::Get (void) const

{

  return m_snr;

}

MacLowTransmissionListener::MacLowTransmissionListener ()

{}

MacLowTransmissionListener::~MacLowTransmissionListener ()

{}

MacLowNavListener::MacLowNavListener ()

{}

MacLowNavListener::~MacLowNavListener ()

{}

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::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)?true:false;

}

bool 

MacLowTransmissionParameters::MustWaitNormalAck (void) const

{

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

}

bool 

MacLowTransmissionParameters::MustWaitFastAck (void) const

{

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

}

bool 

MacLowTransmissionParameters::MustWaitSuperFastAck (void) const

{

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

}

bool 

MacLowTransmissionParameters::MustSendRts (void) const

{

  return m_sendRts;

}

bool 

MacLowTransmissionParameters::HasDurationId (void) const

{

  return (m_overrideDurationId != Seconds (0))?true:false;

}

Time

MacLowTransmissionParameters::GetDurationId (void) const

{

  assert (m_overrideDurationId != Seconds (0));

  return m_overrideDurationId;

}

bool 

MacLowTransmissionParameters::HasNextPacket (void) const

{

  return (m_nextSize != 0)?true:false;

}

uint32_t 

MacLowTransmissionParameters::GetNextPacketSize (void) const

{

  assert (HasNextPacket ());

  return m_nextSize;

}

MacLow::MacLow ()

  : m_normalAckTimeoutEvent (),

    m_fastAckTimeoutEvent (),

    m_superFastAckTimeoutEvent (),

    m_fastAckFailedTimeoutEvent (),

    m_ctsTimeoutEvent (),

    m_sendCtsEvent (),

    m_sendAckEvent (),

    m_sendDataEvent (),

    m_waitSifsEvent (),

    m_hasCurrent (false)

{

  m_lastNavDuration = Seconds (0);

  m_lastNavStart = Seconds (0);

}

MacLow::~MacLow ()

{

  CancelAllEvents ();

}

void

MacLow::CancelAllEvents (void)

{

  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_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 (oneRunning && m_listener != 0) 

    {

      m_listener->Cancel ();

    }

}

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

 *  API methods below.

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

void

MacLow::SetInterface (Ptr<WifiNetDevice> interface)

{

  m_interface = interface;

}

void

MacLow::SetPhy (WifiPhy *phy)

{

  m_phy = phy;

}

void 

MacLow::SetParameters (MacParameters *parameters)

{

  m_parameters = parameters;

}

void 

MacLow::SetStations (MacStations *stations)

{

  m_stations = stations;

}

void 

MacLow::SetRxCallback (MacLowRxCallback callback)

{

  m_rxCallback = callback;

}

void 

MacLow::RegisterNavListener (MacLowNavListener *listener)

{

  m_navListeners.push_back (listener);

}

void 

MacLow::StartTransmission (Packet packet, 

                           WifiMacHeader const*hdr, 

                           MacLowTransmissionParameters parameters,

                           MacLowTransmissionListener *listener)

{

  /* m_currentPacket is not NULL because someone started

   * a transmission and was interrupted before one of:

   *   - ctsTimeout

   *   - sendDataAfterCTS

   * expired. This means that one of these timers is still

   * running. They are all cancelled below anyway by the 

   * call to CancelAllEvents (because of at least one

   * of these two timer) which will trigger a call to the

   * previous listener's cancel method.

   *

   * This typically happens because the high-priority 

   * QapScheduler has taken access to the channel from

   * one of the Edca of the QAP.

   */

  if (m_hasCurrent) 

    {

      m_hasCurrent = false;

    }

  m_currentPacket = packet;

  m_currentHdr = *hdr;

  CancelAllEvents ();

  m_listener = listener;

  m_txParams = parameters;

  //assert (m_phy->IsStateIdle ());

  TRACE ("startTx size="<< GetCurrentSize () << ", to=" << m_currentHdr.GetAddr1());

  if (m_txParams.MustSendRts ()) 

    {

      SendRtsForPacket ();

    } 

  else 

    {

      SendDataPacket ();

    }

  /* When this method completes, we have taken ownership of the medium. */

  assert (m_phy->IsStateTx ());  

}

void

MacLow::ReceiveError (Packet const packet, double rxSnr)

{

  TRACE ("rx failed ");

  m_dropError (packet);

  if (m_txParams.MustWaitFastAck ()) 

    {

      assert (m_fastAckFailedTimeoutEvent.IsExpired ());

      m_fastAckFailedTimeoutEvent = Simulator::Schedule (GetSifs (), 

                                                         &MacLow::FastAckFailedTimeout, this);

    }

  return;

}

void 

MacLow::ReceiveOk (Packet const packet, double rxSnr, WifiMode txMode, WifiMode headerMode)

{

  /* A packet is received from the PHY.

   * When we have handled this packet,

   * we handle any packet present in the

   * packet queue.

   */

  WifiMacHeader hdr;

  Packet p = packet;

  p.RemoveHeader (hdr);

  bool isPrevNavZero = IsNavZero (Simulator::Now ());

  TRACE ("duration/id=" << hdr.GetDuration ());

  NotifyNav (Simulator::Now (), &hdr);

  if (hdr.IsRts ()) 

    {

      /* XXX see section 9.9.2.2.1 802.11e/D12.1 */

      if (isPrevNavZero &&

          hdr.GetAddr1 () == m_interface->GetSelfAddress ()) 

        {

          TRACE ("rx RTS from=" << hdr.GetAddr2 () << ", schedule CTS");

          assert (m_sendCtsEvent.IsExpired ());

          MacStation *station = m_stations->Lookup (hdr.GetAddr2 ());

          station->ReportRxOk (rxSnr, txMode);

          m_sendCtsEvent = Simulator::Schedule (GetSifs (),

                                                &MacLow::SendCtsAfterRts, this,

                                                hdr.GetAddr2 (), 

                                                //MicroSeconds (hdr.GetDurationUs ()),

                                                //Time (),

                                                Seconds (0),

                                                GetCtsTxModeForRts (hdr.GetAddr2 (), txMode),

                                                rxSnr);

        } 

      else 

        {

          TRACE ("rx RTS from=" << hdr.GetAddr2 () << ", cannot schedule CTS");

        }

    } 

  else if (hdr.IsCts () &&

           hdr.GetAddr1 () == m_interface->GetSelfAddress () &&

           m_ctsTimeoutEvent.IsRunning () &&

           m_hasCurrent) 

    {

      TRACE ("receive cts from="<<m_currentHdr.GetAddr1 ());

      SnrTag tag;

      packet.PeekTag (tag);

      MacStation *station = GetStation (m_currentHdr.GetAddr1 ());

      station->ReportRxOk (rxSnr, txMode);

      station->ReportRtsOk (rxSnr, txMode, tag.Get ());

      m_ctsTimeoutEvent.Cancel ();

      m_listener->GotCts (rxSnr, txMode);

      assert (m_sendDataEvent.IsExpired ());

      m_sendDataEvent = Simulator::Schedule (GetSifs (), 

                                             &MacLow::SendDataAfterCts, this, 

                                             hdr.GetAddr1 (),

                                             MicroSeconds (hdr.GetDurationUs ()),

                                             txMode);

    } 

  else if (hdr.IsAck () &&

           hdr.GetAddr1 () == m_interface->GetSelfAddress () &&

           (m_normalAckTimeoutEvent.IsRunning () || 

            m_fastAckTimeoutEvent.IsRunning () ||

            m_superFastAckTimeoutEvent.IsRunning ()) &&

           m_txParams.MustWaitAck ()) 

    {

      TRACE ("receive ack from="<<m_currentHdr.GetAddr1 ());

      SnrTag tag;

      packet.PeekTag (tag);

      MacStation *station = GetStation (m_currentHdr.GetAddr1 ());

      station->ReportRxOk (rxSnr, txMode);

      station->ReportDataOk (rxSnr, txMode, tag.Get ());

      bool gotAck = false;

      if (m_txParams.MustWaitNormalAck () &&

          m_normalAckTimeoutEvent.IsRunning ()) 

        {

          m_normalAckTimeoutEvent.Cancel ();

          gotAck = true;

        }

      if (m_txParams.MustWaitFastAck () &&

          m_fastAckTimeoutEvent.IsRunning ()) 

        {

          m_fastAckTimeoutEvent.Cancel ();

          gotAck = true;

        }

      if (gotAck) 

        {

          m_listener->GotAck (rxSnr, txMode);

        }

    if (m_txParams.HasNextPacket ()) 

      {

        m_waitSifsEvent = Simulator::Schedule (GetSifs (), 

                                               &MacLow::WaitSifsAfterEndTx, this);

      }

    } 

  else if (hdr.IsCtl ()) 

    {

      TRACE ("rx drop " << hdr.GetTypeString ());

    } 

  else if (hdr.GetAddr1 () == m_interface->GetSelfAddress ()) 

    {

      MacStation *station = GetStation (hdr.GetAddr2 ());

      station->ReportRxOk (rxSnr, txMode);

      if (hdr.IsQosData () && hdr.IsQosNoAck ()) 

        {

          TRACE ("rx unicast/noAck from="<<hdr.GetAddr2 ());

        } 

      else if (hdr.IsData () || hdr.IsMgt ()) 

        {

          TRACE ("rx unicast/sendAck from=" << hdr.GetAddr2 ());

          assert (m_sendAckEvent.IsExpired ());

          m_sendAckEvent = Simulator::Schedule (GetSifs (),

                                                &MacLow::SendAckAfterData, this,

                                                hdr.GetAddr2 (), 

                                                MicroSeconds (hdr.GetDurationUs ()),

                                                GetAckTxModeForData (hdr.GetAddr2 (), txMode),

                                                rxSnr);

        }

      goto rxPacket;

    } 

  else if (hdr.GetAddr1 ().IsBroadcast ()) 

    {

      if (hdr.IsData () || hdr.IsMgt ()) 

        {

          TRACE ("rx broadcast from=" << hdr.GetAddr2 ());

          goto rxPacket;

        }