/* -*-  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: Manuel Requena <manuel.requena@cttc.es>

 */

#include "ns3/simulator.h"

#include "ns3/log.h"

#include "ns3/string.h"

#include "ns3/double.h"

#include "ns3/mobility-helper.h"

#include "ns3/lte-helper.h"

#include "ns3/lte-ue-phy.h"

#include "ns3/lte-ue-net-device.h"

#include "ns3/lte-test-link-adaptation.h"

#include "lte-test-sinr-chunk-processor.h"

NS_LOG_COMPONENT_DEFINE ("LteLinkAdaptationTest");

using namespace ns3;

/**

 * Test 1.3 Link Adaptation

 */

void

LteTestDlSchedulingCallback (LteLinkAdaptationTestCase *testcase, std::string path,

                             uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

                             uint8_t mcsTb1, uint16_t sizeTb1, uint8_t mcsTb2, uint16_t sizeTb2)

{

  testcase->DlScheduling (frameNo, subframeNo, rnti, mcsTb1, sizeTb1, mcsTb2, sizeTb2);

}

/**

 * TestSuite

 */

LteLinkAdaptationTestSuite::LteLinkAdaptationTestSuite ()

  : TestSuite ("lte-link-adaptation", SYSTEM)

{

  NS_LOG_INFO ("Creating LteLinkAdaptionTestSuite");

  struct SnrEfficiencyMcs

  {

    double  snrDb;

    double  efficiency;

    int  mcsIndex;

  };

  /**

    * Test vectors: SNRDB, Spectral Efficiency, MCS index

    * From XXX

    */

  SnrEfficiencyMcs snrEfficiencyMcs[] = {

    { -5.00000,  0.08024,        -1},

    { -4.00000,  0.10030,        -1},

    { -3.00000,  0.12518,        -1},

    { -2.00000,  0.15589,        0},

    { -1.00000,  0.19365,        0},

    { 0.00000,   0.23983,        2},

    { 1.00000,   0.29593,        2},

    { 2.00000,   0.36360,        2},

    { 3.00000,   0.44451,        4},

    { 4.00000,   0.54031,        4},

    { 5.00000,   0.65251,        6},

    { 6.00000,   0.78240,        6},

    { 7.00000,   0.93086,        8},

    { 8.00000,   1.09835,        8},

    { 9.00000,   1.28485,        10},

    { 10.00000,  1.48981,        12},

    { 11.00000,  1.71229,        12},

    { 12.00000,  1.95096,        14},

    { 13.00000,  2.20429,        14},

    { 14.00000,  2.47062,        16},

    { 15.00000,  2.74826,        18},

    { 16.00000,  3.03560,        18},

    { 17.00000,  3.33115,        20},

    { 18.00000,  3.63355,        20},

    { 19.00000,  3.94163,        22},

    { 20.00000,  4.25439,        22},

    { 21.00000,  4.57095,        24},

    { 22.00000,  4.89060,        24},

    { 23.00000,  5.21276,        26},

    { 24.00000,  5.53693,        26},

    { 25.00000,  5.86271,        28},

    { 26.00000,  6.18980,        28},

    { 27.00000,  6.51792,        28},

    { 28.00000,  6.84687,        28},

    { 29.00000,  7.17649,        28},

    { 30.00000,  7.50663,        28},

  };

  int numOfTests = sizeof (snrEfficiencyMcs) / sizeof (SnrEfficiencyMcs);

  double txPowerDbm = 30; // default eNB TX power over whole bandwdith

  double ktDbm = -174;    // reference LTE noise PSD

  double noisePowerDbm = ktDbm + 10 * log10 (25 * 180000); // corresponds to kT*bandwidth in linear units

  double receiverNoiseFigureDb = 9.0; // default UE noise figure

  for ( int i = 0 ; i < numOfTests; i++ )

    {

      double lossDb = txPowerDbm - snrEfficiencyMcs[i].snrDb - noisePowerDbm - receiverNoiseFigureDb;

      std::ostringstream name;

      name << " snr= " << snrEfficiencyMcs[i].snrDb << " dB, "

           << " mcs= " << snrEfficiencyMcs[i].mcsIndex;

      AddTestCase (new LteLinkAdaptationTestCase (name.str (),  snrEfficiencyMcs[i].snrDb, lossDb, snrEfficiencyMcs[i].mcsIndex));

    }

}

