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

/*

 * Copyright (c) 2010 TELEMATICS LAB, DEE - Politecnico di Bari

 *

 * 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: Giuseppe Piro  <g.piro@poliba.it>

 *         Marco Miozzo <marco.miozzo@cttc.es>

 *         Nicola Baldo <nbaldo@cttc.es>

 */

#include <ns3/object-factory.h>

#include <ns3/log.h>

#include <cmath>

#include <ns3/simulator.h>

#include <ns3/double.h>

#include "lte-ue-phy.h"

#include "lte-enb-phy.h"

#include "lte-net-device.h"

#include "lte-ue-net-device.h"

#include "lte-enb-net-device.h"

#include "lte-spectrum-value-helper.h"

#include "lte-amc.h"

#include "lte-ue-mac.h"

#include "ff-mac-common.h"

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

#include <ns3/lte-common.h>

#include <ns3/pointer.h>

NS_LOG_COMPONENT_DEFINE ("LteUePhy");

namespace ns3 {

// duration of data portion of UL subframe

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

// (symbol duration in nanoseconds = TTI / 14 (rounded))

// in other words, duration of data portion of UL subframe = TTI*(13/14) -1ns

static const Time UL_DATA_DURATION = NanoSeconds (1e6 - 71429 - 1); 

// delay from subframe start to transmission of SRS 

// = TTI - 1 symbol for SRS 

static const Time UL_SRS_DELAY_FROM_SUBFRAME_START = NanoSeconds (1e6 - 71429); 

////////////////////////////////////////

// member SAP forwarders

////////////////////////////////////////

class UeMemberLteUePhySapProvider : public LteUePhySapProvider

{

public:

  UeMemberLteUePhySapProvider (LteUePhy* phy);

  // inherited from LtePhySapProvider

  virtual void SendMacPdu (Ptr<Packet> p);

  virtual void SendLteControlMessage (Ptr<LteControlMessage> msg);

  virtual void SendRachPreamble (uint32_t prachId, uint32_t raRnti);

private:

  LteUePhy* m_phy;

};

UeMemberLteUePhySapProvider::UeMemberLteUePhySapProvider (LteUePhy* phy) : m_phy (phy)

{

}

void

UeMemberLteUePhySapProvider::SendMacPdu (Ptr<Packet> p)

{

  m_phy->DoSendMacPdu (p);

}

void

UeMemberLteUePhySapProvider::SendLteControlMessage (Ptr<LteControlMessage> msg)

{

  m_phy->DoSendLteControlMessage (msg);

}

void

UeMemberLteUePhySapProvider::SendRachPreamble (uint32_t prachId, uint32_t raRnti)

{

  m_phy->DoSendRachPreamble (prachId, raRnti);

}

////////////////////////////////////////

// LteUePhy methods

////////////////////////////////////////

NS_OBJECT_ENSURE_REGISTERED (LteUePhy);

LteUePhy::LteUePhy ()

{

  NS_LOG_FUNCTION (this);

  NS_FATAL_ERROR ("This constructor should not be called");

}

LteUePhy::LteUePhy (Ptr<LteSpectrumPhy> dlPhy, Ptr<LteSpectrumPhy> ulPhy)

  : LtePhy (dlPhy, ulPhy),

    m_p10CqiPeriocity (MilliSeconds (1)),  // ideal behavior  

    m_a30CqiPeriocity (MilliSeconds (1)),  // ideal behavior

    m_uePhySapUser (0),

    m_ueCphySapUser (0),

    m_rsReceivedPowerUpdated (false),

    m_rsrpSinrSampleCounter (0)

{

  m_amc = CreateObject <LteAmc> ();

  m_uePhySapProvider = new UeMemberLteUePhySapProvider (this);

  m_ueCphySapProvider = new MemberLteUeCphySapProvider<LteUePhy> (this);

  m_macChTtiDelay = UL_PUSCH_TTIS_DELAY;

  NS_ASSERT_MSG (Simulator::Now ().GetNanoSeconds () == 0,

                 "Cannot create UE devices after simulation started");

  Simulator::ScheduleNow (&LteUePhy::SubframeIndication, this, 1, 1);

  DoReset ();

}

LteUePhy::~LteUePhy ()

{

  m_txModeGain.clear ();

}

void

LteUePhy::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  delete m_uePhySapProvider;

  delete m_ueCphySapProvider;

  LtePhy::DoDispose ();

}

TypeId

LteUePhy::GetTypeId (void)

