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

/*

 * Copyright (c) 2009, 2011 CTTC

 *

 * 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: Nicola Baldo <nbaldo@cttc.es>

 *         Giuseppe Piro  <g.piro@poliba.it>

 *         Marco Miozzo <marco.miozzo@cttc.es> (add physical error model)

 */

#include <ns3/object-factory.h>

#include <ns3/log.h>

#include <math.h>

#include <ns3/simulator.h>

#include <ns3/trace-source-accessor.h>

#include <ns3/antenna-model.h>

#include "lte-spectrum-phy.h"

#include "lte-spectrum-signal-parameters.h"

#include "lte-net-device.h"

#include "lte-radio-bearer-tag.h"

#include "lte-sinr-chunk-processor.h"

#include "lte-phy-tag.h"

#include <ns3/lte-mi-error-model.h>

#include <ns3/lte-radio-bearer-tag.h>

#include <ns3/boolean.h>

#include <ns3/double.h>

NS_LOG_COMPONENT_DEFINE ("LteSpectrumPhy");

namespace ns3 {

// duration of SRS portion of UL subframe  

// = 1 symbol for SRS -1ns as margin to avoid overlapping simulator events

static const Time UL_SRS_DURATION = NanoSeconds (71429 -1);  

// duration of the control portion of a subframe

// = 0.001 / 14 * 3 (ctrl fixed to 3 symbols) -1ns as margin to avoid overlapping simulator events

static const Time DL_CTRL_DURATION = NanoSeconds (214286 -1);

TbId_t::TbId_t ()

{

}

TbId_t::TbId_t (const uint16_t a, const uint8_t b)

: m_rnti (a),

  m_layer (b)

{

}

bool

operator == (const TbId_t &a, const TbId_t &b)

{

  return ( (a.m_rnti == b.m_rnti) && (a.m_layer == b.m_layer) );

}

bool

operator < (const TbId_t& a, const TbId_t& b)

{

  return ( (a.m_rnti < b.m_rnti) || ( (a.m_rnti == b.m_rnti) && (a.m_layer < b.m_layer) ) );

}

NS_OBJECT_ENSURE_REGISTERED (LteSpectrumPhy);

LteSpectrumPhy::LteSpectrumPhy ()

  : m_state (IDLE),

  m_random (0.0, 1.0),

  m_transmissionMode (0)

{

  NS_LOG_FUNCTION (this);

  m_interferenceData = CreateObject<LteInterference> ();

  m_interferenceCtrl = CreateObject<LteInterference> ();

  for (uint8_t i = 0; i < 7; i++)

    {

      m_txModeGain.push_back (1.0);

    }

}

LteSpectrumPhy::~LteSpectrumPhy ()

{

  NS_LOG_FUNCTION (this);

  m_expectedTbs.clear ();

  m_txModeGain.clear ();

}

void LteSpectrumPhy::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  m_channel = 0;

  m_mobility = 0;

  m_device = 0;

  m_interferenceData->Dispose ();

  m_interferenceData = 0;

  m_interferenceCtrl->Dispose ();

  m_interferenceCtrl = 0;

  m_ltePhyTxEndCallback      = MakeNullCallback< void, Ptr<const Packet> > ();

  m_ltePhyRxDataEndErrorCallback = MakeNullCallback< void > ();

  m_ltePhyRxDataEndOkCallback    = MakeNullCallback< void, Ptr<Packet> >  ();

  m_ltePhyRxCtrlEndOkCallback = MakeNullCallback< void, std::list<Ptr<LteControlMessage> > > ();

  m_ltePhyRxCtrlEndErrorCallback = MakeNullCallback< void > ();

  SpectrumPhy::DoDispose ();

} 

std::ostream& operator<< (std::ostream& os, LteSpectrumPhy::State s)

{

  switch (s)

    {

    case LteSpectrumPhy::IDLE:

      os << "IDLE";

      break;

    case LteSpectrumPhy::RX_DATA:

      os << "RX_DATA";

      break;

    case LteSpectrumPhy::RX_CTRL:

      os << "RX_CTRL";

      break;

    case LteSpectrumPhy::TX:

      os << "TX";

      break;

    default:

      os << "UNKNOWN";

      break;

    }

  return os;

}

TypeId

LteSpectrumPhy::GetTypeId (void)

