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

/*

 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (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> (re-wrote from scratch this helper)

 *         Giuseppe Piro <g.piro@poliba.it> (parts of the PHY & channel  creation & configuration copied from the GSoC 2011 code)

 */

#include "lte-helper.h"

#include <ns3/string.h>

#include <ns3/log.h>

#include <ns3/abort.h>

#include <ns3/pointer.h>

#include <ns3/lte-enb-rrc.h>

#include <ns3/epc-ue-nas.h>

#include <ns3/epc-enb-application.h>

#include <ns3/lte-ue-rrc.h>

#include <ns3/lte-ue-mac.h>

#include <ns3/lte-enb-mac.h>

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

#include <ns3/lte-enb-phy.h>

#include <ns3/lte-ue-phy.h>

#include <ns3/lte-spectrum-phy.h>

#include <ns3/lte-sinr-chunk-processor.h>

#include <ns3/multi-model-spectrum-channel.h>

#include <ns3/friis-spectrum-propagation-loss.h>

#include <ns3/trace-fading-loss-model.h>

#include <ns3/isotropic-antenna-model.h>

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

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

#include <ns3/ff-mac-scheduler.h>

#include <ns3/lte-handover-algorithm.h>

#include <ns3/lte-anr.h>

#include <ns3/lte-rlc.h>

#include <ns3/lte-rlc-um.h>

#include <ns3/lte-rlc-am.h>

#include <ns3/epc-enb-s1-sap.h>

#include <ns3/lte-rrc-protocol-ideal.h>

#include <ns3/lte-rrc-protocol-real.h>

#include <ns3/mac-stats-calculator.h>

#include <ns3/phy-stats-calculator.h>

#include <ns3/phy-tx-stats-calculator.h>

#include <ns3/phy-rx-stats-calculator.h>

#include <ns3/epc-helper.h>

#include <iostream>

#include <ns3/buildings-propagation-loss-model.h>

#include <ns3/lte-spectrum-value-helper.h>

#include <ns3/epc-x2.h>

NS_LOG_COMPONENT_DEFINE ("LteHelper");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (LteHelper);

LteHelper::LteHelper (void)

  : m_fadingStreamsAssigned (false),

    m_imsiCounter (0),

    m_cellIdCounter (0)

{

  NS_LOG_FUNCTION (this);

  m_enbNetDeviceFactory.SetTypeId (LteEnbNetDevice::GetTypeId ());

  m_enbAntennaModelFactory.SetTypeId (IsotropicAntennaModel::GetTypeId ());

  m_ueNetDeviceFactory.SetTypeId (LteUeNetDevice::GetTypeId ());

  m_ueAntennaModelFactory.SetTypeId (IsotropicAntennaModel::GetTypeId ());

  m_channelFactory.SetTypeId (MultiModelSpectrumChannel::GetTypeId ());

}

void 

LteHelper::DoInitialize (void)