{

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

    .SetParent<LtePhy> ()

    .AddConstructor<LteUePhy> ()

    .AddAttribute ("TxPower",

                   "Transmission power in dBm",

                   DoubleValue (10.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxPower, 

                                       &LteUePhy::GetTxPower),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("NoiseFigure",

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

                   " According to Wikipedia (http://en.wikipedia.org/wiki/Noise_figure), this is "

                   "\"the difference in decibels (dB) between"

                   " the noise output of the actual receiver to the noise output of an "

                   " ideal receiver with the same overall gain and bandwidth when the receivers "

                   " are connected to sources at the standard noise temperature T0.\" "

                   "In this model, we consider T0 = 290K.",

                   DoubleValue (9.0),

                   MakeDoubleAccessor (&LteUePhy::SetNoiseFigure, 

                                       &LteUePhy::GetNoiseFigure),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode1Gain",

                  "Transmission mode 1 gain in dB",

                  DoubleValue (0.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode1Gain                       ),

                  MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode2Gain",

                    "Transmission mode 2 gain in dB",

                    DoubleValue (4.2),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode2Gain                       ),

                    MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode3Gain",

                    "Transmission mode 3 gain in dB",

                    DoubleValue (-2.8),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode3Gain                       ),

                    MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode4Gain",

                    "Transmission mode 4 gain in dB",

                    DoubleValue (0.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode4Gain                       ),

                    MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode5Gain",

                  "Transmission mode 5 gain in dB",

                  DoubleValue (0.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode5Gain                       ),

                  MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode6Gain",

                    "Transmission mode 6 gain in dB",

                    DoubleValue (0.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode6Gain                       ),

                    MakeDoubleChecker<double> ())

    .AddAttribute ("TxMode7Gain",

                  "Transmission mode 7 gain in dB",

                  DoubleValue (0.0),

                   MakeDoubleAccessor (&LteUePhy::SetTxMode7Gain                       ),

                  MakeDoubleChecker<double> ())

    .AddTraceSource ("ReportCurrentCellRsrpSinr",

                     "RSRP and SINR statistics.",

                     MakeTraceSourceAccessor (&LteUePhy::m_reportCurrentCellRsrpSinrTrace))

    .AddAttribute ("RsrpSinrSamplePeriod",

                   "The sampling period for reporting RSRP-SINR stats (default value 1)",

                   UintegerValue (1),

                   MakeUintegerAccessor (&LteUePhy::m_rsrpSinrSamplePeriod),

                   MakeUintegerChecker<uint16_t> ())

    .AddTraceSource ("UlPhyTransmission",

                     "DL transmission PHY layer statistics.",

                     MakeTraceSourceAccessor (&LteUePhy::m_ulPhyTransmission))

    .AddAttribute ("DlSpectrumPhy",

                   "The downlink LteSpectrumPhy associated to this LtePhy",

                   TypeId::ATTR_GET,

                   PointerValue (),

                   MakePointerAccessor (&LteUePhy::GetDlSpectrumPhy),

                   MakePointerChecker <LteSpectrumPhy> ())

    .AddAttribute ("UlSpectrumPhy",

                   "The uplink LteSpectrumPhy associated to this LtePhy",

                   TypeId::ATTR_GET,

                   PointerValue (),

                   MakePointerAccessor (&LteUePhy::GetUlSpectrumPhy),

                   MakePointerChecker <LteSpectrumPhy> ())

  ;

  return tid;

}

void

{

  NS_LOG_FUNCTION (this);

}

void

LteUePhy::SetLteUePhySapUser (LteUePhySapUser* s)

{

  NS_LOG_FUNCTION (this);

  m_uePhySapUser = s;

}

LteUePhySapProvider*

LteUePhy::GetLteUePhySapProvider ()

{

  NS_LOG_FUNCTION (this);

  return (m_uePhySapProvider);

}

void

LteUePhy::SetLteUeCphySapUser (LteUeCphySapUser* s)

{

  NS_LOG_FUNCTION (this);

  m_ueCphySapUser = s;

}

LteUeCphySapProvider*

LteUePhy::GetLteUeCphySapProvider ()

{

  NS_LOG_FUNCTION (this);

  return (m_ueCphySapProvider);

}

void

LteUePhy::SetNoiseFigure (double nf)

{

  NS_LOG_FUNCTION (this << nf);

  m_noiseFigure = nf;

}

double

LteUePhy::GetNoiseFigure () const

{

  NS_LOG_FUNCTION (this);

  return m_noiseFigure;

}

void

LteUePhy::SetTxPower (double pow)

{

  NS_LOG_FUNCTION (this << pow);

  m_txPower = pow;

}

double

LteUePhy::GetTxPower () const

{

  NS_LOG_FUNCTION (this);

  return m_txPower;

}

uint8_t

LteUePhy::GetMacChDelay (void) const

{

  return (m_macChTtiDelay);

}

Ptr<LteSpectrumPhy>

LteUePhy::GetDlSpectrumPhy () const

{

  return m_downlinkSpectrumPhy;

}

Ptr<LteSpectrumPhy>

LteUePhy::GetUlSpectrumPhy () const