static LteLinkAdaptationTestSuite lteLinkAdaptationTestSuite;

/**

 * TestCase

 */

LteLinkAdaptationTestCase::LteLinkAdaptationTestCase (std::string name, double snrDb, double loss, uint16_t mcsIndex)

  : TestCase (name),

    m_snrDb (snrDb),

    m_loss (loss),

    m_mcsIndex (mcsIndex)

{

  std::ostringstream sstream1, sstream2;

  sstream1 << " snr=" << snrDb 

           << " mcs=" << mcsIndex;

  NS_LOG_INFO ("Creating LteLinkAdaptationTestCase: " + sstream1.str ());

}

LteLinkAdaptationTestCase::~LteLinkAdaptationTestCase ()

{

}

void

LteLinkAdaptationTestCase::DoRun (void)

{

  /**

    * Simulation Topology

    */

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

//   lteHelper->EnableLogComponents ();

  lteHelper->EnableMacTraces ();

  lteHelper->EnableRlcTraces ();

  lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::ConstantSpectrumPropagationLossModel"));

  NS_LOG_INFO ("SNR = " << m_snrDb << "  LOSS = " << m_loss);

  lteHelper->SetPathlossModelAttribute ("Loss", DoubleValue (m_loss));

  // Create Nodes: eNodeB and UE

  NodeContainer enbNodes;

  NodeContainer ueNodes;

  enbNodes.Create (1);

  ueNodes.Create (1);

  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );

  // Install Mobility Model

  MobilityHelper mobility;

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

  mobility.Install (allNodes);

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

  NetDeviceContainer enbDevs;

  NetDeviceContainer ueDevs;

  lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler");

  enbDevs = lteHelper->InstallEnbDevice (enbNodes);

  ueDevs = lteHelper->InstallUeDevice (ueNodes);

  // Attach a UE to a eNB

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

  // Activate the default EPS bearer

  enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;

  EpsBearer bearer (q);

  // Use testing chunk processor in the PHY layer

  // It will be used to test that the SNR is as intended

  Ptr<LtePhy> uePhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();

  Ptr<LteTestSinrChunkProcessor> testSinr = Create<LteTestSinrChunkProcessor> (uePhy);

  uePhy->GetDownlinkSpectrumPhy ()->AddSinrChunkProcessor (testSinr);

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

                   MakeBoundCallback (&LteTestDlSchedulingCallback, this));

  Simulator::Stop (Seconds (0.005));

  Simulator::Run ();

  double calculatedSinrDb = 10.0 * log10 (testSinr->GetSinr ()[0]);

  NS_TEST_ASSERT_MSG_EQ_TOL (calculatedSinrDb, m_snrDb, 0.0000001, "Wrong SINR !");

  Simulator::Destroy ();

}

void

LteLinkAdaptationTestCase::DlScheduling (uint32_t frameNo, uint32_t subframeNo, uint16_t rnti,

                                         uint8_t mcsTb1, uint16_t sizeTb1, uint8_t mcsTb2, uint16_t sizeTb2) 

{

  static bool firstTime = true;

  if ( firstTime )

    {

      firstTime = false;

      NS_LOG_INFO ("SNR\tRef_MCS\tCalc_MCS");

    }

  /**

   * Note:

   *    For first 4 subframeNo in the first frameNo, the MCS cannot be properly evaluated,

   *    because CQI feedback is still not available at the eNB.

   */

  if ( (frameNo > 1) || (subframeNo > 4) )

    {

      NS_LOG_INFO (m_snrDb << "\t" << m_mcsIndex << "\t" << (uint16_t)mcsTb1);

      NS_TEST_ASSERT_MSG_EQ ((uint16_t)mcsTb1, m_mcsIndex, "Wrong MCS index");

    }

}