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

/*

 * Copyright (c) 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: Lluis Parcerisa <lparcerisa@cttc.cat>

 */

#include "ns3/log.h"

#include "ns3/lte-rrc-header.h"

#include <stdio.h>

#include <sstream>

#define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331

#define MAX_EARFCN 65535

#define MAX_RAT_CAPABILITIES 8

#define MAX_SI_MESSAGE 32

#define MAX_SIB 32

#define MAX_REPORT_CONFIG_ID 32

#define MAX_OBJECT_ID 32

#define MAX_MEAS_ID 32

#define MAX_CELL_MEAS 32

#define MAX_CELL_REPORT 8

NS_LOG_COMPONENT_DEFINE ("RrcHeader");

namespace ns3 {

//////////////////// RrcAsn1Header class ///////////////////////////////

RrcAsn1Header::RrcAsn1Header ()

{

}

TypeId

RrcAsn1Header::GetTypeId (void)

{

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

    .SetParent<Header> ()

  ;

  return tid;

}

TypeId

RrcAsn1Header::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

int

RrcAsn1Header::GetMessageType ()

{

  return m_messageType;

}

void

RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbToAddModList) const

{

  // Serialize DRB-ToAddModList sequence-of

  SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1);

  // Serialize the elements in the sequence-of list

  std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin ();

  for (; it != drbToAddModList.end (); it++)

    {

      // Serialize DRB-ToAddMod sequence

      // 5 otional fields. Extension marker is present.

      std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5> ();

      drbToAddModListOptionalFieldsPresent.set (4,1); // eps-BearerIdentity present

      drbToAddModListOptionalFieldsPresent.set (3,0); // pdcp-Config not present

      drbToAddModListOptionalFieldsPresent.set (2,1); // rlc-Config present

      drbToAddModListOptionalFieldsPresent.set (1,1); // logicalChannelIdentity present

      drbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig present

      SerializeSequence (drbToAddModListOptionalFieldsPresent,true);

      // Serialize eps-BearerIdentity::=INTEGER (0..15)

      SerializeInteger (it->epsBearerIdentity,0,15);

      // Serialize drb-Identity ::= INTEGER (1..32)

      SerializeInteger (it->drbIdentity,1,32);

      switch (it->rlcConfig.choice)

        {

        case LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL:

          // Serialize rlc-Config choice

          SerializeChoice (4,1,true);

          // Serialize UL-UM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (2,0);  // sn-FieldLength

          // Serialize DL-UM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (2,0);  // sn-FieldLength

          SerializeEnum (32,0);  // t-Reordering

          break;

        case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL:

          // Serialize rlc-Config choice

          SerializeChoice (4,2,true);

          // Serialize UL-UM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (2,0);  // sn-FieldLength

          break;

        case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL:

          // Serialize rlc-Config choice

          SerializeChoice (4,3,true);

          // Serialize DL-UM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (2,0);  // sn-FieldLength

          SerializeEnum (32,0);  // t-Reordering

          break;

        case LteRrcSap::RlcConfig::AM:

        default:

          // Serialize rlc-Config choice

          SerializeChoice (4,0,true);

          // Serialize UL-AM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (64,0);  // t-PollRetransmit

          SerializeEnum (8,0);   // pollPDU

          SerializeEnum (16,0);  // pollByte

          SerializeEnum (8,0);   // maxRetxThreshold

          // Serialize DL-AM-RLC

          SerializeSequence (std::bitset<0> (),false);

          SerializeEnum (32,0);  // t-Reordering

          SerializeEnum (64,0);  // t-StatusProhibit

          break;

        }

      // Serialize logicalChannelIdentity ::=INTEGER (3..10)

      SerializeInteger (it->logicalChannelIdentity,3,10);

      // Serialize logicalChannelConfig

      SerializeLogicalChannelConfig (it->logicalChannelConfig);

    }

}

void

RrcAsn1Header::SerializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> srbToAddModList) const

