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

/*

 *  Copyright (c) 2007,2008, 2009 INRIA, UDcast

 *

 * 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: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>

 *                              <amine.ismail@udcast.com>

 */

#include "ns3/simulator.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/uinteger.h"

#include "ns3/double.h"

#include "ns3/string.h"

#include "wimax-net-device.h"

#include "simple-ofdm-wimax-phy.h"

#include "wimax-channel.h"

#include "ns3/packet-burst.h"

#include "wimax-mac-header.h"

#include "simple-ofdm-wimax-channel.h"

#include "ns3/trace-source-accessor.h"

#include <string>

#include <cmath>

NS_LOG_COMPONENT_DEFINE ("SimpleOfdmWimaxPhy");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (SimpleOfdmWimaxPhy);

TypeId SimpleOfdmWimaxPhy::GetTypeId (void)

{

  static TypeId

    tid =

    TypeId ("ns3::SimpleOfdmWimaxPhy").SetParent<WimaxPhy> ()

    .AddAttribute ("NoiseFigure",

                   "Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver.",

                   DoubleValue (5),

                   MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetNoiseFigure, &SimpleOfdmWimaxPhy::GetNoiseFigure),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("TxPower",

                   "Transmission power (dB).",

                   DoubleValue (30),

                   MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetTxPower, &SimpleOfdmWimaxPhy::GetTxPower),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("G",

                   "This is the ratio of CP time to useful time.",

                   DoubleValue (0.25),

                   MakeDoubleAccessor (&SimpleOfdmWimaxPhy::DoSetGValue, &SimpleOfdmWimaxPhy::DoGetGValue),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("TxGain",

                   "Transmission gain (dB).",

                   DoubleValue (0),

                   MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetTxGain, &SimpleOfdmWimaxPhy::GetTxGain),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("RxGain",

                   "Reception gain (dB).",

                   DoubleValue (0),

                   MakeDoubleAccessor (&SimpleOfdmWimaxPhy::SetRxGain, &SimpleOfdmWimaxPhy::GetRxGain),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("Nfft",

                   "FFT size",

                   UintegerValue (256),

                   MakeUintegerAccessor (&SimpleOfdmWimaxPhy::DoSetNfft, &SimpleOfdmWimaxPhy::DoGetNfft),

                   MakeUintegerChecker<uint16_t> (256, 1024))

    .AddAttribute ("TraceFilePath",

                   "Path to the directory containing SNR to block error rate files",

                   StringValue (""),

                   MakeStringAccessor (&SimpleOfdmWimaxPhy::GetTraceFilePath,

                                       &SimpleOfdmWimaxPhy::SetTraceFilePath),

                   MakeStringChecker ())

    .AddTraceSource ("Rx", "Receive trace", MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_traceRx))

    .AddTraceSource ("Tx", "Transmit trace", MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_traceTx))

    .AddTraceSource ("PhyTxBegin",

                     "Trace source indicating a packet has begun transmitting over the channel medium",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxBeginTrace))

    .AddTraceSource ("PhyTxEnd",

                     "Trace source indicating a packet has been completely transmitted over the channel",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxEndTrace))

    .AddTraceSource ("PhyTxDrop",

                     "Trace source indicating a packet has been dropped by the device during transmission",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyTxDropTrace))

    .AddTraceSource ("PhyRxBegin",

                     "Trace source indicating a packet has begun being received from the channel medium by the device",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxBeginTrace))

    .AddTraceSource ("PhyRxEnd",

                     "Trace source indicating a packet has been completely received from the channel medium by the device",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxEndTrace))

    .AddTraceSource ("PhyRxDrop",

                     "Trace source indicating a packet has been dropped by the device during reception",

                     MakeTraceSourceAccessor (&SimpleOfdmWimaxPhy::m_phyRxDropTrace));

  return tid;

}

void

SimpleOfdmWimaxPhy::InitSimpleOfdmWimaxPhy (void)