{

  NS_LOG_FUNCTION (this);

  m_downlinkChannel = m_channelFactory.Create<SpectrumChannel> ();

  m_uplinkChannel = m_channelFactory.Create<SpectrumChannel> ();

  m_downlinkPathlossModel = m_dlPathlossModelFactory.Create ();

  Ptr<SpectrumPropagationLossModel> dlSplm = m_downlinkPathlossModel->GetObject<SpectrumPropagationLossModel> ();

  if (dlSplm != 0)

    {

      NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in DL");

      m_downlinkChannel->AddSpectrumPropagationLossModel (dlSplm);

    }

  else

    {

      NS_LOG_LOGIC (this << " using a PropagationLossModel in DL");

      Ptr<PropagationLossModel> dlPlm = m_downlinkPathlossModel->GetObject<PropagationLossModel> ();

      NS_ASSERT_MSG (dlPlm != 0, " " << m_downlinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel");

      m_downlinkChannel->AddPropagationLossModel (dlPlm);

    }

  m_uplinkPathlossModel = m_ulPathlossModelFactory.Create ();

  Ptr<SpectrumPropagationLossModel> ulSplm = m_uplinkPathlossModel->GetObject<SpectrumPropagationLossModel> ();

  if (ulSplm != 0)

    {

      NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in UL");

      m_uplinkChannel->AddSpectrumPropagationLossModel (ulSplm);

    }

  else

    {

      NS_LOG_LOGIC (this << " using a PropagationLossModel in UL");

      Ptr<PropagationLossModel> ulPlm = m_uplinkPathlossModel->GetObject<PropagationLossModel> ();

      NS_ASSERT_MSG (ulPlm != 0, " " << m_uplinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel");

      m_uplinkChannel->AddPropagationLossModel (ulPlm);

    }

  if (!m_fadingModelType.empty ())

    {

      m_fadingModule = m_fadingModelFactory.Create<SpectrumPropagationLossModel> ();

      m_fadingModule->Initialize ();

      m_downlinkChannel->AddSpectrumPropagationLossModel (m_fadingModule);

      m_uplinkChannel->AddSpectrumPropagationLossModel (m_fadingModule);

    }

  m_phyStats = CreateObject<PhyStatsCalculator> ();

  m_phyTxStats = CreateObject<PhyTxStatsCalculator> ();

  m_phyRxStats = CreateObject<PhyRxStatsCalculator> ();

  m_macStats = CreateObject<MacStatsCalculator> ();

  Object::DoInitialize ();

}

LteHelper::~LteHelper (void)

{

  NS_LOG_FUNCTION (this);

}

TypeId LteHelper::GetTypeId (void)

{

  static TypeId

    tid =

    TypeId ("ns3::LteHelper")

    .SetParent<Object> ()

    .AddConstructor<LteHelper> ()

    .AddAttribute ("Scheduler",

                   "The type of scheduler to be used for eNBs. "

                   "The allowed values for this attributes are the type names "

                   "of any class inheriting from ns3::FfMacScheduler.",

                   StringValue ("ns3::PfFfMacScheduler"),

                   MakeStringAccessor (&LteHelper::SetSchedulerType,

                                       &LteHelper::GetSchedulerType),

                   MakeStringChecker ())

    .AddAttribute ("HandoverAlgorithm",

                   "The type of handover algorithm to be used for eNBs. "

                   "The allowed values for this attributes are the type names "

                   "of any class inheriting from ns3::HandoverAlgorithm.",

                   StringValue ("ns3::NoOpHandoverAlgorithm"),

                   MakeStringAccessor (&LteHelper::SetHandoverAlgorithmType,

                                       &LteHelper::GetHandoverAlgorithmType),

                   MakeStringChecker ())

    .AddAttribute ("PathlossModel",

                   "The type of pathloss model to be used. "

                   "The allowed values for this attributes are the type names "

                   "of any class inheriting from ns3::PropagationLossModel.",

                   StringValue ("ns3::FriisPropagationLossModel"),

                   MakeStringAccessor (&LteHelper::SetPathlossModelType),

                   MakeStringChecker ())

    .AddAttribute ("FadingModel",

                   "The type of fading model to be used."

                   "The allowed values for this attributes are the type names "

                   "of any class inheriting from ns3::SpectrumPropagationLossModel."

                   "If the type is set to an empty string, no fading model is used.",

                   StringValue (""),

                   MakeStringAccessor (&LteHelper::SetFadingModel),

                   MakeStringChecker ())

    .AddAttribute ("UseIdealRrc",

                   "If true, LteRrcProtocolIdeal will be used for RRC signaling. "

                   "If false, LteRrcProtocolReal will be used.",

                   BooleanValue (true), 

                   MakeBooleanAccessor (&LteHelper::m_useIdealRrc),

                   MakeBooleanChecker ())

    .AddAttribute ("AnrEnabled",

                   "Activate or deactivate Automatic Neighbour Relation function",

                   BooleanValue (true),

                   MakeBooleanAccessor (&LteHelper::m_isAnrEnabled),

                   MakeBooleanChecker ())

  ;

  return tid;

}

void

LteHelper::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  m_downlinkChannel = 0;

  m_uplinkChannel = 0;

  Object::DoDispose ();

}

void 

LteHelper::SetEpcHelper (Ptr<EpcHelper> h)

{

  NS_LOG_FUNCTION (this << h);

  m_epcHelper = h;

}

void 

LteHelper::SetSchedulerType (std::string type) 

{

  NS_LOG_FUNCTION (this << type);

  m_schedulerFactory = ObjectFactory ();

  m_schedulerFactory.SetTypeId (type);

}

std::string

LteHelper::GetSchedulerType () const

{

  return m_schedulerFactory.GetTypeId ().GetName ();

} 

void 

LteHelper::SetSchedulerAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this << n);

  m_schedulerFactory.Set (n, v);

}

std::string

LteHelper::GetHandoverAlgorithmType () const

{

  return m_handoverAlgorithmFactory.GetTypeId ().GetName ();

}

void

LteHelper::SetHandoverAlgorithmType (std::string type)

{

  NS_LOG_FUNCTION (this << type);

  m_handoverAlgorithmFactory = ObjectFactory ();

  m_handoverAlgorithmFactory.SetTypeId (type);

}

void

LteHelper::SetHandoverAlgorithmAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this << n);

  m_handoverAlgorithmFactory.Set (n, v);

}

void 

LteHelper::SetPathlossModelType (std::string type) 

{

  NS_LOG_FUNCTION (this << type);

  m_dlPathlossModelFactory = ObjectFactory ();

  m_dlPathlossModelFactory.SetTypeId (type);

  m_ulPathlossModelFactory = ObjectFactory ();

  m_ulPathlossModelFactory.SetTypeId (type);

}

