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

/*

 * Copyright (c) 2005,2006 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 "interference-helper.h"

#include "wifi-phy.h"

#include "error-rate-model.h"

#include "ns3/simulator.h"

#include "ns3/log.h"

#include <algorithm>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("InterferenceHelper");

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

 *       Phy event class

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

InterferenceHelper::Event::Event (uint32_t size, WifiMode payloadMode,

                                  enum WifiPreamble preamble,

                                  Time duration, double rxPower, WifiTxVector txVector)

  : m_size (size),

    m_payloadMode (payloadMode),

    m_preamble (preamble),

    m_startTime (Simulator::Now ()),

    m_endTime (m_startTime + duration),

    m_rxPowerW (rxPower),

    m_txVector (txVector)

{

}

InterferenceHelper::Event::~Event ()

{

}

Time

InterferenceHelper::Event::GetDuration (void) const

{

  return m_endTime - m_startTime;

}

Time

InterferenceHelper::Event::GetStartTime (void) const

{

  return m_startTime;

}

Time

InterferenceHelper::Event::GetEndTime (void) const

{

  return m_endTime;

}

double

InterferenceHelper::Event::GetRxPowerW (void) const

{

  return m_rxPowerW;

}

uint32_t

InterferenceHelper::Event::GetSize (void) const

{

  return m_size;

}

WifiMode

InterferenceHelper::Event::GetPayloadMode (void) const

{

  return m_payloadMode;

}

enum WifiPreamble

InterferenceHelper::Event::GetPreambleType (void) const

{

  return m_preamble;

}

WifiTxVector

InterferenceHelper::Event::GetTxVector (void) const

{

  return m_txVector;

}

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

 *       Class which records SNIR change events for a

 *       short period of time.

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

InterferenceHelper::NiChange::NiChange (Time time, double delta)

  : m_time (time),

    m_delta (delta)

{

}

Time

InterferenceHelper::NiChange::GetTime (void) const

{

  return m_time;

}

double

InterferenceHelper::NiChange::GetDelta (void) const

{

  return m_delta;

}

bool

InterferenceHelper::NiChange::operator < (const InterferenceHelper::NiChange& o) const

{

  return (m_time < o.m_time);

}

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

 *       The actual InterferenceHelper

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

InterferenceHelper::InterferenceHelper ()

  : m_errorRateModel (0),

    m_firstPower (0.0),

    m_rxing (false)

{

}

InterferenceHelper::~InterferenceHelper ()

{

  EraseEvents ();

  m_errorRateModel = 0;

}

Ptr<InterferenceHelper::Event>

InterferenceHelper::Add (uint32_t size, WifiMode payloadMode,

                         enum WifiPreamble preamble,

                         Time duration, double rxPowerW, WifiTxVector txVector)

{

  Ptr<InterferenceHelper::Event> event;

  event = Create<InterferenceHelper::Event> (size,

                                             payloadMode,

                                             preamble,

                                             duration,

                                             rxPowerW,

                                             txVector);

  AppendEvent (event);

  return event;

}

void

InterferenceHelper::SetNoiseFigure (double value)

{

  m_noiseFigure = value;

}

double

InterferenceHelper::GetNoiseFigure (void) const

{

  return m_noiseFigure;

}

void

InterferenceHelper::SetErrorRateModel (Ptr<ErrorRateModel> rate)

{

  m_errorRateModel = rate;

}

Ptr<ErrorRateModel>

InterferenceHelper::GetErrorRateModel (void) const

{

  return m_errorRateModel;

}

Time

InterferenceHelper::GetEnergyDuration (double energyW)

{

  Time now = Simulator::Now ();

  double noiseInterferenceW = 0.0;

  Time end = now;

  noiseInterferenceW = m_firstPower;

  for (NiChanges::const_iterator i = m_niChanges.begin (); i != m_niChanges.end (); i++)

    {

      noiseInterferenceW += i->GetDelta ();

      end = i->GetTime ();

      if (end < now)

        {

          continue;

        }

      if (noiseInterferenceW < energyW)

        {

          break;

        }

    }

  return end > now ? end - now : MicroSeconds (0);

}

void

InterferenceHelper::AppendEvent (Ptr<InterferenceHelper::Event> event)

{

  Time now = Simulator::Now ();

  if (!m_rxing)

    {

      NiChanges::iterator nowIterator = GetPosition (now);

      for (NiChanges::iterator i = m_niChanges.begin (); i != nowIterator; i++)

        {

          m_firstPower += i->GetDelta ();

        }

      m_niChanges.erase (m_niChanges.begin (), nowIterator);

      m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW ()));

    }

  else

    {

      AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ()));

    }

  AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW ()));

}

double

InterferenceHelper::CalculateSnr (double signal, double noiseInterference, WifiMode mode) const

{

  // thermal noise at 290K in J/s = W

  static const double BOLTZMANN = 1.3803e-23;

  // Nt is the power of thermal noise in W

  double Nt = BOLTZMANN * 290.0 * mode.GetBandwidth ();

  // receiver noise Floor (W) which accounts for thermal noise and non-idealities of the receiver

  double noiseFloor = m_noiseFigure * Nt;

  double noise = noiseFloor + noiseInterference;

  double snr = signal / noise;

  return snr;

}

double

InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const

{

  double noiseInterference = m_firstPower;

  NS_ASSERT (m_rxing);

  for (NiChanges::const_iterator i = m_niChanges.begin () + 1; i != m_niChanges.end (); i++)

    {

      if ((event->GetEndTime () == i->GetTime ()) && event->GetRxPowerW () == -i->GetDelta ())

        {

          break;

        }

      ni->push_back (*i);

    }

  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference));

  ni->push_back (NiChange (event->GetEndTime (), 0));

  return noiseInterference;

}

double

InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode) const

{

  if (duration == NanoSeconds (0))

    {

      return 1.0;

    }

  uint32_t rate = mode.GetPhyRate ();

  uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());

  double csr = m_errorRateModel->GetChunkSuccessRate (mode, snir, (uint32_t)nbits);

  return csr;

}

double

{

  double psr = 1.0; /* Packet Success Rate */

  NiChanges::iterator j = ni->begin ();

  Time previous = (*j).GetTime ();

  WifiMode payloadMode = event->GetPayloadMode ();

  WifiPreamble preamble = event->GetPreambleType ();

  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time+ preamble

  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble);//packet start time+ preamble+L SIG

  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble);//packet start time+ preamble+L SIG+HT SIG

  Time plcpPayloadStart =plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble,event->GetTxVector()); //packet start time+ preamble+L SIG+HT SIG+Training

  double noiseInterferenceW = (*j).GetDelta ();

  double powerW = event->GetRxPowerW ();

    j++;

  while (ni->end () != j)

    {

      Time current = (*j).GetTime ();

      NS_ASSERT (current >= previous);

      //Case 1: Both prev and curr point to the payload

      if (previous >= plcpPayloadStart)

        {

          psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                          noiseInterferenceW,

                                                          payloadMode),

                                            current - previous,

                                            payloadMode);

        }

      //Case 2: previous is before payload

      else if (previous >= plcpHtTrainingSymbolsStart)

        {

          //Case 2a: current is after payload

          if (current >= plcpPayloadStart)

            { 

               //Case 2ai and 2aii: All formats

               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                              noiseInterferenceW,

                                                              payloadMode),

                                                current - plcpPayloadStart,

        }

        {

             {

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

              }

          else if (current >=plcpHtTrainingSymbolsStart)

             {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                headerMode),

             }

         else

            {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                headerMode),

            }

      }

      else if (previous >= plcpHeaderStart)

        {

             {

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart)

                {

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                }

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                              noiseInterferenceW,

                                                              headerMode),

                                                      plcpHtTrainingSymbolsStart - plcpHsigHeaderStart,

                                                      headerMode);

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                    noiseInterferenceW,

                                                                    MfHeaderMode),

                                                      plcpHsigHeaderStart - previous,

                                                      MfHeaderMode);

                 }

              }

             {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                              noiseInterferenceW,

                                                              headerMode),

                                                  plcpHtTrainingSymbolsStart - plcpHsigHeaderStart,

                                                  headerMode);

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                MfHeaderMode),

                                                   plcpHsigHeaderStart - previous,

                                                   MfHeaderMode);

              }

             {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                headerMode),

                                                  current - plcpHsigHeaderStart,

                                                  headerMode);

                 psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                 noiseInterferenceW,

                                                                 MfHeaderMode),

                                                   plcpHsigHeaderStart - previous,

                                                   MfHeaderMode);

             }

         else 

            {

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart)

                {

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                }