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

/*

 * Copyright (c) 2013 Budiarto Herman

 *

 * 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: Budiarto Herman <budiarto.herman@magister.fi>

 *

 */

#include <ns3/test.h>

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

#include <ns3/simulator.h>

#include <ns3/log.h>

#include <ns3/boolean.h>

#include <ns3/integer.h>

#include <ns3/mobility-helper.h>

#include <ns3/lte-helper.h>

#include <ns3/epc-helper.h>

#include <ns3/internet-stack-helper.h>

#include <ns3/point-to-point-helper.h>

#include <ns3/ipv4-address-helper.h>

#include <ns3/ipv4-static-routing-helper.h>

#include <ns3/node-container.h>

#include <ns3/net-device-container.h>

#include <ns3/ipv4-interface-container.h>

NS_LOG_COMPONENT_DEFINE ("LteRrcConnEstablishmentTest");

namespace ns3 {

/**

 * \brief TODO

 */

class LteRrcConnEstablishmentTestCase : public TestCase

{

public:

  /**

   * \brief TODO

   */

  LteRrcConnEstablishmentTestCase (uint16_t nUe, double distance,

                                   int64_t rngRun);

  virtual ~LteRrcConnEstablishmentTestCase ();

private:

  virtual void DoRun ();

  void DlSchedulingCallback (std::string context, uint32_t frameNo,

                             uint32_t subframeNo, uint16_t rnti,

                             uint8_t mcs1, uint16_t tbSize1,

                             uint8_t mcs2, uint16_t tbSize2);

  void UlSchedulingCallback (std::string context, uint32_t frameNo,

                             uint32_t subframeNo, uint16_t rnti,

                             uint8_t mcs, uint16_t tbSize);

  void StateTransitionCallback (std::string context, uint64_t imsi,

                                uint16_t cellId, uint16_t rnti,

                                LteUeRrc::State oldState, LteUeRrc::State newState);

  void ConnectionEstablishedCallback (std::string context, uint64_t imsi,

                                      uint16_t cellId, uint16_t rnti);

  uint16_t m_nUe;

  double m_distance;

  int64_t m_rngRun;

  std::vector<LteUeRrc::State> m_lastState;

};

LteRrcConnEstablishmentTestCase::LteRrcConnEstablishmentTestCase (

  uint16_t nUe, double distance, int64_t rngRun)

  : TestCase (""),

    m_nUe (nUe),

    m_distance (distance),