{

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

    .SetParent<SpectrumPhy> ()

    .AddTraceSource ("TxStart",

                     "Trace fired when a new transmission is started",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyTxStartTrace))

    .AddTraceSource ("TxEnd",

                     "Trace fired when a previosuly started transmission is finished",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyTxEndTrace))

    .AddTraceSource ("RxStart",

                     "Trace fired when the start of a signal is detected",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxStartTrace))

    .AddTraceSource ("RxEndOk",

                     "Trace fired when a previosuly started RX terminates successfully",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxEndOkTrace))

    .AddTraceSource ("RxEndError",

                     "Trace fired when a previosuly started RX terminates with an error",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxEndErrorTrace))

    .AddAttribute ("DataErrorModelEnabled",

                    "Activate/Deactivate the error model of data (TBs of PDSCH and PUSCH) [by default is active].",

                    BooleanValue (true),

                   MakeBooleanAccessor (&LteSpectrumPhy::m_dataErrorModelEnabled),

                    MakeBooleanChecker ())

    .AddAttribute ("CtrlErrorModelEnabled",

                    "Activate/Deactivate the error model of control (PCFICH-PDCCH decodification) [by default is active].",

                    BooleanValue (true),

                    MakeBooleanAccessor (&LteSpectrumPhy::m_ctrlErrorModelEnabled),

                    MakeBooleanChecker ())

  ;

  return tid;

}

Ptr<NetDevice>

LteSpectrumPhy::GetDevice ()

{

  NS_LOG_FUNCTION (this);

  return m_device;

}

Ptr<MobilityModel>

LteSpectrumPhy::GetMobility ()

{

  NS_LOG_FUNCTION (this);

  return m_mobility;

}

void

LteSpectrumPhy::SetDevice (Ptr<NetDevice> d)

{

  NS_LOG_FUNCTION (this << d);

  m_device = d;

}

void

LteSpectrumPhy::SetMobility (Ptr<MobilityModel> m)

{

  NS_LOG_FUNCTION (this << m);

  m_mobility = m;

}

void

LteSpectrumPhy::SetChannel (Ptr<SpectrumChannel> c)

{

  NS_LOG_FUNCTION (this << c);

  m_channel = c;

}

Ptr<const SpectrumModel>

LteSpectrumPhy::GetRxSpectrumModel () const

{

  return m_rxSpectrumModel;

}

void

LteSpectrumPhy::SetTxPowerSpectralDensity (Ptr<SpectrumValue> txPsd)

{

  NS_LOG_FUNCTION (this << txPsd);

  NS_ASSERT (txPsd);

  m_txPsd = txPsd;

}

void

LteSpectrumPhy::SetNoisePowerSpectralDensity (Ptr<const SpectrumValue> noisePsd)

{

  NS_LOG_FUNCTION (this << noisePsd);

  NS_ASSERT (noisePsd);

  m_rxSpectrumModel = noisePsd->GetSpectrumModel ();

  m_interferenceData->SetNoisePowerSpectralDensity (noisePsd);

  m_interferenceCtrl->SetNoisePowerSpectralDensity (noisePsd);

}

void

LteSpectrumPhy::SetLtePhyTxEndCallback (LtePhyTxEndCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyTxEndCallback = c;

}

void

LteSpectrumPhy::SetLtePhyRxDataEndErrorCallback (LtePhyRxDataEndErrorCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyRxDataEndErrorCallback = c;

}

void

LteSpectrumPhy::SetLtePhyRxDataEndOkCallback (LtePhyRxDataEndOkCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyRxDataEndOkCallback = c;

}

void

LteSpectrumPhy::SetLtePhyRxCtrlEndOkCallback (LtePhyRxCtrlEndOkCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyRxCtrlEndOkCallback = c;

}

void

LteSpectrumPhy::SetLtePhyRxCtrlEndErrorCallback (LtePhyRxCtrlEndErrorCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyRxCtrlEndErrorCallback = c;

}

Ptr<AntennaModel>

LteSpectrumPhy::GetRxAntenna ()

{

  return m_antenna;

}

void

LteSpectrumPhy::SetAntenna (Ptr<AntennaModel> a)

{

  NS_LOG_FUNCTION (this << a);

  m_antenna = a;

}

void

LteSpectrumPhy::SetState (State newState)

{

  ChangeState (newState);

}

void

LteSpectrumPhy::ChangeState (State newState)

{

  NS_LOG_LOGIC (this << " state: " << m_state << " -> " << newState);

  m_state = newState;

}

bool

LteSpectrumPhy::StartTxDataFrame (Ptr<PacketBurst> pb, std::list<Ptr<LteControlMessage> > ctrlMsgList, Time duration)