{

  m_fecBlockSize = 0;

  m_nrFecBlocksSent = 0;

  m_dataRateBpsk12 = 0;

  m_dataRateQpsk12 = 0;

  m_dataRateQpsk34 = 0;

  m_dataRateQam16_12 = 0;

  m_dataRateQam16_34 = 0;

  m_dataRateQam64_23 = 0;

  m_dataRateQam64_34 = 0;

  m_nrBlocks = 0;

  m_blockSize = 0;

  m_paddingBits = 0;

  m_rxGain = 0;

  m_txGain = 0;

  m_nfft = 256;

  m_g = (double) 1 / 4;

  SetNrCarriers (192);

  m_fecBlocks = new std::list<bvec>;

  m_receivedFecBlocks = new std::list<bvec>;

  m_currentBurstSize = 0;

  m_noiseFigure = 5; // dB

  m_txPower = 30; // dBm

  SetBandwidth (10000000); // 10Mhz

  m_nbErroneousBlock = 0;

  m_nrRecivedFecBlocks = 0;

  m_snrToBlockErrorRateManager = new SNRToBlockErrorRateManager ();

}

SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy (void)

{

  m_URNG = CreateObject<UniformRandomVariable> ();

  InitSimpleOfdmWimaxPhy ();

  m_snrToBlockErrorRateManager->SetTraceFilePath ((char*) "");

  m_snrToBlockErrorRateManager->LoadTraces ();

}

SimpleOfdmWimaxPhy::SimpleOfdmWimaxPhy (char * tracesPath)

{

  InitSimpleOfdmWimaxPhy ();

  m_snrToBlockErrorRateManager->SetTraceFilePath (tracesPath);

  m_snrToBlockErrorRateManager->LoadTraces ();

}

SimpleOfdmWimaxPhy::~SimpleOfdmWimaxPhy (void)

{

}

void

SimpleOfdmWimaxPhy::ActivateLoss (bool loss)

{

  m_snrToBlockErrorRateManager->ActivateLoss (loss);

}

void

SimpleOfdmWimaxPhy::SetSNRToBlockErrorRateTracesPath (char * tracesPath)

{

  m_snrToBlockErrorRateManager->SetTraceFilePath (tracesPath);

  m_snrToBlockErrorRateManager->ReLoadTraces ();

}

uint32_t

SimpleOfdmWimaxPhy::GetBandwidth (void) const

{

  return WimaxPhy::GetChannelBandwidth ();

}

void

SimpleOfdmWimaxPhy::SetBandwidth (uint32_t BW)

{

  WimaxPhy::SetChannelBandwidth (BW);

}

double

SimpleOfdmWimaxPhy::GetTxPower (void) const

{

  return m_txPower;

}

void

SimpleOfdmWimaxPhy::SetTxPower (double txPower)

{

  m_txPower = txPower;

}

double

SimpleOfdmWimaxPhy::GetNoiseFigure (void) const

{

  return m_noiseFigure;

}

void

SimpleOfdmWimaxPhy::SetNoiseFigure (double noiseFigure)

{

  m_noiseFigure = noiseFigure;

}

void

SimpleOfdmWimaxPhy::DoDispose (void)

{

  delete m_receivedFecBlocks;

  delete m_fecBlocks;

  m_receivedFecBlocks = 0;

  m_fecBlocks = 0;

  delete m_snrToBlockErrorRateManager;

  WimaxPhy::DoDispose ();

}

void

SimpleOfdmWimaxPhy::DoAttach (Ptr<WimaxChannel> channel)

{

  GetChannel ()->Attach (this);

}

void

SimpleOfdmWimaxPhy::Send (SendParams *params)

{

  OfdmSendParams *o_params = dynamic_cast<OfdmSendParams*> (params);

  Send (o_params->GetBurst (),

        (WimaxPhy::ModulationType) o_params->GetModulationType (),

        o_params->GetDirection ());

}

WimaxPhy::PhyType

SimpleOfdmWimaxPhy::GetPhyType (void) const

{

  return WimaxPhy::simpleOfdmWimaxPhy;

}

void

SimpleOfdmWimaxPhy::Send (Ptr<PacketBurst> burst,

                          WimaxPhy::ModulationType modulationType,

                          uint8_t direction)