    m_rngRun (rngRun)

{

  NS_LOG_FUNCTION (this << GetName ());

  m_lastState.resize (nUe, LteUeRrc::NUM_STATES);

}

LteRrcConnEstablishmentTestCase::~LteRrcConnEstablishmentTestCase ()

{

  NS_LOG_FUNCTION (this << GetName ());

}

void

LteRrcConnEstablishmentTestCase::DoRun ()

{

  NS_LOG_FUNCTION (this << GetName ());

  Config::SetGlobal ("RngRun", IntegerValue (m_rngRun));

  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

  lteHelper->SetAttribute ("PathlossModel",

                           StringValue ("ns3::FriisSpectrumPropagationLossModel"));

  lteHelper->SetAttribute ("UseIdealRrc", BooleanValue (false));

//  Ptr<EpcHelper> epcHelper;

//  epcHelper = CreateObject<EpcHelper> ();

//  lteHelper->SetEpcHelper (epcHelper);

  // Create Nodes

  NodeContainer enbNodes;

  enbNodes.Create (4);

  NodeContainer ueNodes;

  ueNodes.Create (m_nUe);

  // Assign nodes to position

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

  positionAlloc->Add (Vector (0, 0, 0));

  positionAlloc->Add (Vector (m_distance, 0, 0));

  positionAlloc->Add (Vector (0, m_distance, 0));

  positionAlloc->Add (Vector (m_distance, m_distance, 0));

  for (uint16_t i = 0; i < m_nUe; i++)

    {

      positionAlloc->Add (Vector (0.6 * m_distance, 0.6 * m_distance, 0));

    }

  MobilityHelper mobility;

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.SetPositionAllocator (positionAlloc);

  mobility.Install (enbNodes);

  mobility.Install (ueNodes);

  // Create Devices and install them in the Nodes (eNB and UE)

  int64_t stream = 1;

  NetDeviceContainer enbDevs;

  enbDevs = lteHelper->InstallEnbDevice (enbNodes);

  stream += lteHelper->AssignStreams (enbDevs, stream);

  NetDeviceContainer ueDevs;

  ueDevs = lteHelper->InstallUeDevice (ueNodes);

  stream += lteHelper->AssignStreams (ueDevs, stream);

//  // Create P-GW node

//  Ptr<Node> pgw = epcHelper->GetPgwNode ();

//

//  // Create a single RemoteHost

//  NodeContainer remoteHostContainer;

//  remoteHostContainer.Create (1);

//  Ptr<Node> remoteHost = remoteHostContainer.Get (0);

//  InternetStackHelper internet;

//  internet.Install (remoteHostContainer);

//

//  // Create the Internet

//  PointToPointHelper p2ph;

//  p2ph.SetDeviceAttribute ("DataRate", DataRateValue (DataRate ("100Gb/s")));

//  p2ph.SetDeviceAttribute ("Mtu", UintegerValue (1500));

//  p2ph.SetChannelAttribute ("Delay", TimeValue (Seconds (0.010)));

//  NetDeviceContainer internetDevices = p2ph.Install (pgw, remoteHost);

//  Ipv4AddressHelper ipv4h;

//  ipv4h.SetBase ("1.0.0.0", "255.0.0.0");

//  Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign (internetDevices);

//

//  // Routing of the Internet Host (towards the LTE network)

//  Ipv4StaticRoutingHelper ipv4RoutingHelper;

//  Ptr<Ipv4StaticRouting> remoteHostStaticRouting = ipv4RoutingHelper.GetStaticRouting (remoteHost->GetObject<Ipv4> ());

//  remoteHostStaticRouting->AddNetworkRouteTo (Ipv4Address ("7.0.0.0"), Ipv4Mask ("255.0.0.0"), 1);

//

//  // Install the IP stack on the UEs

//  internet.Install (ueNodes);

//  Ipv4InterfaceContainer ueIpIfaces;

//  ueIpIfaces = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueDevs));

//

//  // Assign IP address to UEs

//  for (uint32_t u = 0; u < ueNodes.GetN (); ++u)

//    {

//      Ptr<Node> ueNode = ueNodes.Get (u);

//      // Set the default gateway for the UE

//      Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting (ueNode->GetObject<Ipv4> ());

//      ueStaticRouting->SetDefaultRoute (epcHelper->GetUeDefaultGatewayAddress (), 1);

//    }

  // Connect to trace sources in UEs

  Config::Connect ("/NodeList/*/DeviceList/*/LteEnbMac/DlScheduling",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::DlSchedulingCallback,

                                 this));

  Config::Connect ("/NodeList/*/DeviceList/*/LteEnbMac/UlScheduling",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::UlSchedulingCallback,

                                 this));

  Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/StateTransition",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::StateTransitionCallback,

                                 this));

  Config::Connect ("/NodeList/*/DeviceList/*/LteUeRrc/ConnectionEstablished",

                   MakeCallback (&LteRrcConnEstablishmentTestCase::ConnectionEstablishedCallback,

                                 this));

  // Enable Idle mode cell selection

  lteHelper->Attach (ueDevs, enbDevs.Get (0));

  // Activate an EPS bearer

  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;

  EpsBearer bearer (q);

  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);

//  lteHelper->EnableTraces ();

//  Ptr<RadioBearerStatsCalculator> rlcStats = lteHelper->GetRlcStats ();

//  rlcStats->SetAttribute ("EpochDuration", TimeValue (MilliSeconds (1)));

//  Ptr<RadioBearerStatsCalculator> pdcpStats = lteHelper->GetPdcpStats ();

