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

 *         Marco Miozzo <mmiozzo@cttc.es>

 *         Manuel Requena <manuel.requena@cttc.es>

 */

#include "ns3/fatal-error.h"

#include "ns3/log.h"

#include "ns3/abort.h"

#include "ns3/pointer.h"

#include "ns3/object-map.h"

#include "ns3/object-factory.h"

#include "ns3/simulator.h"

#include "lte-enb-rrc.h"

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

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

#include "eps-bearer-tag.h"

#include "ff-mac-csched-sap.h"

#include "epc-enb-s1-sap.h"

#include "lte-rlc.h"

#include "lte-rlc-tm.h"

#include "lte-rlc-um.h"

#include "lte-rlc-am.h"

#include "lte-pdcp.h"

#include "lte-pdcp-sap.h"

#include <ns3/simulator.h>

NS_LOG_COMPONENT_DEFINE ("LteEnbRrc");

namespace ns3 {

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

// CMAC SAP forwarder

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

class EnbRrcMemberLteEnbCmacSapUser : public LteEnbCmacSapUser

{

public:

  EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc);

  virtual uint16_t AllocateTemporaryCellRnti ();

  virtual void NotifyLcConfigResult (uint16_t rnti, uint8_t lcid, bool success);

  virtual void RrcConfigurationUpdateInd (UeConfig params);

private:

  LteEnbRrc* m_rrc;

};

EnbRrcMemberLteEnbCmacSapUser::EnbRrcMemberLteEnbCmacSapUser (LteEnbRrc* rrc)

  : m_rrc (rrc)

{

}

uint16_t

EnbRrcMemberLteEnbCmacSapUser::AllocateTemporaryCellRnti ()

{

  return m_rrc->DoAllocateTemporaryCellRnti ();

}

void

EnbRrcMemberLteEnbCmacSapUser::NotifyLcConfigResult (uint16_t rnti, uint8_t lcid, bool success)

{

  m_rrc->DoNotifyLcConfigResult (rnti, lcid, success);

}

void

EnbRrcMemberLteEnbCmacSapUser::RrcConfigurationUpdateInd (UeConfig params)

{

  m_rrc->DoRrcConfigurationUpdateInd (params);

}

const char* g_ueManagerStateName[UeManager::NUM_STATES] = 

  {

    "INITIAL_RANDOM_ACCESS",

    "CONNECTION_SETUP",

    "CONNECTED_NORMALLY",

    "CONNECTION_RECONFIGURATION",

    "CONNECTION_REESTABLISHMENT",

    "HANDOVER_JOINING",

    "HANDOVER_LEAVING",

  };

std::string ToString (UeManager::State s)

{

  return std::string (g_ueManagerStateName[s]);

}

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

// UeManager 

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

NS_OBJECT_ENSURE_REGISTERED (UeManager);

UeManager::UeManager ()

{

  NS_FATAL_ERROR ("this constructor is not espected to be used");

}

UeManager::UeManager (Ptr<LteEnbRrc> rrc, uint16_t rnti, State s)

  : m_lastAllocatedDrbid (0),

    m_rnti (rnti),

    m_imsi (0),

    m_lastRrcTransactionIdentifier (0),

    m_rrc (rrc),

    m_state (s),

    m_pendingRrcConnectionReconfiguration (false),

    m_sourceX2apId (0),

    m_sourceCellId (0)