{

  if (GetState () != PHY_STATE_TX)

    {

      m_currentBurstSize = burst->GetSize ();

      m_nrFecBlocksSent = 0;

      m_currentBurst = burst;

      SetBlockParameters (burst->GetSize (), modulationType);

      NotifyTxBegin (m_currentBurst);

      StartSendDummyFecBlock (true, modulationType, direction);

      m_traceTx (burst);

    }

}

void

SimpleOfdmWimaxPhy::StartSendDummyFecBlock (bool isFirstBlock,

                                            WimaxPhy::ModulationType modulationType,

                                            uint8_t direction)

{

  SetState (PHY_STATE_TX);

  bool isLastFecBlock = 0;

  if (isFirstBlock)

    {

      m_blockTime = GetBlockTransmissionTime (modulationType);

    }

  SimpleOfdmWimaxChannel *channel = dynamic_cast<SimpleOfdmWimaxChannel*> (PeekPointer (GetChannel ()));

  if (m_nrRemainingBlocksToSend==1)

    {

      isLastFecBlock = true;

    }

  else

    {

      isLastFecBlock = false;

    }

  channel->Send (m_blockTime,

                 m_currentBurstSize,

                 this,

                 isFirstBlock,

                 isLastFecBlock,

                 GetTxFrequency (),

                 modulationType,

                 direction,

                 m_txPower,

                 m_currentBurst);

  m_nrRemainingBlocksToSend--;

  Simulator::Schedule (m_blockTime, &SimpleOfdmWimaxPhy::EndSendFecBlock, this, modulationType, direction);

}

void

SimpleOfdmWimaxPhy::EndSendFecBlock (WimaxPhy::ModulationType modulationType,

                                     uint8_t direction)

{

  m_nrFecBlocksSent++;

  SetState (PHY_STATE_IDLE);

  if (m_nrFecBlocksSent * m_blockSize == m_currentBurstSize * 8 + m_paddingBits)

    {

      // this is the last FEC block of the burst

      NS_ASSERT_MSG (m_nrRemainingBlocksToSend == 0, "Error while sending a burst");

      NotifyTxEnd (m_currentBurst);

    }

  else

    {

      StartSendDummyFecBlock (false,modulationType,direction);

    }

}

void

SimpleOfdmWimaxPhy::EndSend (void)

{

  SetState (PHY_STATE_IDLE);

}

void

SimpleOfdmWimaxPhy::StartReceive (uint32_t burstSize,

                                  bool isFirstBlock,

                                  uint64_t frequency,

                                  WimaxPhy::ModulationType modulationType,

                                  uint8_t direction,

                                  double rxPower,

                                  Ptr<PacketBurst> burst)

{

  uint8_t drop = 0;

  double Nwb = -114 + m_noiseFigure + 10 * std::log (GetBandwidth () / 1000000000.0) / 2.303;

  double SNR = rxPower - Nwb;

  SNRToBlockErrorRateRecord * record = m_snrToBlockErrorRateManager->GetSNRToBlockErrorRateRecord (SNR, modulationType);

  double I1 = record->GetI1 ();

  double I2 = record->GetI2 ();

  double blockErrorRate = m_URNG->GetValue (I1, I2);

  double rand = m_URNG->GetValue (0.0, 1.0);

  if (rand < blockErrorRate)

    {

      drop = 1;

    }

  if (rand > blockErrorRate)

    {

      drop = 0;

    }

  if (blockErrorRate == 1.0)

    {

      drop = 1;

    }

  if (blockErrorRate == 0.0)

    {

      drop = 0;

    }

  delete record;

  NS_LOG_INFO ("PHY: Receive rxPower=" << rxPower << ", Nwb=" << Nwb << ", SNR=" << SNR << ", Modulation="

                                       << modulationType << ", BlocErrorRate=" << blockErrorRate << ", drop=" << (int) drop);

  switch (GetState ())

    {

    case PHY_STATE_SCANNING:

      if (frequency == GetScanningFrequency ())

        {

          Simulator::Cancel (GetChnlSrchTimeoutEvent ());

          SetScanningCallback ();

          SetSimplex (frequency);

          SetState (PHY_STATE_IDLE);

        }

      break;

    case PHY_STATE_IDLE:

      if (frequency == GetRxFrequency ())

        {

          if (isFirstBlock)

            {

              NotifyRxBegin (burst);

              m_receivedFecBlocks->clear ();

              m_nrRecivedFecBlocks=0;

              SetBlockParameters (burstSize, modulationType);

              m_blockTime = GetBlockTransmissionTime (modulationType);

            }

          Simulator::Schedule (m_blockTime,

                               &SimpleOfdmWimaxPhy::EndReceiveFecBlock,

                               this,

                               burstSize,

                               modulationType,

                               direction,

                               drop,

                               burst);

          SetState (PHY_STATE_RX);

        }

      break;

    case PHY_STATE_RX:

      // drop

      break;

    case PHY_STATE_TX:

      if (IsDuplex () && frequency == GetRxFrequency ())

        {

        }

      break;

    }

}