//  pdcpStats->SetAttribute ("EpochDuration", TimeValue (MilliSeconds (1)));

  // Run simulation

  Simulator::Stop (MilliSeconds (50));

  Simulator::Run ();

  NS_LOG_INFO ("Simulation ends");

  for (uint16_t i = 0; i < m_nUe; i++)

    {

      NS_TEST_ASSERT_MSG_EQ (m_lastState.at (i), LteUeRrc::CONNECTED_NORMALLY,

                             "UE " << i << " is not at CONNECTED_NORMALLY state");

    }

  Simulator::Destroy ();

} // end of void LteRrcConnEstablishmentTestCase::DoRun ()

void

LteRrcConnEstablishmentTestCase::DlSchedulingCallback (

  std::string context, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

  uint8_t mcs1, uint16_t tbSize1, uint8_t mcs2, uint16_t tbSize2)

{

  NS_LOG_FUNCTION (this << frameNo << subframeNo << rnti

                        << (uint16_t) mcs1 << tbSize1

                        << (uint16_t) mcs2 << tbSize2);

}

void

LteRrcConnEstablishmentTestCase::UlSchedulingCallback (

  std::string context, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

  uint8_t mcs, uint16_t tbSize)

{

  NS_LOG_FUNCTION (this << frameNo << subframeNo << rnti

                        << (uint16_t) mcs << tbSize);

}

void

LteRrcConnEstablishmentTestCase::StateTransitionCallback (

  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti,

  LteUeRrc::State oldState, LteUeRrc::State newState)

{

  NS_LOG_FUNCTION (this << imsi << cellId << rnti << oldState << newState);

  m_lastState.at (imsi - 1) = newState;

}

void

LteRrcConnEstablishmentTestCase::ConnectionEstablishedCallback (

  std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)

{

  NS_LOG_FUNCTION (this << imsi << cellId);

}

/**

 * \brief TODO

 *

 * \sa ns3::LteRrcConnEstablishmentTestCase

 */

class LteRrcConnEstablishmentTestSuite : public TestSuite

{

public:

  LteRrcConnEstablishmentTestSuite ();

};

LteRrcConnEstablishmentTestSuite::LteRrcConnEstablishmentTestSuite ()

  : TestSuite ("lte-rrc-conn-establishment", SYSTEM)

{

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_FUNCTION);

//  LogComponentEnable ("LteRrcConnEstablishmentTest", LOG_INFO);

//  LogComponentEnable ("LteSpectrumPhy", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteSpectrumPhy", LOG_DEBUG);

////  LogComponentEnable ("LteEnbMac", LOG_PREFIX_ALL);

////  LogComponentEnable ("LteEnbMac", LOG_FUNCTION);

//  LogComponentEnable ("LteUeMac", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteUeMac", LOG_LOGIC);

//  LogComponentEnable ("LteUeMac", LOG_DEBUG);

//  //LogComponentEnable ("LteUeMac", LOG_FUNCTION);

////  LogComponentEnable ("PfFfMacScheduler", LOG_PREFIX_ALL);

////  LogComponentEnable ("PfFfMacScheduler", LOG_DEBUG);

////  LogComponentEnable ("PfFfMacScheduler", LOG_FUNCTION);

//  LogComponentEnable ("LteRlcTm", LOG_PREFIX_ALL);

//  LogComponentEnable ("LteRlcTm", LOG_FUNCTION);

//  LogComponentEnable ("LteRlcTm", LOG_LOGIC);

//  LogComponentEnable ("LteRlcTm", LOG_WARN);

  for (int64_t i = 2; i <= 3; i++)

    {

      AddTestCase (new LteRrcConnEstablishmentTestCase (1, 100, i),

                   TestCase::QUICK);

    }

}

static LteRrcConnEstablishmentTestSuite g_lteRrcConnEstablishmentTestSuite;

} // end of namespace ns3

        'test/test-lte-rrc-conn-establishment.cc',