{

  // Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod

  SerializeSequenceOf (srbToAddModList.size (),2,1);

  // Serialize the elements in the sequence-of list

  std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin ();

  for (; it != srbToAddModList.end (); it++)

    {

      // Serialize SRB-ToAddMod sequence

      // 2 otional fields. Extension marker is present.

      std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2> ();

      srbToAddModListOptionalFieldsPresent.set (1,0); // rlc-Config not present

      srbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig present

      SerializeSequence (srbToAddModListOptionalFieldsPresent,true);

      // Serialize srb-Identity ::= INTEGER (1..2)

      SerializeInteger (it->srbIdentity,1,2);

      // Serialize logicalChannelConfig choice

      // 2 options, selected option 0 (var "explicitValue", of type LogicalChannelConfig)

      SerializeChoice (2,0,false);

      // Serialize LogicalChannelConfig 

      SerializeLogicalChannelConfig (it->logicalChannelConfig);

    }

}

void

RrcAsn1Header::SerializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig logicalChannelConfig) const

{

  // Serialize LogicalChannelConfig sequence

  // 1 optional field (ul-SpecificParameters), which is present. Extension marker present.

  SerializeSequence (std::bitset<1> (1),true);

  // Serialize ul-SpecificParameters sequence

  // 1 optional field (logicalChannelGroup), which is present. No extension marker.

  SerializeSequence (std::bitset<1> (1),false);

  // Serialize priority ::= INTEGER (1..16)

  SerializeInteger (logicalChannelConfig.priority,1,16);

  // Serialize prioritisedBitRate

  int prioritizedBitRate;

  switch (logicalChannelConfig.prioritizedBitRateKbps)

    {

    case 0:

      prioritizedBitRate = 0;

      break;

    case 8:

      prioritizedBitRate = 1;

      break;

    case 16:

      prioritizedBitRate = 2;

      break;

    case 32:

      prioritizedBitRate = 3;

      break;

    case 64:

      prioritizedBitRate = 4;

      break;

    case 128:

      prioritizedBitRate = 5;

      break;

    case 256:

      prioritizedBitRate = 6;

      break;

    default:

      prioritizedBitRate = 7;          // Infinity

    }

  SerializeEnum (16,prioritizedBitRate);

  // Serialize bucketSizeDuration

  int bucketSizeDuration;

  switch (logicalChannelConfig.bucketSizeDurationMs)

    {

    case 50:

      bucketSizeDuration = 0;

      break;

    case 100:

      bucketSizeDuration = 1;

      break;

    case 150:

      bucketSizeDuration = 2;

      break;

    case 300:

      bucketSizeDuration = 3;

      break;

    case 500:

      bucketSizeDuration = 4;

      break;

    case 1000:

      bucketSizeDuration = 5;

      break;

    default:

      bucketSizeDuration = 5;

    }

  SerializeEnum (8,bucketSizeDuration);

  // Serialize logicalChannelGroup ::= INTEGER (0..3)

  SerializeInteger (logicalChannelConfig.logicalChannelGroup,0,3);

}

void

RrcAsn1Header::SerializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedicated physicalConfigDedicated) const

{

  // Serialize PhysicalConfigDedicated Sequence

  std::bitset<10> optionalFieldsPhysicalConfigDedicated;

  optionalFieldsPhysicalConfigDedicated.set (9,0);  // pdsch-ConfigDedicated not present

  optionalFieldsPhysicalConfigDedicated.set (8,0);  // pucch-ConfigDedicated not present

  optionalFieldsPhysicalConfigDedicated.set (7,0);  // pusch-ConfigDedicated not present

  optionalFieldsPhysicalConfigDedicated.set (6,0);  // uplinkPowerControlDedicated not present

  optionalFieldsPhysicalConfigDedicated.set (5,0);  // tpc-PDCCH-ConfigPUCCH not present

  optionalFieldsPhysicalConfigDedicated.set (4,0);  // tpc-PDCCH-ConfigPUSCH not present

  optionalFieldsPhysicalConfigDedicated.set (3,0);  // cqi-ReportConfig not present

  optionalFieldsPhysicalConfigDedicated.set (2,physicalConfigDedicated.haveSoundingRsUlConfigDedicated);  // soundingRS-UL-ConfigDedicated

  optionalFieldsPhysicalConfigDedicated.set (1,physicalConfigDedicated.haveAntennaInfoDedicated);  // antennaInfo

  optionalFieldsPhysicalConfigDedicated.set (0,0);  // schedulingRequestConfig not present

  SerializeSequence (optionalFieldsPhysicalConfigDedicated,true);

  if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated)

    {

      // Serialize SoundingRS-UL-ConfigDedicated choice:

      switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type)

        {

        case LteRrcSap::SoundingRsUlConfigDedicated::RESET:

          SerializeChoice (2,0,false);

          SerializeNull ();

          break;

        case LteRrcSap::SoundingRsUlConfigDedicated::SETUP:

        default:

          // 2 options, selected: 1 (setup)

          SerializeChoice (2,1,false);

          // Serialize setup sequence

          // 0 optional / default fields, no extension marker.

          SerializeSequence (std::bitset<0> (),false);

          // Serialize srs-Bandwidth

          SerializeEnum (4,physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth);

          // Serialize  srs-HoppingBandwidth

          SerializeEnum (4,0);

          // Serialize freqDomainPosition

          SerializeInteger (0,0,23);

          // Serialize duration

          SerializeBoolean (false);

          // Serialize srs-ConfigIndex

          SerializeInteger (physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex,0,1023);

          // Serialize transmissionComb

          SerializeInteger (0,0,1);

          // Serialize cyclicShift

          SerializeEnum (8,0);

          break;

        }

    }

  if (physicalConfigDedicated.haveAntennaInfoDedicated)

    {

      // Serialize antennaInfo choice

      // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated")

      SerializeChoice (2,0,false);

      // Serialize AntennaInfoDedicated sequence

      // 1 optional parameter, not present. No extension marker.

      SerializeSequence (std::bitset<1> (0),false);

      // Serialize transmissionMode

      // Assuming the value in the struct is the enum index

      SerializeEnum (8,physicalConfigDedicated.antennaInfo.transmissionMode);

      // Serialize ue-TransmitAntennaSelection choice

      SerializeChoice (2,0,false);

      // Serialize release

      SerializeNull ();

    }

}