{ 

  NS_LOG_FUNCTION (this);

  m_pdcpSapUser = new LtePdcpSpecificLtePdcpSapUser<UeManager> (this);

  m_physicalConfigDedicated.haveAntennaInfoDedicated = true;

  m_physicalConfigDedicated.antennaInfo.transmissionMode = m_rrc->m_defaultTransmissionMode;

  m_physicalConfigDedicated.haveSoundingRsUlConfigDedicated = true;

  m_physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex = m_rrc->GetNewSrsConfigurationIndex ();

  m_rrc->m_cmacSapProvider->AddUe (rnti);

  m_rrc->m_cphySapProvider->AddUe (rnti);

  // setup the eNB side of SRB0

  {

    uint8_t lcid = 0;

    Ptr<LteRlc> rlc = CreateObject<LteRlcTm> ()->GetObject<LteRlc> ();

    rlc->SetLteMacSapProvider (m_rrc->m_macSapProvider);

    rlc->SetRnti (m_rnti);

    rlc->SetLcId (lcid);

    m_srb0 = CreateObject<LteSignalingRadioBearerInfo> ();  

    m_srb0->m_rlc = rlc;

    m_srb0->m_srbIdentity = 1;

    // no need to store logicalChannelConfig as SRB0 is pre-configured

    LteEnbCmacSapProvider::LcInfo lcinfo;

    lcinfo.rnti = m_rnti;

    lcinfo.lcId = lcid;

    // leave the rest of lcinfo empty as CCCH (LCID 0) is pre-configured

    m_rrc->m_cmacSapProvider->AddLc (lcinfo, rlc->GetLteMacSapUser ());

  }

  // setup the eNB side of SRB1; the UE side will be set up upon RRC connection establishment

  {

    uint8_t lcid = 1;

    Ptr<LteRlc> rlc = CreateObject<LteRlcAm> ()->GetObject<LteRlc> ();

    rlc->SetLteMacSapProvider (m_rrc->m_macSapProvider);

    rlc->SetRnti (m_rnti);

    rlc->SetLcId (lcid);

    Ptr<LtePdcp> pdcp = CreateObject<LtePdcp> ();

    pdcp->SetRnti (m_rnti);

    pdcp->SetLcId (lcid);

    pdcp->SetLtePdcpSapUser (m_pdcpSapUser);

    pdcp->SetLteRlcSapProvider (rlc->GetLteRlcSapProvider ());

    rlc->SetLteRlcSapUser (pdcp->GetLteRlcSapUser ());

    m_srb1 = CreateObject<LteSignalingRadioBearerInfo> ();  

    m_srb1->m_rlc = rlc;

    m_srb1->m_pdcp = pdcp;

    m_srb1->m_srbIdentity = 1;

    m_srb1->m_logicalChannelConfig.priority = 0;

    m_srb1->m_logicalChannelConfig.prioritizedBitRateKbps = 100;

    m_srb1->m_logicalChannelConfig.bucketSizeDurationMs = 100;

    m_srb1->m_logicalChannelConfig.logicalChannelGroup = 0;

    LteEnbCmacSapProvider::LcInfo lcinfo;

    lcinfo.rnti = m_rnti;

    lcinfo.lcId = lcid;

    lcinfo.lcGroup = 0; // all SRBs always mapped to LCG 0

    lcinfo.qci = EpsBearer::GBR_CONV_VOICE; // not sure why the FF API requires a CQI even for SRBs...

    lcinfo.isGbr = true;

    lcinfo.mbrUl = 1e6;

    lcinfo.mbrDl = 1e6;

    lcinfo.gbrUl = 1e4;

    lcinfo.gbrDl = 1e4;

    m_rrc->m_cmacSapProvider->AddLc (lcinfo, rlc->GetLteMacSapUser ());

  }

  LteEnbRrcSapUser::SetupUeParameters ueParams;

  ueParams.srb0SapProvider = m_srb0->m_rlc->GetLteRlcSapProvider ();

  ueParams.srb1SapProvider = m_srb1->m_pdcp->GetLtePdcpSapProvider ();

  m_rrc->m_rrcSapUser->SetupUe (m_rnti, ueParams);

  // configure MAC (and scheduler)

  LteEnbCmacSapProvider::UeConfig req;

  req.m_rnti = rnti;

  req.m_transmissionMode = m_physicalConfigDedicated.antennaInfo.transmissionMode;

  m_rrc->m_cmacSapProvider->UeUpdateConfigurationReq (req);

  // configure PHY

  m_rrc->m_cphySapProvider->SetTransmissionMode (rnti, m_physicalConfigDedicated.antennaInfo.transmissionMode);

  m_rrc->m_cphySapProvider->SetSrsConfigurationIndex (rnti, m_physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex);

}

UeManager::~UeManager (void)

{

}

void

UeManager::DoDispose ()

{

  delete m_pdcpSapUser;

  m_rrc->m_cmacSapProvider->RemoveUe (m_rnti);

  m_rrc->m_cphySapProvider->RemoveUe (m_rnti);

}

TypeId UeManager::GetTypeId (void)

{

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

    .SetParent<Object> ()

    .AddConstructor<UeManager> ()

    .AddAttribute ("DataRadioBearerMap", "List of UE RadioBearerInfo by DRBID.",

                   ObjectMapValue (),

                   MakeObjectMapAccessor (&UeManager::m_drbMap),

                   MakeObjectMapChecker<LteDataRadioBearerInfo> ())

    .AddTraceSource ("StateTransition",

                     "fired upon every UE state transition seen by the UeManager at the eNB RRC",

                     MakeTraceSourceAccessor (&UeManager::m_stateTransitionCallback))

  ;

  return tid;

}

void 

UeManager::SetSource (uint16_t sourceCellId, uint16_t sourceX2apId)

{

  m_sourceX2apId = sourceX2apId;

  m_sourceCellId = sourceCellId;

}

uint8_t

UeManager::SetupDataRadioBearer (EpsBearer bearer, uint32_t gtpTeid, Ipv4Address transportLayerAddress)