void 

LteHelper::SetPathlossModelAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this << n);

  m_dlPathlossModelFactory.Set (n, v);

  m_ulPathlossModelFactory.Set (n, v);

}

void

LteHelper::SetEnbDeviceAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this);

  m_enbNetDeviceFactory.Set (n, v);

}

void 

LteHelper::SetEnbAntennaModelType (std::string type)

{

  NS_LOG_FUNCTION (this);

  m_enbAntennaModelFactory.SetTypeId (type);

}

void 

LteHelper::SetEnbAntennaModelAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this);

  m_enbAntennaModelFactory.Set (n, v);

}

void

LteHelper::SetUeDeviceAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this);

  m_ueNetDeviceFactory.Set (n, v);

}

void 

LteHelper::SetUeAntennaModelType (std::string type)

{

  NS_LOG_FUNCTION (this);

  m_ueAntennaModelFactory.SetTypeId (type);

}

void 

LteHelper::SetUeAntennaModelAttribute (std::string n, const AttributeValue &v)

{

  NS_LOG_FUNCTION (this);

  m_ueAntennaModelFactory.Set (n, v);

}

void 

LteHelper::SetFadingModel (std::string type) 

{

  NS_LOG_FUNCTION (this << type);

  m_fadingModelType = type;

  if (!type.empty ())

    {

      m_fadingModelFactory = ObjectFactory ();

      m_fadingModelFactory.SetTypeId (type);

    }

}

void 

LteHelper::SetFadingModelAttribute (std::string n, const AttributeValue &v)

{

  m_fadingModelFactory.Set (n, v);

}

void 

LteHelper::SetSpectrumChannelType (std::string type) 

{

  NS_LOG_FUNCTION (this << type);

  m_channelFactory.SetTypeId (type);

}

void 

LteHelper::SetSpectrumChannelAttribute (std::string n, const AttributeValue &v)

{

  m_channelFactory.Set (n, v);

}

NetDeviceContainer

LteHelper::InstallEnbDevice (NodeContainer c)

{

  NS_LOG_FUNCTION (this);

  Initialize ();  // will run DoInitialize () if necessary

  NetDeviceContainer devices;

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      Ptr<Node> node = *i;

      Ptr<NetDevice> device = InstallSingleEnbDevice (node);

      devices.Add (device);

    }

  return devices;

}

NetDeviceContainer

LteHelper::InstallUeDevice (NodeContainer c)

{

  NS_LOG_FUNCTION (this);

  NetDeviceContainer devices;

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      Ptr<Node> node = *i;

      Ptr<NetDevice> device = InstallSingleUeDevice (node);

      devices.Add (device);

    }

  return devices;

}

Ptr<NetDevice>

LteHelper::InstallSingleEnbDevice (Ptr<Node> n)

