/* -*- 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 <cmath>

#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-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>

#include <ns3/config.h>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("LteSpectrumPhy");

// 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);

static const double EffectiveCodingRate[29] = {

  0.08,

  0.1,

  0.11,

  0.15,

  0.19,

  0.24,

  0.3,

  0.37,

  0.44,

  0.51,

  0.3,

  0.33,

  0.37,

  0.42,

  0.48,

  0.54,

  0.6,

  0.43,

  0.45,

  0.5,

  0.55,

  0.6,

  0.65,

  0.7,

  0.75,

  0.8,

  0.85,

  0.89,

  0.92

};

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_cellId (0),

  m_transmissionMode (0),

  m_layersNum (1)

{

  NS_LOG_FUNCTION (this);

  m_random = CreateObject<UniformRandomVariable> ();

  m_random->SetAttribute ("Min", DoubleValue (0.0));

  m_random->SetAttribute ("Max", DoubleValue (1.0));

  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_ltePhyRxDataEndErrorCallback = MakeNullCallback< void > ();

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

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

  m_ltePhyRxCtrlEndErrorCallback = MakeNullCallback< void > ();

  m_ltePhyDlHarqFeedbackCallback = MakeNullCallback< void, DlInfoListElement_s > ();

  m_ltePhyUlHarqFeedbackCallback = MakeNullCallback< void, UlInfoListElement_s > ();

  m_ltePhyRxPssCallback = MakeNullCallback< void, uint16_t, Ptr<SpectrumValue> > ();

  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_DL_CTRL:

      os << "RX_DL_CTRL";

      break;

    case LteSpectrumPhy::TX_DATA:

      os << "TX_DATA";

      break;

    case LteSpectrumPhy::TX_DL_CTRL:

      os << "TX_DL_CTRL";

      break;

    case LteSpectrumPhy::TX_UL_SRS:

      os << "TX_UL_SRS";

      break;

    default:

      os << "UNKNOWN";

      break;

    }

  return os;

}

TypeId

LteSpectrumPhy::GetTypeId (void)

{

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

    .SetParent<SpectrumPhy> ()

    .SetGroupName("Lte")

    .AddTraceSource ("TxStart",

                     "Trace fired when a new transmission is started",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyTxStartTrace),

                     "ns3::PacketBurst::TracedCallback")

    .AddTraceSource ("TxEnd",

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

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyTxEndTrace),

                     "ns3::PacketBurst::TracedCallback")

    .AddTraceSource ("RxStart",

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

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxStartTrace),

                     "ns3::PacketBurst::TracedCallback")

    .AddTraceSource ("RxEndOk",

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

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxEndOkTrace),

                     "ns3::Packet::TracedCallback")

    .AddTraceSource ("RxEndError",

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

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_phyRxEndErrorTrace),

                     "ns3::Packet::TracedCallback")

    .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 ())

    .AddTraceSource ("DlPhyReception",

                     "DL reception PHY layer statistics.",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_dlPhyReception),

                     "ns3::PhyReceptionStatParameters::TracedCallback")

    .AddTraceSource ("UlPhyReception",

                     "DL reception PHY layer statistics.",

                     MakeTraceSourceAccessor (&LteSpectrumPhy::m_ulPhyReception),

                     "ns3::PhyReceptionStatParameters::TracedCallback")

  ;

  return tid;

}

Ptr<NetDevice>

LteSpectrumPhy::GetDevice () const

{

  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<SpectrumChannel> 

LteSpectrumPhy::GetChannel ()

{

  return m_channel;

}

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::Reset ()

{

  NS_LOG_FUNCTION (this);

  m_cellId = 0;

  m_state = IDLE;

  m_transmissionMode = 0;

  m_layersNum = 1;

  m_endTxEvent.Cancel ();

  m_endRxDataEvent.Cancel ();

  m_endRxDlCtrlEvent.Cancel ();

  m_endRxUlSrsEvent.Cancel ();

  m_rxControlMessageList.clear ();

  m_expectedTbs.clear ();

  m_txControlMessageList.clear ();

  m_rxPacketBurstList.clear ();

  m_txPacketBurst = 0;

  m_rxSpectrumModel = 0;

}

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;

}

void

LteSpectrumPhy::SetLtePhyRxPssCallback (LtePhyRxPssCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyRxPssCallback = c;

}

void

LteSpectrumPhy::SetLtePhyDlHarqFeedbackCallback (LtePhyDlHarqFeedbackCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyDlHarqFeedbackCallback = c;

}

void

LteSpectrumPhy::SetLtePhyUlHarqFeedbackCallback (LtePhyUlHarqFeedbackCallback c)

{

  NS_LOG_FUNCTION (this);

  m_ltePhyUlHarqFeedbackCallback = 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;

}

void

LteSpectrumPhy::SetHarqPhyModule (Ptr<LteHarqPhy> harq)

{

  m_harqPhyModule = harq;

}

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_DL_CTRL:

    case RX_UL_SRS:

      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_DATA:

    case TX_DL_CTRL:      

    case TX_UL_SRS:

      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_DATA);

      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);

      m_endTxEvent = Simulator::Schedule (duration, &LteSpectrumPhy::EndTxData, this);

    }

    return false;

    break;

    default:

      NS_FATAL_ERROR ("unknown state");

      return true;

      break;

  }

}

bool

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

{

  NS_LOG_FUNCTION (this << " PSS " << (uint16_t)pss);

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

  switch (m_state)

  {

    case RX_DATA:

    case RX_DL_CTRL:

    case RX_UL_SRS:

      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_DATA: