/* -*- 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 <mmiozzo@cttc.es>

 */

#include <ns3/object-factory.h>

#include <ns3/log.h>

#include <cmath>

#include <ns3/simulator.h>

#include <ns3/attribute-accessor-helper.h>

#include <ns3/double.h>

#include "lte-enb-phy.h"

#include "lte-ue-phy.h"

#include "lte-net-device.h"

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

#include "lte-control-messages.h"

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

#include "lte-ue-rrc.h"

#include "lte-enb-mac.h"

#include <ns3/lte-common.h>

#include <ns3/lte-vendor-specific-parameters.h>

// WILD HACK for the inizialization of direct eNB-UE ctrl messaging

#include <ns3/node-list.h>

#include <ns3/node.h>

#include <ns3/lte-ue-net-device.h>

#include <ns3/pointer.h>

NS_LOG_COMPONENT_DEFINE ("LteEnbPhy");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (LteEnbPhy);

// duration of the data part of a subframe in DL

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

static const Time DL_DATA_DURATION = NanoSeconds (785714 -1);

//  delay from subframe start to transmission of the data in DL 

// = 0.001 / 14 * 3 (ctrl fixed to 3 symbols)

static const Time DL_CTRL_DELAY_FROM_SUBFRAME_START = NanoSeconds (214286);

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

// member SAP forwarders

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

class EnbMemberLteEnbPhySapProvider : public LteEnbPhySapProvider

{

public:

  EnbMemberLteEnbPhySapProvider (LteEnbPhy* phy);

  // inherited from LteEnbPhySapProvider

  virtual void SendMacPdu (Ptr<Packet> p);

  virtual void SetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth);

  virtual void SetCellId (uint16_t cellId);

  virtual void SendLteControlMessage (Ptr<LteControlMessage> msg);

  virtual uint8_t GetMacChTtiDelay ();

private:

  LteEnbPhy* m_phy;

};

EnbMemberLteEnbPhySapProvider::EnbMemberLteEnbPhySapProvider (LteEnbPhy* phy) : m_phy (phy)

{

}

void

EnbMemberLteEnbPhySapProvider::SendMacPdu (Ptr<Packet> p)

{

  m_phy->DoSendMacPdu (p);

}

void

EnbMemberLteEnbPhySapProvider::SetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth)

{

  m_phy->DoSetBandwidth (ulBandwidth, dlBandwidth);

}

void

EnbMemberLteEnbPhySapProvider::SetCellId (uint16_t cellId)

{

  m_phy->DoSetCellId (cellId);

}

void

EnbMemberLteEnbPhySapProvider::SendLteControlMessage (Ptr<LteControlMessage> msg)

{

  m_phy->DoSendLteControlMessage (msg);

}

uint8_t

EnbMemberLteEnbPhySapProvider::GetMacChTtiDelay ()

{

  return (m_phy->DoGetMacChTtiDelay ());

}

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

// generic LteEnbPhy methods

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

LteEnbPhy::LteEnbPhy ()

{

  NS_LOG_FUNCTION (this);

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

}

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

  : LtePhy (dlPhy, ulPhy),

    m_enbPhySapUser (0),

    m_enbCphySapUser (0),

    m_nrFrames (0),

    m_nrSubFrames (0),

    m_srsPeriodicity (0),

    m_srsStartTime (Seconds (0)),

    m_currentSrsOffset (0),

    m_interferenceSampleCounter (0)

{

  m_enbPhySapProvider = new EnbMemberLteEnbPhySapProvider (this);

  m_enbCphySapProvider = new MemberLteEnbCphySapProvider<LteEnbPhy> (this);

  m_harqPhyModule = Create <LteHarqPhy> ();

  m_downlinkSpectrumPhy->SetHarqPhyModule (m_harqPhyModule);

  m_uplinkSpectrumPhy->SetHarqPhyModule (m_harqPhyModule);

  Simulator::ScheduleNow (&LteEnbPhy::StartFrame, this);

}

TypeId

LteEnbPhy::GetTypeId (void)