void

RrcAsn1Header::SerializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceConfigDedicated radioResourceConfigDedicated) const

{

  bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.empty ();

  bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.empty ();

  bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseList.empty ();

  // 6 optional fields. Extension marker is present.

  std::bitset<6> optionalFieldsPresent = std::bitset<6> ();

  optionalFieldsPresent.set (5,isSrbToAddModListPresent);  // srb-ToAddModList present

  optionalFieldsPresent.set (4,isDrbToAddModListPresent);  // drb-ToAddModList present

  optionalFieldsPresent.set (3,isDrbToReleaseListPresent);  // drb-ToReleaseList present

  optionalFieldsPresent.set (2,0);  // mac-MainConfig not present

  optionalFieldsPresent.set (1,0);  // sps-Config not present

  optionalFieldsPresent.set (0,(radioResourceConfigDedicated.havePhysicalConfigDedicated) ? 1 : 0);

  SerializeSequence (optionalFieldsPresent,true);

  // Serialize srbToAddModList

  if (isSrbToAddModListPresent)

    {

      SerializeSrbToAddModList (radioResourceConfigDedicated.srbToAddModList);

    }

  // Serialize drbToAddModList

  if (isDrbToAddModListPresent)

    {

      SerializeDrbToAddModList (radioResourceConfigDedicated.drbToAddModList);

    }

  // Serialize drbToReleaseList

  if (isDrbToReleaseListPresent)

    {

      SerializeSequenceOf (radioResourceConfigDedicated.drbToReleaseList.size (),MAX_DRB,1);

      std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToReleaseList.begin ();

      for (; it != radioResourceConfigDedicated.drbToReleaseList.end (); it++)

        {

          // DRB-Identity ::= INTEGER (1..32)

          SerializeInteger (*it,1,32);

        }

    }

  if (radioResourceConfigDedicated.havePhysicalConfigDedicated)

    {

      SerializePhysicalConfigDedicated (radioResourceConfigDedicated.physicalConfigDedicated);

    }

}

void

RrcAsn1Header::SerializeSystemInformationBlockType1 (LteRrcSap::SystemInformationBlockType1 systemInformationBlockType1) const

