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

/*

 * Copyright (c) 2011, 2012 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>

 */

#include <ns3/fatal-error.h>

#include <ns3/log.h>

#include <ns3/object-map.h>

#include <ns3/object-factory.h>

#include <ns3/node-list.h>

#include <ns3/node.h>

#include "lte-ue-rrc.h"

#include "lte-enb-rrc.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 "lte-radio-bearer-info.h"

#include "lte-as-sap.h"

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

NS_LOG_COMPONENT_DEFINE ("LteUeRrc");

namespace ns3 {

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

// CMAC SAP forwarder

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

class UeMemberLteUeCmacSapUser : public LteUeCmacSapUser

{

public:

  UeMemberLteUeCmacSapUser (LteUeRrc* rrc);

  virtual void SetTemporaryCellRnti (uint16_t rnti);

  virtual void NotifyRandomAccessSuccessful ();

  virtual void NotifyRandomAccessFailed ();

private:

  LteUeRrc* m_rrc;

};

UeMemberLteUeCmacSapUser::UeMemberLteUeCmacSapUser (LteUeRrc* rrc)

  : m_rrc (rrc)

{

}

void

UeMemberLteUeCmacSapUser::SetTemporaryCellRnti (uint16_t rnti)

{

  m_rrc->DoSetTemporaryCellRnti (rnti);

}

void

UeMemberLteUeCmacSapUser::NotifyRandomAccessSuccessful ()

{

  m_rrc->DoNotifyRandomAccessSuccessful ();

}

void

UeMemberLteUeCmacSapUser::NotifyRandomAccessFailed ()

{

  m_rrc->DoNotifyRandomAccessFailed ();

}

const char* g_ueRrcStateName[LteUeRrc::NUM_STATES] = 

  {

    "IDLE_CELL_SELECTION",

    "IDLE_WAIT_SYSTEM_INFO",

    "IDLE_CAMPED_NORMALLY",

    "IDLE_RANDOM_ACCESS",

    "IDLE_CONNECTING",

    "CONNECTED_NORMALLY",

    "CONNECTED_REESTABLISHING",

    "CONNECTED_HANDOVER"

  };

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

{

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

}

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

// ue RRC methods

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

NS_OBJECT_ENSURE_REGISTERED (LteUeRrc);

LteUeRrc::LteUeRrc ()

  : m_cphySapProvider (0),

    m_cmacSapProvider (0),

    m_rrcSapUser (0),

    m_macSapProvider (0),

    m_asSapUser (0),

    m_state (IDLE_CELL_SELECTION),

    m_imsi (0),

    m_rnti (0),

    m_cellId (0),

    m_useRlcSm (true),

    m_connectionPending (0),

    m_receivedMib (0),

    m_receivedSib2 (0)

{

  NS_LOG_FUNCTION (this);

  m_cphySapUser = new MemberLteUeCphySapUser<LteUeRrc> (this);

  m_cmacSapUser = new UeMemberLteUeCmacSapUser (this);

  m_rrcSapProvider = new MemberLteUeRrcSapProvider<LteUeRrc> (this);

  m_pdcpSapUser = new LtePdcpSpecificLtePdcpSapUser<LteUeRrc> (this);

  m_asSapProvider = new MemberLteAsSapProvider<LteUeRrc> (this);

}

LteUeRrc::~LteUeRrc ()

{

  NS_LOG_FUNCTION (this);

}

void

LteUeRrc::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  delete m_cphySapUser;

  delete m_cmacSapUser;

  delete m_pdcpSapUser;

  delete m_asSapProvider;

  m_drbMap.clear ();

}

TypeId

LteUeRrc::GetTypeId (void)

{

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

    .SetParent<Object> ()

    .AddConstructor<LteUeRrc> ()

    .AddAttribute ("DataRadioBearerMap", "List of UE RadioBearerInfo for Data Radio Bearers by LCID.",

                   ObjectMapValue (),

                   MakeObjectMapAccessor (&LteUeRrc::m_drbMap),

                   MakeObjectMapChecker<LteDataRadioBearerInfo> ())

    .AddAttribute ("CellId",

                   "Serving cell identifier",

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

                   MakeUintegerAccessor (&LteUeRrc::GetCellId),

                   MakeUintegerChecker<uint16_t> ())

    .AddAttribute ("C-RNTI",

                   "Cell Radio Network Temporary Identifier",

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

                   MakeUintegerAccessor (&LteUeRrc::GetRnti),

                   MakeUintegerChecker<uint16_t> ())

    .AddTraceSource ("StateTransition",

                     "fired upon every UE RRC state transition",

                     MakeTraceSourceAccessor (&LteUeRrc::m_stateTransitionCallback))

    ;

  return tid;

}