{

  NS_LOG_FUNCTION (this << pb);

  NS_LOG_LOGIC (this << " state: " << m_state);

  m_phyTxStartTrace (pb);

  switch (m_state)

  {

    case RX_DATA:

    case RX_CTRL:

      NS_FATAL_ERROR ("cannot TX while RX: according to FDD channel acces, the physical layer for transmission cannot be used for reception");

      break;

    case TX:

      NS_FATAL_ERROR ("cannot TX while already TX: the MAC should avoid this");

      break;

    case IDLE:

    {

      /*

      m_txPsd must be setted by the device, according to

      (i) the available subchannel for transmission

      (ii) the power transmission

      */

      NS_ASSERT (m_txPsd);

      m_txPacketBurst = pb;

      // we need to convey some PHY meta information to the receiver

      // to be used for simulation purposes (e.g., the CellId). This

      // is done by setting the ctrlMsgList parameter of

      // LteSpectrumSignalParametersDataFrame

      ChangeState (TX);

      NS_ASSERT (m_channel);

      Ptr<LteSpectrumSignalParametersDataFrame> txParams = Create<LteSpectrumSignalParametersDataFrame> ();

      txParams->duration = duration;

      txParams->txPhy = GetObject<SpectrumPhy> ();

      txParams->txAntenna = m_antenna;

      txParams->psd = m_txPsd;

      txParams->packetBurst = pb;

      txParams->ctrlMsgList = ctrlMsgList;

      txParams->cellId = m_cellId;

      m_channel->StartTx (txParams);

      Simulator::Schedule (duration, &LteSpectrumPhy::EndTx, this);

    }

    return false;

    break;

    default:

      NS_FATAL_ERROR ("unknown state");

      return true;

      break;

  }

}

bool

LteSpectrumPhy::StartTxDlCtrlFrame (std::list<Ptr<LteControlMessage> > ctrlMsgList)

{

  NS_LOG_FUNCTION (this << time);

  NS_LOG_LOGIC (this << " state: " << m_state);

//   m_phyTxStartTrace (pb);

  switch (m_state)

  {

    case RX_DATA:

    case RX_CTRL:

      NS_FATAL_ERROR ("cannot TX while RX: according to FDD channel acces, the physical layer for transmission cannot be used for reception");

      break;

    case TX:

      NS_FATAL_ERROR ("cannot TX while already TX: the MAC should avoid this");

      break;

    case IDLE:

    {

      /*

      m_txPsd must be setted by the device, according to

      (i) the available subchannel for transmission

      (ii) the power transmission

      */

      NS_ASSERT (m_txPsd);

      // we need to convey some PHY meta information to the receiver

      // to be used for simulation purposes (e.g., the CellId). This

      // is done by setting the cellId parameter of

      // LteSpectrumSignalParametersDlCtrlFrame

      ChangeState (TX);

      NS_ASSERT (m_channel);

      Ptr<LteSpectrumSignalParametersDlCtrlFrame> txParams = Create<LteSpectrumSignalParametersDlCtrlFrame> ();

      txParams->duration = DL_CTRL_DURATION;

      txParams->txPhy = GetObject<SpectrumPhy> ();

      txParams->txAntenna = m_antenna;

      txParams->psd = m_txPsd;

      txParams->cellId = m_cellId;

      txParams->ctrlMsgList = ctrlMsgList;

      m_channel->StartTx (txParams);

      Simulator::Schedule (DL_CTRL_DURATION, &LteSpectrumPhy::EndTx, this);

    }

    return false;

    break;

    default:

      NS_FATAL_ERROR ("unknown state");

      return true;

      break;

  }

}

bool

LteSpectrumPhy::StartTxUlSrsFrame ()

{

  NS_LOG_FUNCTION (this << time);

  NS_LOG_LOGIC (this << " state: " << m_state);

  //   m_phyTxStartTrace (pb);

  switch (m_state)

  {

    case RX_DATA:

    case RX_CTRL:

      NS_FATAL_ERROR ("cannot TX while RX: according to FDD channel acces, the physical layer for transmission cannot be used for reception");

      break;

    case TX:

      NS_FATAL_ERROR ("cannot TX while already TX: the MAC should avoid this");

      break;

    case IDLE:

    {

      /*

      m_txPsd must be setted by the device, according to

      (i) the available subchannel for transmission

      (ii) the power transmission

      */

      NS_ASSERT (m_txPsd);

      // we need to convey some PHY meta information to the receiver

      // to be used for simulation purposes (e.g., the CellId). This

      // is done by setting the cellId parameter of 

      // LteSpectrumSignalParametersDlCtrlFrame

      ChangeState (TX);

      NS_ASSERT (m_channel);

      Ptr<LteSpectrumSignalParametersUlSrsFrame> txParams = Create<LteSpectrumSignalParametersUlSrsFrame> ();

      txParams->duration = UL_SRS_DURATION;

      txParams->txPhy = GetObject<SpectrumPhy> ();

      txParams->txAntenna = m_antenna;

      txParams->psd = m_txPsd;

      txParams->cellId = m_cellId;

      m_channel->StartTx (txParams);

      Simulator::Schedule (UL_SRS_DURATION, &LteSpectrumPhy::EndTx, this);

    }

    return false;

    break;

    default:

      NS_FATAL_ERROR ("unknown state");

      return true;

      break;

  }

}

void

LteSpectrumPhy::EndTx ()

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC (this << " state: " << m_state);

  NS_ASSERT (m_state == TX);

  m_phyTxEndTrace (m_txPacketBurst);

  if (!m_ltePhyTxEndCallback.IsNull ())