void

SimpleOfdmWimaxPhy::EndReceiveFecBlock (uint32_t burstSize,

                                        WimaxPhy::ModulationType modulationType,

                                        uint8_t direction,

                                        uint8_t drop,

                                        Ptr<PacketBurst> burst)

{

  SetState (PHY_STATE_IDLE);

  m_nrRecivedFecBlocks++;

  if (drop == true)

    {

      m_nbErroneousBlock++;

    }

  if ((uint32_t) m_nrRecivedFecBlocks * m_blockSize == burstSize * 8 + m_paddingBits)

    {

      NotifyRxEnd (burst);

      if (m_nbErroneousBlock == 0)

        {

          Simulator::Schedule (Seconds (0),

                               &SimpleOfdmWimaxPhy::EndReceive,

                               this,

                               burst);

        }

      else

        {

          NotifyRxDrop (burst);

        }

      m_nbErroneousBlock = 0;

      m_nrRecivedFecBlocks = 0;

    }

}

void

SimpleOfdmWimaxPhy::EndReceive (Ptr<const PacketBurst> burst)

{

  Ptr<PacketBurst> b = burst->Copy ();

  GetReceiveCallback () (b);

  m_traceRx (burst);

}

bvec

SimpleOfdmWimaxPhy::ConvertBurstToBits (Ptr<const PacketBurst> burst)

{

  bvec buffer (burst->GetSize () * 8, 0);

  std::list<Ptr<Packet> > packets = burst->GetPackets ();

  uint32_t j = 0;

  for (std::list<Ptr<Packet> >::iterator iter = packets.begin (); iter != packets.end (); ++iter)

    {

      Ptr<Packet> packet = *iter;

      uint8_t *pstart = (uint8_t*) std::malloc (packet->GetSize ());

      std::memset (pstart, 0, packet->GetSize ());

      packet->CopyData (pstart, packet->GetSize ());

      bvec temp (8);

      temp.resize (0, 0);

      temp.resize (8, 0);

      for (uint32_t i = 0; i < packet->GetSize (); i++)

        {

          for (uint8_t l = 0; l < 8; l++)

            {

              temp[l] = (bool)((((uint8_t) pstart[i]) >> (7 - l)) & 0x01);

              buffer.at (j * 8 + l) = temp[l];

            }

          j++;

        }

      std::free (pstart);

    }

  return buffer;

}

/*

 Converts back the bit buffer (bvec) to the actual burst.

 Actually creates byte buffer from the bvec and resets the buffer

 of each packet in the copy of the orifinal burst stored before transmitting.

 By doing this it preserves the metadata and tags in the packet.

 Function could also be named DeserializeBurst because actually it

 copying to the burst's byte buffer.

 */

Ptr<PacketBurst>

SimpleOfdmWimaxPhy::ConvertBitsToBurst (bvec buffer)

{

  uint8_t init[buffer.size () / 8];

  uint8_t *pstart = init;

  uint8_t temp;

  int32_t j = 0;

  // recreating byte buffer from bit buffer (bvec)

  for (uint32_t i = 0; i < buffer.size (); i += 8)