void

LteUeRrc::SetLteUeCphySapProvider (LteUeCphySapProvider * s)

{

  NS_LOG_FUNCTION (this << s);

  m_cphySapProvider = s;

}

LteUeCphySapUser*

LteUeRrc::GetLteUeCphySapUser ()

{

  NS_LOG_FUNCTION (this);

  return m_cphySapUser;

}

void

LteUeRrc::SetLteUeCmacSapProvider (LteUeCmacSapProvider * s)

{

  NS_LOG_FUNCTION (this << s);

  m_cmacSapProvider = s;

}

LteUeCmacSapUser*

LteUeRrc::GetLteUeCmacSapUser ()

{

  NS_LOG_FUNCTION (this);

  return m_cmacSapUser;

}

void

LteUeRrc::SetLteUeRrcSapUser (LteUeRrcSapUser * s)

{

  NS_LOG_FUNCTION (this << s);

  m_rrcSapUser = s;

}

LteUeRrcSapProvider*

LteUeRrc::GetLteUeRrcSapProvider ()

{

  NS_LOG_FUNCTION (this);

  return m_rrcSapProvider;

}

void

LteUeRrc::SetLteMacSapProvider (LteMacSapProvider * s)

{

  NS_LOG_FUNCTION (this << s);

  m_macSapProvider = s;

}

void

LteUeRrc::SetAsSapUser (LteAsSapUser* s)

{

  m_asSapUser = s;

}

LteAsSapProvider* 

LteUeRrc::GetAsSapProvider ()

{

  return m_asSapProvider;

}

void 

LteUeRrc::SetImsi (uint64_t imsi)

{

  NS_LOG_FUNCTION (this << imsi);

  m_imsi = imsi;

}

uint16_t

LteUeRrc::GetRnti () const

{

  NS_LOG_FUNCTION (this);

  return m_rnti;

}

uint16_t

LteUeRrc::GetCellId () const

{

  NS_LOG_FUNCTION (this);

  return m_cellId;

}

uint8_t 

LteUeRrc::GetUlBandwidth () const

{

  NS_LOG_FUNCTION (this);

  return m_ulBandwidth;

}

uint8_t 

LteUeRrc::GetDlBandwidth () const

{

  NS_LOG_FUNCTION (this);

  return m_dlBandwidth;

}

uint16_t 

LteUeRrc::GetDlEarfcn () const

{

  return m_dlEarfcn;

}

uint16_t 

LteUeRrc::GetUlEarfcn () const

{

  NS_LOG_FUNCTION (this);

  return m_ulEarfcn;

}

LteUeRrc::State

LteUeRrc::GetState (void)

{

  NS_LOG_FUNCTION (this);

  return m_state;

}

void

LteUeRrc::SetUseRlcSm (bool val) 

{

  NS_LOG_FUNCTION (this);

  m_useRlcSm = val;

}

void

LteUeRrc::DoStart (void)

{

  NS_LOG_FUNCTION (this);

  // setup the UE side of SRB0

  uint8_t lcid = 0;

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

  rlc->SetLteMacSapProvider (m_macSapProvider);

  rlc->SetRnti (m_rnti);

  rlc->SetLcId (lcid);

  m_srb0 = CreateObject<LteSignalingRadioBearerInfo> ();  

  m_srb0->m_rlc = rlc;

  m_srb0->m_srbIdentity = 1;

  // CCCH (LCID 0) is pre-configured, here is the hardcoded configuration:

  LteUeCmacSapProvider::LogicalChannelConfig lcConfig;

  lcConfig.priority = 0; // highest priority

  lcConfig.prioritizedBitRateKbps = 65535; // maximum

  lcConfig.bucketSizeDurationMs = 65535; // maximum

  lcConfig.logicalChannelGroup = 0; // all SRBs mapped to LCG 0

  m_cmacSapProvider->AddLc (lcid, lcConfig, rlc->GetLteMacSapUser ());

}

void

LteUeRrc::DoSendData (Ptr<Packet> packet, uint8_t bid)