{

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

    .SetParent<LtePhy> ()

    .AddConstructor<LteEnbPhy> ()

    .AddAttribute ("TxPower",

                   "Transmission power in dBm",

                   DoubleValue (30.0),

                   MakeDoubleAccessor (&LteEnbPhy::SetTxPower, 

                                       &LteEnbPhy::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 (5.0),

                   MakeDoubleAccessor (&LteEnbPhy::SetNoiseFigure, 

                                       &LteEnbPhy::GetNoiseFigure),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("MacToChannelDelay",

                   "The delay in TTI units that occurs between a scheduling decision in the MAC and the actual start of the transmission by the PHY. This is intended to be used to model the latency of real PHY and MAC implementations.",

                   UintegerValue (2),

                   MakeUintegerAccessor (&LteEnbPhy::SetMacChDelay, 

                                         &LteEnbPhy::GetMacChDelay),

                   MakeUintegerChecker<uint8_t> ())

    .AddTraceSource ("ReportUeSinr",

                     "Report UEs' averaged linear SINR",

                     MakeTraceSourceAccessor (&LteEnbPhy::m_reportUeSinr))

    .AddAttribute ("UeSinrSamplePeriod",

                   "The sampling period for reporting UEs' SINR stats (default value 1)",

                   UintegerValue (1),

                   MakeUintegerAccessor (&LteEnbPhy::m_srsSamplePeriod),

                   MakeUintegerChecker<uint16_t> ())

    .AddTraceSource ("ReportInterference",

                     "Report linear interference power per PHY RB",

                     MakeTraceSourceAccessor (&LteEnbPhy::m_reportInterferenceTrace))

    .AddAttribute ("InterferenceSamplePeriod",

                   "The sampling period for reporting interference stats (default value 1)",

                   UintegerValue (1),

                   MakeUintegerAccessor (&LteEnbPhy::m_interferenceSamplePeriod),

                   MakeUintegerChecker<uint16_t> ())

    .AddTraceSource ("DlPhyTransmission",

                     "DL transmission PHY layer statistics.",

                     MakeTraceSourceAccessor (&LteEnbPhy::m_dlPhyTransmission))

    .AddAttribute ("DlSpectrumPhy",

                   "The downlink LteSpectrumPhy associated to this LtePhy",

                   TypeId::ATTR_GET,

                   PointerValue (),

                   MakePointerAccessor (&LteEnbPhy::GetDlSpectrumPhy),

                   MakePointerChecker <LteSpectrumPhy> ())

    .AddAttribute ("UlSpectrumPhy",

                   "The uplink LteSpectrumPhy associated to this LtePhy",

                   TypeId::ATTR_GET,

                   PointerValue (),

                   MakePointerAccessor (&LteEnbPhy::GetUlSpectrumPhy),

                   MakePointerChecker <LteSpectrumPhy> ())

  ;

  return tid;

}

LteEnbPhy::~LteEnbPhy ()

{

}

void

LteEnbPhy::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  m_ueAttached.clear ();

  m_srsUeOffset.clear ();

  delete m_enbPhySapProvider;

  delete m_enbCphySapProvider;

  LtePhy::DoDispose ();

}

void

{

  NS_LOG_FUNCTION (this);

  Ptr<SpectrumValue> noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_noiseFigure);

  m_uplinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd);

}

void

LteEnbPhy::SetLteEnbPhySapUser (LteEnbPhySapUser* s)

{

  m_enbPhySapUser = s;

}

LteEnbPhySapProvider*

LteEnbPhy::GetLteEnbPhySapProvider ()

{

  return (m_enbPhySapProvider);

}

void

LteEnbPhy::SetLteEnbCphySapUser (LteEnbCphySapUser* s)

{

  NS_LOG_FUNCTION (this);

  m_enbCphySapUser = s;

}

LteEnbCphySapProvider*

LteEnbPhy::GetLteEnbCphySapProvider ()

{

  NS_LOG_FUNCTION (this);

  return (m_enbCphySapProvider);

}

void

LteEnbPhy::SetTxPower (double pow)

{

  NS_LOG_FUNCTION (this << pow);

  m_txPower = pow;

}

double

LteEnbPhy::GetTxPower () const

{

  NS_LOG_FUNCTION (this);

  return m_txPower;

}

void

LteEnbPhy::SetNoiseFigure (double nf)

{

  NS_LOG_FUNCTION (this << nf);

  m_noiseFigure = nf;

}

double

LteEnbPhy::GetNoiseFigure () const

{

  NS_LOG_FUNCTION (this);

  return m_noiseFigure;

}

void

LteEnbPhy::SetMacChDelay (uint8_t delay)

{

  NS_LOG_FUNCTION (this);

  m_macChTtiDelay = delay;

  for (int i = 0; i < m_macChTtiDelay; i++)

    {

      Ptr<PacketBurst> pb = CreateObject <PacketBurst> ();

      m_packetBurstQueue.push_back (pb);

      std::list<Ptr<LteControlMessage> > l;

      m_controlMessagesQueue.push_back (l);

      std::list<UlDciLteControlMessage> l1;

      m_ulDciQueue.push_back (l1);

    }

  for (int i = 0; i < UL_PUSCH_TTIS_DELAY; i++)

    {

      std::list<UlDciLteControlMessage> l1;

      m_ulDciQueue.push_back (l1);

    }

}

uint8_t