{

  return m_uplinkSpectrumPhy;

}

void

LteUePhy::DoSendMacPdu (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this);

  SetMacPdu (p);

}

void

LteUePhy::PhyPduReceived (Ptr<Packet> p)

{

  m_uePhySapUser->ReceivePhyPdu (p);

}

void

LteUePhy::SetSubChannelsForTransmission (std::vector <int> mask)

{

  NS_LOG_FUNCTION (this);

  m_subChannelsForTransmission = mask;

  Ptr<SpectrumValue> txPsd = CreateTxPowerSpectralDensity ();

  m_uplinkSpectrumPhy->SetTxPowerSpectralDensity (txPsd);

}

void

LteUePhy::SetSubChannelsForReception (std::vector <int> mask)

{

  NS_LOG_FUNCTION (this);

  m_subChannelsForReception = mask;

}

std::vector <int>

LteUePhy::GetSubChannelsForTransmission ()

{

  NS_LOG_FUNCTION (this);

  return m_subChannelsForTransmission;

}

std::vector <int>

LteUePhy::GetSubChannelsForReception ()

{

  NS_LOG_FUNCTION (this);

  return m_subChannelsForReception;

}

Ptr<SpectrumValue>

LteUePhy::CreateTxPowerSpectralDensity ()

{

  NS_LOG_FUNCTION (this);

  LteSpectrumValueHelper psdHelper;

  Ptr<SpectrumValue> psd = psdHelper.CreateTxPowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_txPower, GetSubChannelsForTransmission ());

  return psd;

}

void

LteUePhy::GenerateCtrlCqiReport (const SpectrumValue& sinr)

{

  NS_LOG_FUNCTION (this);

  if (!(m_dlConfigured && m_ulConfigured))

    {

      return;

    }

  // check periodic wideband CQI

  if (Simulator::Now () > m_p10CqiLast + m_p10CqiPeriocity)

    {

      Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();

      Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);

      if (msg)

        {

          DoSendLteControlMessage (msg);

        }

      m_p10CqiLast = Simulator::Now ();

    }

  // check aperiodic high-layer configured subband CQI

  if  (Simulator::Now () > m_a30CqiLast + m_a30CqiPeriocity)

    {

      Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();

      Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);

      if (msg)

        {

          DoSendLteControlMessage (msg);

        }

      m_a30CqiLast = Simulator::Now ();

    }

}

void

LteUePhy::GenerateDataCqiReport (const SpectrumValue& sinr)

{

  // Not used by UE, CQI are based only on RS

}

void

LteUePhy::ReportInterference (const SpectrumValue& interf)

{

  // Currently not used by UE

}

void

LteUePhy::ReportRsReceivedPower (const SpectrumValue& power)

{

  NS_LOG_FUNCTION (this << power);

  m_rsReceivedPowerUpdated = true;

  m_rsReceivedPower = power;  

}

Ptr<DlCqiLteControlMessage>

LteUePhy::CreateDlCqiFeedbackMessage (const SpectrumValue& sinr)

{

  NS_LOG_FUNCTION (this);

  if (m_rnti == 0)

    {

      // abort method, the UE is still not registered

      return (0);

    }

  // apply transmission mode gain

  NS_ASSERT (m_transmissionMode < m_txModeGain.size ());

  SpectrumValue newSinr = sinr;

  newSinr *= m_txModeGain.at (m_transmissionMode);

  m_rsrpSinrSampleCounter++;

  if (m_rsrpSinrSampleCounter==m_rsrpSinrSamplePeriod)

    {

      NS_ASSERT_MSG (m_rsReceivedPowerUpdated, " RS received power info obsolete");

      // RSRP evaluated as averaged received power among RBs

      double sum = 0.0;

      uint8_t rbNum = 0;

      Values::const_iterator it;

      for (it = m_rsReceivedPower.ConstValuesBegin (); it != m_rsReceivedPower.ConstValuesEnd (); it++)

        {

          // convert PSD [W/Hz] to linear power [W] for the single RE

          // we consider only one RE for the RS since the channel is

          // flat within the same RB

          double powerTxW = ((*it) * 180000.0) / 12.0;

          sum += powerTxW;

          rbNum++;

        }

      double rsrp = sum / (double)rbNum;

      // averaged SINR among RBs

      sum = 0.0;

      rbNum = 0;

      for (it = sinr.ConstValuesBegin (); it != sinr.ConstValuesEnd (); it++)

        {

          sum += (*it);

          rbNum++;

        }

      double avSinr = sum / (double)rbNum;

      NS_LOG_INFO (this << " cellId " << m_cellId << " rnti " << m_rnti << " RSRP " << rsrp << " SINR " << avSinr);

      m_reportCurrentCellRsrpSinrTrace (m_cellId, m_rnti, rsrp, avSinr);

      m_rsrpSinrSampleCounter = 0;

    }