{

  NS_LOG_FUNCTION (this << (uint32_t) m_rnti);

  Ptr<LteDataRadioBearerInfo> drbInfo = CreateObject<LteDataRadioBearerInfo> ();

  uint8_t drbid = AddDataRadioBearerInfo (drbInfo);

  uint8_t lcid = Drbid2Lcid (drbid); 

  uint8_t bid = Drbid2Bid (drbid);  

  drbInfo->m_epsBearerIdentity = bid;

  drbInfo->m_drbIdentity = drbid;

  drbInfo->m_logicalChannelIdentity = lcid;

  drbInfo->m_gtpTeid = gtpTeid;

  drbInfo->m_transportLayerAddress = transportLayerAddress;

  TypeId rlcTypeId = m_rrc->GetRlcType (bearer);

  ObjectFactory rlcObjectFactory;

  rlcObjectFactory.SetTypeId (rlcTypeId);

  Ptr<LteRlc> rlc = rlcObjectFactory.Create ()->GetObject<LteRlc> ();

  rlc->SetLteMacSapProvider (m_rrc->m_macSapProvider);

  rlc->SetRnti (m_rnti);

  drbInfo->m_rlc = rlc;

  rlc->SetLcId (lcid);

  // we need PDCP only for real RLC, i.e., RLC/UM or RLC/AM

  // if we are using RLC/SM we don't care of anything above RLC

  if (rlcTypeId != LteRlcSm::GetTypeId ())

    {

      Ptr<LtePdcp> pdcp = CreateObject<LtePdcp> ();

      pdcp->SetRnti (m_rnti);

      pdcp->SetLcId (lcid);

      pdcp->SetLtePdcpSapUser (m_pdcpSapUser);

      pdcp->SetLteRlcSapProvider (rlc->GetLteRlcSapProvider ());

      rlc->SetLteRlcSapUser (pdcp->GetLteRlcSapUser ());

      drbInfo->m_pdcp = pdcp;

    }

  LteEnbCmacSapProvider::LcInfo lcinfo;

  lcinfo.rnti = m_rnti;

  lcinfo.lcId = lcid;

  lcinfo.lcGroup = m_rrc->GetLogicalChannelGroup (bearer);

  lcinfo.qci = bearer.qci;

  lcinfo.isGbr = bearer.IsGbr ();

  lcinfo.mbrUl = bearer.gbrQosInfo.mbrUl;

  lcinfo.mbrDl = bearer.gbrQosInfo.mbrDl;

  lcinfo.gbrUl = bearer.gbrQosInfo.gbrUl;

  lcinfo.gbrDl = bearer.gbrQosInfo.gbrDl;

  m_rrc->m_cmacSapProvider->AddLc (lcinfo, rlc->GetLteMacSapUser ());

  if (drbInfo->m_rlc->GetTypeId () == LteRlcAm::GetTypeId ())

    {

      drbInfo->m_rlcConfig.choice =  LteRrcSap::RlcConfig::AM;

    }

  else

    {

      drbInfo->m_rlcConfig.choice =  LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL;

    }

  drbInfo->m_logicalChannelIdentity = lcid;

  drbInfo->m_logicalChannelConfig.priority =  m_rrc->GetLogicalChannelPriority (bearer);

  drbInfo->m_logicalChannelConfig.logicalChannelGroup = m_rrc->GetLogicalChannelGroup (bearer);

  if (bearer.IsGbr ())

    {

      drbInfo->m_logicalChannelConfig.prioritizedBitRateKbps = bearer.gbrQosInfo.gbrUl;      

    }

  else

    {

      drbInfo->m_logicalChannelConfig.prioritizedBitRateKbps = 0;

    }

  drbInfo->m_logicalChannelConfig.bucketSizeDurationMs = 1000;

  return drbid;

}

void

UeManager::ReleaseDataRadioBearer (uint8_t drbid)

{

  NS_LOG_FUNCTION (this << (uint32_t) m_rnti << (uint32_t) drbid);

  uint8_t lcid = Drbid2Lcid (drbid);

  std::map <uint8_t, Ptr<LteDataRadioBearerInfo> >::iterator it = m_drbMap.find (drbid);

  NS_ASSERT_MSG (it != m_drbMap.end (), "request to remove radio bearer with unknown drbid " << drbid);

  m_drbMap.erase (it);

  m_rrc->m_cmacSapProvider->ReleaseLc (m_rnti, lcid);

  LteRrcSap::RadioResourceConfigDedicated rrcd;

  rrcd.havePhysicalConfigDedicated = false;

  rrcd.drbToReleaseList.push_back (drbid);

  LteRrcSap::RrcConnectionReconfiguration msg;

  msg.haveMeasConfig = false;

  msg.haveMobilityControlInfo = false;

  m_rrc->m_rrcSapUser->SendRrcConnectionReconfiguration (m_rnti, msg);

}

void 

UeManager::ScheduleRrcConnectionReconfiguration ()