LteEnbPhy::GetMacChDelay (void) const

{

  return (m_macChTtiDelay);

}

Ptr<LteSpectrumPhy>

LteEnbPhy::GetDlSpectrumPhy () const

{

  return m_downlinkSpectrumPhy;

}

Ptr<LteSpectrumPhy>

LteEnbPhy::GetUlSpectrumPhy () const

{

  return m_uplinkSpectrumPhy;

}

bool

LteEnbPhy::AddUePhy (uint16_t rnti)

{

  NS_LOG_FUNCTION (this << rnti);

  std::set <uint16_t>::iterator it;

  it = m_ueAttached.find (rnti);

  if (it == m_ueAttached.end ())

    {

      m_ueAttached.insert (rnti);

      return (true);

    }

  else

    {

      NS_LOG_ERROR ("UE already attached");

      return (false);

    }

}

bool

LteEnbPhy::DeleteUePhy (uint16_t rnti)

{

  NS_LOG_FUNCTION (this << rnti);

  std::set <uint16_t>::iterator it;

  it = m_ueAttached.find (rnti);

  if (it == m_ueAttached.end ())

    {

      NS_LOG_ERROR ("UE not attached");

      return (false);

    }

  else

    {

      m_ueAttached.erase (it);

      return (true);

    }

}

void

LteEnbPhy::DoSendMacPdu (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this);

  SetMacPdu (p);

}

uint8_t

LteEnbPhy::DoGetMacChTtiDelay ()

{

  return (m_macChTtiDelay);

}

void

LteEnbPhy::PhyPduReceived (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this);

  m_enbPhySapUser->ReceivePhyPdu (p);

}

void

LteEnbPhy::SetDownlinkSubChannels (std::vector<int> mask)

{

  NS_LOG_FUNCTION (this);

  m_listOfDownlinkSubchannel = mask;

  Ptr<SpectrumValue> txPsd = CreateTxPowerSpectralDensity ();

  m_downlinkSpectrumPhy->SetTxPowerSpectralDensity (txPsd);

}

std::vector<int>

LteEnbPhy::GetDownlinkSubChannels (void)

{

  NS_LOG_FUNCTION (this);

  return m_listOfDownlinkSubchannel;

}

Ptr<SpectrumValue>

LteEnbPhy::CreateTxPowerSpectralDensity ()

{

  NS_LOG_FUNCTION (this);

  Ptr<SpectrumValue> psd = LteSpectrumValueHelper::CreateTxPowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_txPower, GetDownlinkSubChannels ());

  return psd;

}

void

LteEnbPhy::CalcChannelQualityForUe (std::vector <double> sinr, Ptr<LteSpectrumPhy> ue)

{

  NS_LOG_FUNCTION (this);

}

void

LteEnbPhy::DoSendLteControlMessage (Ptr<LteControlMessage> msg)

{

  NS_LOG_FUNCTION (this << msg);

  // queues the message (wait for MAC-PHY delay)

  SetControlMessages (msg);

}

void

LteEnbPhy::ReceiveLteControlMessage (Ptr<LteControlMessage> msg)

{

  NS_FATAL_ERROR ("Obsolete function");

  NS_LOG_FUNCTION (this << msg);

  m_enbPhySapUser->ReceiveLteControlMessage (msg);

}

void

LteEnbPhy::ReceiveLteControlMessageList (std::list<Ptr<LteControlMessage> > msgList)

{

  NS_LOG_FUNCTION (this);

  std::list<Ptr<LteControlMessage> >::iterator it;

  for (it = msgList.begin (); it != msgList.end(); it++)

    {

      switch ((*it)->GetMessageType ())

        {

        case LteControlMessage::RACH_PREAMBLE:

          {

            Ptr<RachPreambleLteControlMessage> rachPreamble = DynamicCast<RachPreambleLteControlMessage> (*it);

            m_enbPhySapUser->ReceiveRachPreamble (rachPreamble->GetRapId ());

          }

          break;

        default:

          m_enbPhySapUser->ReceiveLteControlMessage (*it);

          break;

        }

    }

}

void

LteEnbPhy::StartFrame (void)

{

  NS_LOG_FUNCTION (this);

  ++m_nrFrames;

  NS_LOG_INFO ("-----frame " << m_nrFrames << "-----");

  m_nrSubFrames = 0;

  // send MIB at beginning of every frame

  m_mib.systemFrameNumber = m_nrSubFrames;

  Ptr<MibLteControlMessage> mibMsg = Create<MibLteControlMessage> ();

  mibMsg->SetMib (m_mib);

  m_controlMessagesQueue.at (0).push_back (mibMsg);

  StartSubFrame ();

}

void

LteEnbPhy::StartSubFrame (void)