{

  NS_LOG_FUNCTION (this << packet);

  uint8_t drbid = Bid2Drbid (bid);

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

  NS_ASSERT_MSG (it != m_drbMap.end (), "could not find bearer with drbid == " << drbid);

  LtePdcpSapProvider::TransmitPdcpSduParameters params;

  params.pdcpSdu = packet;

  params.rnti = m_rnti;

  params.lcid = it->second->m_logicalChannelIdentity;

  NS_LOG_LOGIC (this << " RNTI=" << m_rnti << " sending " << packet << "on DRBID " << (uint32_t) drbid << " (LCID" << params.lcid << ")" << " (" << packet->GetSize () << " bytes)");

  it->second->m_pdcp->GetLtePdcpSapProvider ()->TransmitPdcpSdu (params);  

}

void

LteUeRrc::DoDisconnect ()

{

  NS_LOG_FUNCTION (this);

  switch (m_state)

    {      

    case IDLE_CELL_SELECTION:

    case IDLE_CAMPED_NORMALLY:

      NS_LOG_INFO ("already disconnected");

      break;

    case IDLE_CONNECTING:

      NS_LOG_INFO ("aborting connection setup procedure");

      SwitchToState (IDLE_CAMPED_NORMALLY);

      break;

    case CONNECTED_NORMALLY:

    case CONNECTED_REESTABLISHING:

    case CONNECTED_HANDOVER:

      LeaveConnectedMode ();

      break;

    default:

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

      break;

    }

}

void

LteUeRrc::DoReceivePdcpSdu (LtePdcpSapUser::ReceivePdcpSduParameters params)

{

  NS_LOG_FUNCTION (this);

  m_asSapUser->RecvData (params.pdcpSdu);

}

void

LteUeRrc::DoSetTemporaryCellRnti (uint16_t rnti)

{

  NS_LOG_FUNCTION (this << rnti);

  m_rnti = rnti;

  m_rrcSapUser->Reestablish ();

  m_cphySapProvider->SetRnti (m_rnti);

}

void

LteUeRrc::DoNotifyRandomAccessSuccessful ()

{

  NS_LOG_FUNCTION (this << m_imsi << ToString (m_state));

  switch (m_state)

    {

    case IDLE_RANDOM_ACCESS:     

      {

        // we just received a RAR with a T-C-RNTI and an UL grant

        // send RRC connection request as message 3 of the random access procedure 

        SwitchToState (IDLE_CONNECTING);

        LteRrcSap::RrcConnectionRequest msg;

        msg.ueIdentity = m_imsi;

        m_rrcSapUser->SendRrcConnectionRequest (msg); 

      }

      break;

    case CONNECTED_HANDOVER:     

      {

        LteRrcSap::RrcConnectionReconfigurationCompleted msg;

        msg.rrcTransactionIdentifier = m_lastRrcTransactionIdentifier;

        m_rrcSapUser->SendRrcConnectionReconfigurationCompleted (msg);

        SwitchToState (CONNECTED_NORMALLY);

      }

      break;

    default:

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

      break; 

    } 

}

void

LteUeRrc::DoNotifyRandomAccessFailed ()

{

  NS_LOG_FUNCTION (this);

}

void 

LteUeRrc::DoForceCampedOnEnb (Ptr<LteEnbNetDevice> enbLteDevice, uint16_t cellId)

{

  NS_LOG_FUNCTION (this << cellId);

  m_cellId = cellId;

  m_dlEarfcn = enbLteDevice->GetDlEarfcn ();

  m_cphySapProvider->SyncronizeWithEnb (m_cellId, m_dlEarfcn); 

  SwitchToState (IDLE_WAIT_SYSTEM_INFO);

}

void 

LteUeRrc::DoConnect ()

{

  NS_LOG_FUNCTION (this);

  switch (m_state)

    {

    case IDLE_CELL_SELECTION:

    case IDLE_WAIT_SYSTEM_INFO:

      m_connectionPending = true;

      break;

    case IDLE_CAMPED_NORMALLY:     

      StartConnection ();

      break;

    case IDLE_RANDOM_ACCESS:

    case IDLE_CONNECTING:

      NS_LOG_WARN ("already connecting (state " << ToString (m_state) << ")");      

      break;

    case CONNECTED_NORMALLY:

    case CONNECTED_REESTABLISHING:

    case CONNECTED_HANDOVER:

      NS_LOG_WARN ("already connected (state " << ToString (m_state) << ")");      

      break;  

    default:

      NS_FATAL_ERROR ("cannot connect while in state " << ToString (m_state));

      break;

    }

}

// CPHY SAP methods

void 

LteUeRrc::DoRecvMasterInformationBlock (LteRrcSap::MasterInformationBlock msg)