{

  NS_ABORT_MSG_IF (m_cellIdCounter == 65535, "max num eNBs exceeded");

  uint16_t cellId = ++m_cellIdCounter;

  Ptr<LteSpectrumPhy> dlPhy = CreateObject<LteSpectrumPhy> ();

  Ptr<LteSpectrumPhy> ulPhy = CreateObject<LteSpectrumPhy> ();

  Ptr<LteEnbPhy> phy = CreateObject<LteEnbPhy> (dlPhy, ulPhy);

  Ptr<LteHarqPhy> harq = Create<LteHarqPhy> ();

  dlPhy->SetHarqPhyModule (harq);

  ulPhy->SetHarqPhyModule (harq);

  phy->SetHarqPhyModule (harq);

  Ptr<LteCtrlSinrChunkProcessor> pCtrl = Create<LteCtrlSinrChunkProcessor> (phy->GetObject<LtePhy> ());

  ulPhy->AddCtrlSinrChunkProcessor (pCtrl); // for evaluating SRS UL-CQI

  Ptr<LteDataSinrChunkProcessor> pData = Create<LteDataSinrChunkProcessor> (ulPhy, phy);

  ulPhy->AddDataSinrChunkProcessor (pData); // for evaluating PUSCH UL-CQI

  Ptr<LteInterferencePowerChunkProcessor> pInterf = Create<LteInterferencePowerChunkProcessor> (phy);

  ulPhy->AddInterferenceDataChunkProcessor (pInterf); // for interference power tracing

  dlPhy->SetChannel (m_downlinkChannel);

  ulPhy->SetChannel (m_uplinkChannel);

  Ptr<MobilityModel> mm = n->GetObject<MobilityModel> ();

  NS_ASSERT_MSG (mm, "MobilityModel needs to be set on node before calling LteHelper::InstallUeDevice ()");

  dlPhy->SetMobility (mm);

  ulPhy->SetMobility (mm);

  Ptr<AntennaModel> antenna = (m_enbAntennaModelFactory.Create ())->GetObject<AntennaModel> ();

  NS_ASSERT_MSG (antenna, "error in creating the AntennaModel object");

  dlPhy->SetAntenna (antenna);

  ulPhy->SetAntenna (antenna);

  Ptr<LteEnbMac> mac = CreateObject<LteEnbMac> ();

  Ptr<FfMacScheduler> sched = m_schedulerFactory.Create<FfMacScheduler> ();

  Ptr<LteHandoverAlgorithm> handoverAlgorithm = m_handoverAlgorithmFactory.Create<LteHandoverAlgorithm> ();

  Ptr<LteEnbRrc> rrc = CreateObject<LteEnbRrc> ();

  if (m_useIdealRrc)

    {

      Ptr<LteEnbRrcProtocolIdeal> rrcProtocol = CreateObject<LteEnbRrcProtocolIdeal> ();

      rrcProtocol->SetLteEnbRrcSapProvider (rrc->GetLteEnbRrcSapProvider ());

      rrc->SetLteEnbRrcSapUser (rrcProtocol->GetLteEnbRrcSapUser ());

      rrc->AggregateObject (rrcProtocol);

      rrcProtocol->SetCellId (cellId);

    }

  else

    {

      Ptr<LteEnbRrcProtocolReal> rrcProtocol = CreateObject<LteEnbRrcProtocolReal> ();

      rrcProtocol->SetLteEnbRrcSapProvider (rrc->GetLteEnbRrcSapProvider ());

      rrc->SetLteEnbRrcSapUser (rrcProtocol->GetLteEnbRrcSapUser ());

      rrc->AggregateObject (rrcProtocol);

      rrcProtocol->SetCellId (cellId);

    }

  if (m_epcHelper != 0)

    {

      EnumValue epsBearerToRlcMapping;

      rrc->GetAttribute ("EpsBearerToRlcMapping", epsBearerToRlcMapping);

      // it does not make sense to use RLC/SM when also using the EPC

      if (epsBearerToRlcMapping.Get () == LteEnbRrc::RLC_SM_ALWAYS)

        {

          rrc->SetAttribute ("EpsBearerToRlcMapping", EnumValue (LteEnbRrc::RLC_UM_ALWAYS));

        }

    }

  rrc->SetLteEnbCmacSapProvider (mac->GetLteEnbCmacSapProvider ());

  mac->SetLteEnbCmacSapUser (rrc->GetLteEnbCmacSapUser ());

  rrc->SetLteMacSapProvider (mac->GetLteMacSapProvider ());

  rrc->SetLteHandoverManagementSapProvider (handoverAlgorithm->GetLteHandoverManagementSapProvider ());

  handoverAlgorithm->SetLteHandoverManagementSapUser (rrc->GetLteHandoverManagementSapUser ());

  mac->SetFfMacSchedSapProvider (sched->GetFfMacSchedSapProvider ());

  mac->SetFfMacCschedSapProvider (sched->GetFfMacCschedSapProvider ());

  sched->SetFfMacSchedSapUser (mac->GetFfMacSchedSapUser ());

  sched->SetFfMacCschedSapUser (mac->GetFfMacCschedSapUser ());

  phy->SetLteEnbPhySapUser (mac->GetLteEnbPhySapUser ());

  mac->SetLteEnbPhySapProvider (phy->GetLteEnbPhySapProvider ());

  phy->SetLteEnbCphySapUser (rrc->GetLteEnbCphySapUser ());

  rrc->SetLteEnbCphySapProvider (phy->GetLteEnbCphySapProvider ());

  Ptr<LteEnbNetDevice> dev = m_enbNetDeviceFactory.Create<LteEnbNetDevice> ();

  dev->SetNode (n);

  dev->SetAttribute ("CellId", UintegerValue (cellId)); 

  dev->SetAttribute ("LteEnbPhy", PointerValue (phy));

  dev->SetAttribute ("LteEnbMac", PointerValue (mac));

  dev->SetAttribute ("FfMacScheduler", PointerValue (sched));

  dev->SetAttribute ("LteEnbRrc", PointerValue (rrc)); 

  dev->SetAttribute ("LteHandoverAlgorithm", PointerValue (handoverAlgorithm));

  if (m_isAnrEnabled)

    {

      Ptr<LteAnr> anr = CreateObject<LteAnr> (cellId);

      rrc->SetLteAnrSapProvider (anr->GetLteAnrSapProvider ());

      anr->SetLteAnrSapUser (rrc->GetLteAnrSapUser ());

      dev->SetAttribute ("LteAnr", PointerValue (anr));

    }

  phy->SetDevice (dev);

  dlPhy->SetDevice (dev);

  ulPhy->SetDevice (dev);

  n->AddDevice (dev);