{

  NS_LOG_FUNCTION (this);

  switch (m_state)

    {

    case INITIAL_RANDOM_ACCESS:

    case CONNECTION_SETUP:

    case CONNECTION_RECONFIGURATION:

    case CONNECTION_REESTABLISHMENT:

    case HANDOVER_JOINING:

    case HANDOVER_LEAVING:

      // a previous reconfiguration still ongoing, we need to wait for it to be finished

      m_pendingRrcConnectionReconfiguration = true;

      break;

    case CONNECTED_NORMALLY:      

      {

        m_pendingRrcConnectionReconfiguration = false;

        LteRrcSap::RrcConnectionReconfiguration msg = BuildRrcConnectionReconfiguration ();

        m_rrc->m_rrcSapUser->SendRrcConnectionReconfiguration (m_rnti, msg);

        SwitchToState (CONNECTION_RECONFIGURATION);

      }

      break;      

    default:

      NS_FATAL_ERROR ("method unexpected in state " << ToString (m_state));

      break;      

    }

}

void 

UeManager::SendHandoverCommand (LteRrcSap::RrcConnectionReconfiguration rcr)

{

  NS_LOG_FUNCTION (this);

  m_rrc->m_rrcSapUser->SendRrcConnectionReconfiguration (m_rnti, rcr);

  SwitchToState (HANDOVER_LEAVING);

}

LteRrcSap::RadioResourceConfigDedicated

UeManager::GetRadioResourceConfigForHandoverPreparationInfo ()

{

  NS_LOG_FUNCTION (this);

  return BuildRadioResourceConfigDedicated ();

}

LteRrcSap::RrcConnectionReconfiguration 

UeManager::GetHandoverCommand ()

{

  NS_LOG_FUNCTION (this);

  return BuildRrcConnectionReconfiguration ();

}

void

UeManager::SendData (uint8_t bid, Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this << p << (uint16_t) bid);

  LtePdcpSapProvider::TransmitPdcpSduParameters params;

  params.pdcpSdu = p;

  params.rnti = m_rnti;

  params.lcid = Bid2Lcid (bid);

  uint8_t drbid = Bid2Drbid (bid);

  LtePdcpSapProvider* pdcpSapProvider = GetDataRadioBearerInfo (drbid)->m_pdcp->GetLtePdcpSapProvider ();

  pdcpSapProvider->TransmitPdcpSdu (params);

}

std::vector<EpcX2Sap::ErabToBeSetupItem>   

UeManager::GetErabList ()

{

  NS_LOG_FUNCTION (this);

  std::vector<EpcX2Sap::ErabToBeSetupItem> ret;

  for (std::map <uint8_t, Ptr<LteDataRadioBearerInfo> >::iterator it =  m_drbMap.begin ();

       it != m_drbMap.end ();

       ++it)

    {

      EpcX2Sap::ErabToBeSetupItem etbsi;

      etbsi.erabId = it->second->m_epsBearerIdentity;

      etbsi.erabLevelQosParameters = it->second->m_epsBearer;

      etbsi.dlForwarding = false;

      etbsi.transportLayerAddress = it->second->m_transportLayerAddress;

      etbsi.gtpTeid = it->second->m_gtpTeid;

      ret.push_back (etbsi);      

    }

  return ret;

}

void 

UeManager::CompleteSetupUe (LteEnbRrcSapProvider::CompleteSetupUeParameters params)

{

  NS_LOG_FUNCTION (this);

  m_srb0->m_rlc->SetLteRlcSapUser (params.srb0SapUser);

  m_srb1->m_pdcp->SetLtePdcpSapUser (params.srb1SapUser);

}

void

UeManager::RecvRrcConnectionRequest (LteRrcSap::RrcConnectionRequest msg)

{

  NS_LOG_FUNCTION (this);

  switch (m_state)

    {

    case INITIAL_RANDOM_ACCESS:      

      {      

        m_imsi = msg.ueIdentity;      

        if (m_rrc->m_s1SapProvider != 0)

          {

            m_rrc->m_s1SapProvider->InitialUeMessage (m_imsi, m_rnti);

          }      

        LteRrcSap::RrcConnectionSetup msg2;

        msg2.rrcTransactionIdentifier = GetNewRrcTransactionIdentifier ();

        msg2.radioResourceConfigDedicated = BuildRadioResourceConfigDedicated ();

        m_rrc->m_rrcSapUser->SendRrcConnectionSetup (m_rnti, msg2);

        SwitchToState (CONNECTION_SETUP);

      }

      break;

    default:

      NS_FATAL_ERROR ("method unexpected in state " << ToString (m_state));

      break;      

    }

}

void

UeManager::RecvRrcConnectionSetupCompleted (LteRrcSap::RrcConnectionSetupCompleted msg)

{

  NS_LOG_FUNCTION (this);

  switch (m_state)

    {