{

  // 3 optional fields, no extension marker.

  std::bitset<3> sysInfoBlk1Opts;

  sysInfoBlk1Opts.set (2,0); // p-Max absent

  sysInfoBlk1Opts.set (1,0); // tdd-Config absent

  sysInfoBlk1Opts.set (0,0); // nonCriticalExtension absent

  SerializeSequence (sysInfoBlk1Opts,false);

  // Serialize cellAccessRelatedInfo

  // 1 optional field (csgIdentity) which is present, no extension marker.

  SerializeSequence (std::bitset<1> (1),false);

  // Serialize plmn-IdentityList

  SerializeSequenceOf (1,6,1);

  // PLMN-IdentityInfo 

  SerializeSequence (std::bitset<0> (),false);

  SerializePlmnIdentity (systemInformationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity);

  // Serialize trackingAreaCode

  SerializeBitstring (std::bitset<16> (0));

  // Serialize cellIdentity

  SerializeBitstring (std::bitset<28> (systemInformationBlockType1.cellAccessRelatedInfo.cellIdentity));

  // Serialize cellBarred

  SerializeEnum (2,0);

  // Serialize intraFreqReselection

  SerializeEnum (2,0);

  // Serialize csg-Indication

  SerializeBoolean (systemInformationBlockType1.cellAccessRelatedInfo.csgIndication);

  // Serialize csg-Identity

  SerializeBitstring (std::bitset<27> (systemInformationBlockType1.cellAccessRelatedInfo.csgIdentity));

  // Serialize cellSelectionInfo

  SerializeSequence (std::bitset<1> (0),false);

  // Serialize q-RxLevMin

  SerializeInteger (-50,-70,-22);

  // Serialize freqBandIndicator

  SerializeInteger (1,1,64);

  // Serialize schedulingInfoList

  SerializeSequenceOf (1,MAX_SI_MESSAGE,1);

  // SchedulingInfo

  SerializeSequence (std::bitset<0> (),false);

  // si-Periodicity

  SerializeEnum (7,0);

  // sib-MappingInfo

  SerializeSequenceOf (0,MAX_SIB - 1,0);

  // Serialize si-WindowLength

  SerializeEnum (7,0);

  // Serialize systemInfoValueTag

  SerializeInteger (0,0,31);

}

void

RrcAsn1Header::SerializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfigCommon radioResourceConfigCommon) const

{

  // 9 optional fields. Extension marker yes.

  std::bitset<9> rrCfgCmmOpts;

  rrCfgCmmOpts.set (8,1); // rach-ConfigCommon is present

  rrCfgCmmOpts.set (7,0); // pdsch-ConfigCommon not present

  rrCfgCmmOpts.set (6,0); // phich-Config not present

  rrCfgCmmOpts.set (5,0); // pucch-ConfigCommon  not present

  rrCfgCmmOpts.set (4,0); // soundingRS-UL-ConfigCommon not present

  rrCfgCmmOpts.set (3,0); // uplinkPowerControlCommon not present

  rrCfgCmmOpts.set (2,0); // antennaInfoCommon not present

  rrCfgCmmOpts.set (1,0); // p-Max not present

  rrCfgCmmOpts.set (0,0); // tdd-Config not present

  SerializeSequence (rrCfgCmmOpts,true);

  if (rrCfgCmmOpts[8])

    {

      // Serialize RACH-ConfigCommon

      SerializeRachConfigCommon (radioResourceConfigCommon.rachConfigCommon);

    }

  // Serialize PRACH-Config

  // 1 optional, 0 extension marker.

  SerializeSequence (std::bitset<1> (0),false);

  // Serialize PRACH-Config rootSequenceIndex

  SerializeInteger (0,0,1023);

  // Serialize PUSCH-ConfigCommon

  SerializeSequence (std::bitset<0> (),false);

  // Serialize pusch-ConfigBasic

  SerializeSequence (std::bitset<0> (),false);

  SerializeInteger (1,1,4);

  SerializeEnum (2,0);

  SerializeInteger (0,0,98);

  SerializeBoolean (false);

  // Serialize UL-ReferenceSignalsPUSCH

  SerializeSequence (std::bitset<0> (),false);

  SerializeBoolean (false);

  SerializeInteger (0,0,29);

  SerializeBoolean (false);

  SerializeInteger (4,0,7);

  // Serialize UL-CyclicPrefixLength

  SerializeEnum (2,0);

}

void

RrcAsn1Header::SerializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceConfigCommonSib radioResourceConfigCommonSib) const

{

  SerializeSequence (std::bitset<0> (0),true);

  // rach-ConfigCommon

  SerializeRachConfigCommon (radioResourceConfigCommonSib.rachConfigCommon);

  // bcch-Config 

  SerializeSequence (std::bitset<0> (0),false);

  SerializeEnum (4,0); // modificationPeriodCoeff

  // pcch-Config 

  SerializeSequence (std::bitset<0> (0),false);