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

    "CONNECTION_REJECTED",

    "CONNECTED_NORMALLY",

    "CONNECTION_RECONFIGURATION",

    "CONNECTION_REESTABLISHMENT",

    "HANDOVER_PREPARATION",

    "HANDOVER_JOINING",

    "HANDOVER_PATH_SWITCH",

    "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),

    m_needTransmissionModeConfiguration (false)

{ 

  NS_LOG_FUNCTION (this);

}

void

UeManager::DoStart ()

{

  NS_LOG_FUNCTION (this);

  m_drbPdcpSapUser = 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_physicalConfigDedicated.soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRsUlConfigDedicated::SETUP;

  m_physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth = 0;

  m_rrc->m_cmacSapProvider->AddUe (m_rnti);

  m_rrc->m_cphySapProvider->AddUe (m_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 = 0;

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

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

  req.m_transmissionMode = m_physicalConfigDedicated.antennaInfo.transmissionMode;

  m_rrc->m_cmacSapProvider->UeUpdateConfigurationReq (req);

  // configure PHY

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

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

  // schedule this UeManager instance to be deleted if the UE does not give any sign of life within a reasonable time

  Time maxConnectionDelay;

  switch (m_state)

    {

    case INITIAL_RANDOM_ACCESS:

      // must account for reception of RAR and transmission of RRC CONNECTION REQUEST over UL GRANT

      maxConnectionDelay = MilliSeconds (15); 

      break;

    case HANDOVER_JOINING:

      // must account for reception of X2 HO REQ ACK by source eNB,

      // transmission of the Handover Command, and

      // non-contention-based random access

      maxConnectionDelay = MilliSeconds (50); 

      break;      

    default:

      NS_FATAL_ERROR ("unspecified maxConnectionDelay for state " << ToString (m_state));

      break;      

    }  

  m_connectionTimeout = Simulator::Schedule (maxConnectionDelay, &LteEnbRrc::ConnectionTimeout, m_rrc, m_rnti);

}

UeManager::~UeManager (void)

{

}

void

UeManager::DoDispose ()

{

  delete m_drbPdcpSapUser;

  // delete eventual X2-U TEIDs

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

       it != m_drbMap.end ();

       ++it)

    {

      m_rrc->m_x2uTeidInfoMap.erase (it->second->m_gtpTeid);

}

TypeId UeManager::GetTypeId (void)

{

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

    .SetParent<Object> ()

    .AddConstructor<UeManager> ()

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

                   ObjectMapValue (),

                   MakeObjectMapAccessor (&UeManager::m_drbMap),

                   MakeObjectMapChecker<LteDataRadioBearerInfo> ())

    .AddAttribute ("Srb0", "SignalingRadioBearerInfo for SRB0",

                   PointerValue (),

                   MakePointerAccessor (&UeManager::m_srb0),

                   MakePointerChecker<LteSignalingRadioBearerInfo> ())

    .AddAttribute ("Srb1", "SignalingRadioBearerInfo for SRB1",

                   PointerValue (),

                   MakePointerAccessor (&UeManager::m_srb1),

                   MakePointerChecker<LteSignalingRadioBearerInfo> ())

    .AddAttribute ("C-RNTI",

                   "Cell Radio Network Temporary Identifier",

                   TypeId::ATTR_GET, // read-only attribute

                   UintegerValue (0), // unused, read-only attribute

                   MakeUintegerAccessor (&UeManager::m_rnti),

                   MakeUintegerChecker<uint16_t> ())

    .AddTraceSource ("StateTransition",

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

                     MakeTraceSourceAccessor (&UeManager::m_stateTransitionTrace))

    ;

  return tid;

}

void 

UeManager::SetSource (uint16_t sourceCellId, uint16_t sourceX2apId)

{

  m_sourceX2apId = sourceX2apId;

  m_sourceCellId = sourceCellId;

}

void 

UeManager::SetImsi (uint64_t imsi)

{

  m_imsi = imsi;

}

void

UeManager::SetupDataRadioBearer (EpsBearer bearer, uint8_t bearerId, 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);  

  NS_ASSERT_MSG ( bearerId == 0 || bid == bearerId, "bearer ID mismatch (" << (uint32_t) bid << " != " << (uint32_t) bearerId << ", the assumption that ID are allocated in the same way by MME and RRC is not valid any more");

  drbInfo->m_epsBearerIdentity = bid;

  drbInfo->m_drbIdentity = drbid;

  drbInfo->m_logicalChannelIdentity = lcid;

  drbInfo->m_gtpTeid = gtpTeid;

  drbInfo->m_transportLayerAddress = transportLayerAddress;

  if (m_state == HANDOVER_JOINING)

    {

      // setup TEIDs for receiving data eventually forwarded over X2-U 

      LteEnbRrc::X2uTeidInfo x2uTeidInfo;

      x2uTeidInfo.rnti = m_rnti;

      x2uTeidInfo.drbid = drbid;

      std::pair<std::map<uint32_t, LteEnbRrc::X2uTeidInfo>::iterator, bool>

        ret = m_rrc->m_x2uTeidInfoMap.insert (std::pair<uint32_t, LteEnbRrc::X2uTeidInfo> (gtpTeid, x2uTeidInfo));

      NS_ASSERT_MSG (ret.second == true, "overwriting a pre-existing entry in m_x2uTeidInfoMap");

    }

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

      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;

  ScheduleRrcConnectionReconfiguration ();

}

void

UeManager::RecordDataRadioBearersToBeStarted ()

{

  NS_LOG_FUNCTION (this << (uint32_t) m_rnti);

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

       it != m_drbMap.end ();

       ++it)

    {

      m_drbsToBeStarted.push_back (it->first);

    }    

}

void

UeManager::StartDataRadioBearers ()

{

  NS_LOG_FUNCTION (this << (uint32_t) m_rnti);

  for (std::list <uint8_t>::iterator drbIdIt = m_drbsToBeStarted.begin ();

       drbIdIt != m_drbsToBeStarted.end ();

       ++drbIdIt)

    {

      std::map <uint8_t, Ptr<LteDataRadioBearerInfo> >::iterator drbIt = m_drbMap.find (*drbIdIt);

      NS_ASSERT (drbIt != m_drbMap.end ());

      drbIt->second->m_rlc->Start ();

      if (drbIt->second->m_pdcp)

        {

          drbIt->second->m_pdcp->Start ();

        }

    }

  m_drbsToBeStarted.clear ();

}

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

  // first delete eventual X2-U TEIDs

  m_rrc->m_x2uTeidInfoMap.erase (it->second->m_gtpTeid);

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

    case HANDOVER_JOINING:

    case HANDOVER_LEAVING:

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

      m_pendingRrcConnectionReconfiguration = true;