/* -*- 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: Marco Miozzo <marco.miozzo@cttc.es>        // original version

 * Modification: Dizhi Zhou <dizhi.zhou@gmail.com>    // modify codes related to downlink scheduler

 */

#include <ns3/log.h>

#include <ns3/pointer.h>

#include <ns3/math.h>

#include <ns3/simulator.h>

#include <ns3/lte-amc.h>

#include <ns3/tdbet-ff-mac-scheduler.h>

#include <ns3/lte-vendor-specific-parameters.h>

NS_LOG_COMPONENT_DEFINE ("TdBetFfMacScheduler");

// value for SINR outside the range defined by LTE, used to indicate that there

// is no CQI for this element

#define NO_SINR -5000

namespace ns3 {

int TdBetType0AllocationRbg[4] = {

  10,       // RGB size 1

  26,       // RGB size 2

  63,       // RGB size 3

  110       // RGB size 4

};  // see table 7.1.6.1-1 of 36.213

NS_OBJECT_ENSURE_REGISTERED (TdBetFfMacScheduler);

class TdBetSchedulerMemberCschedSapProvider : public FfMacCschedSapProvider

{

public:

  TdBetSchedulerMemberCschedSapProvider (TdBetFfMacScheduler* scheduler);

  // inherited from FfMacCschedSapProvider

  virtual void CschedCellConfigReq (const struct CschedCellConfigReqParameters& params);

  virtual void CschedUeConfigReq (const struct CschedUeConfigReqParameters& params);

  virtual void CschedLcConfigReq (const struct CschedLcConfigReqParameters& params);

  virtual void CschedLcReleaseReq (const struct CschedLcReleaseReqParameters& params);

  virtual void CschedUeReleaseReq (const struct CschedUeReleaseReqParameters& params);

private:

  TdBetSchedulerMemberCschedSapProvider ();

  TdBetFfMacScheduler* m_scheduler;

};

TdBetSchedulerMemberCschedSapProvider::TdBetSchedulerMemberCschedSapProvider ()

{

}

TdBetSchedulerMemberCschedSapProvider::TdBetSchedulerMemberCschedSapProvider (TdBetFfMacScheduler* scheduler) : m_scheduler (scheduler)

{

}

void

TdBetSchedulerMemberCschedSapProvider::CschedCellConfigReq (const struct CschedCellConfigReqParameters& params)

{

  m_scheduler->DoCschedCellConfigReq (params);

}

void

TdBetSchedulerMemberCschedSapProvider::CschedUeConfigReq (const struct CschedUeConfigReqParameters& params)

{

  m_scheduler->DoCschedUeConfigReq (params);

}

void

TdBetSchedulerMemberCschedSapProvider::CschedLcConfigReq (const struct CschedLcConfigReqParameters& params)

{

  m_scheduler->DoCschedLcConfigReq (params);

}

void

TdBetSchedulerMemberCschedSapProvider::CschedLcReleaseReq (const struct CschedLcReleaseReqParameters& params)

{

  m_scheduler->DoCschedLcReleaseReq (params);

}

void

TdBetSchedulerMemberCschedSapProvider::CschedUeReleaseReq (const struct CschedUeReleaseReqParameters& params)

{

  m_scheduler->DoCschedUeReleaseReq (params);

}

class TdBetSchedulerMemberSchedSapProvider : public FfMacSchedSapProvider

{

public:

  TdBetSchedulerMemberSchedSapProvider (TdBetFfMacScheduler* scheduler);

  // inherited from FfMacSchedSapProvider

  virtual void SchedDlRlcBufferReq (const struct SchedDlRlcBufferReqParameters& params);

  virtual void SchedDlPagingBufferReq (const struct SchedDlPagingBufferReqParameters& params);

  virtual void SchedDlMacBufferReq (const struct SchedDlMacBufferReqParameters& params);

  virtual void SchedDlTriggerReq (const struct SchedDlTriggerReqParameters& params);

  virtual void SchedDlRachInfoReq (const struct SchedDlRachInfoReqParameters& params);

  virtual void SchedDlCqiInfoReq (const struct SchedDlCqiInfoReqParameters& params);

  virtual void SchedUlTriggerReq (const struct SchedUlTriggerReqParameters& params);

  virtual void SchedUlNoiseInterferenceReq (const struct SchedUlNoiseInterferenceReqParameters& params);

  virtual void SchedUlSrInfoReq (const struct SchedUlSrInfoReqParameters& params);

  virtual void SchedUlMacCtrlInfoReq (const struct SchedUlMacCtrlInfoReqParameters& params);

  virtual void SchedUlCqiInfoReq (const struct SchedUlCqiInfoReqParameters& params);

private:

  TdBetSchedulerMemberSchedSapProvider ();

  TdBetFfMacScheduler* m_scheduler;

};

TdBetSchedulerMemberSchedSapProvider::TdBetSchedulerMemberSchedSapProvider ()

{

}

TdBetSchedulerMemberSchedSapProvider::TdBetSchedulerMemberSchedSapProvider (TdBetFfMacScheduler* scheduler)

  : m_scheduler (scheduler)

{

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlRlcBufferReq (const struct SchedDlRlcBufferReqParameters& params)

{

  m_scheduler->DoSchedDlRlcBufferReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlPagingBufferReq (const struct SchedDlPagingBufferReqParameters& params)

{

  m_scheduler->DoSchedDlPagingBufferReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlMacBufferReq (const struct SchedDlMacBufferReqParameters& params)

{

  m_scheduler->DoSchedDlMacBufferReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlTriggerReq (const struct SchedDlTriggerReqParameters& params)

{

  m_scheduler->DoSchedDlTriggerReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlRachInfoReq (const struct SchedDlRachInfoReqParameters& params)

{

  m_scheduler->DoSchedDlRachInfoReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedDlCqiInfoReq (const struct SchedDlCqiInfoReqParameters& params)

{

  m_scheduler->DoSchedDlCqiInfoReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedUlTriggerReq (const struct SchedUlTriggerReqParameters& params)

{

  m_scheduler->DoSchedUlTriggerReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedUlNoiseInterferenceReq (const struct SchedUlNoiseInterferenceReqParameters& params)

{

  m_scheduler->DoSchedUlNoiseInterferenceReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedUlSrInfoReq (const struct SchedUlSrInfoReqParameters& params)

{

  m_scheduler->DoSchedUlSrInfoReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedUlMacCtrlInfoReq (const struct SchedUlMacCtrlInfoReqParameters& params)

{

  m_scheduler->DoSchedUlMacCtrlInfoReq (params);

}

void

TdBetSchedulerMemberSchedSapProvider::SchedUlCqiInfoReq (const struct SchedUlCqiInfoReqParameters& params)

{

  m_scheduler->DoSchedUlCqiInfoReq (params);

}

TdBetFfMacScheduler::TdBetFfMacScheduler ()

  :   m_cschedSapUser (0),

    m_schedSapUser (0),

    m_timeWindow (99.0),

    m_nextRntiUl (0)

{

  m_amc = CreateObject <LteAmc> ();

  m_cschedSapProvider = new TdBetSchedulerMemberCschedSapProvider (this);

  m_schedSapProvider = new TdBetSchedulerMemberSchedSapProvider (this);

}

TdBetFfMacScheduler::~TdBetFfMacScheduler ()

{

  NS_LOG_FUNCTION (this);

}

void

TdBetFfMacScheduler::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  delete m_cschedSapProvider;

  delete m_schedSapProvider;

}

TypeId

TdBetFfMacScheduler::GetTypeId (void)

{

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

    .SetParent<FfMacScheduler> ()

    .AddConstructor<TdBetFfMacScheduler> ()

    .AddAttribute ("CqiTimerThreshold",

                   "The number of TTIs a CQI is valid (default 1000 - 1 sec.)",

                   UintegerValue (1000),

                   MakeUintegerAccessor (&TdBetFfMacScheduler::m_cqiTimersThreshold),

                   MakeUintegerChecker<uint32_t> ())

  ;

  return tid;

}

void

TdBetFfMacScheduler::SetFfMacCschedSapUser (FfMacCschedSapUser* s)

{

  m_cschedSapUser = s;

}

void

TdBetFfMacScheduler::SetFfMacSchedSapUser (FfMacSchedSapUser* s)

{

  m_schedSapUser = s;

}

FfMacCschedSapProvider*

TdBetFfMacScheduler::GetFfMacCschedSapProvider ()

{

  return m_cschedSapProvider;

}

FfMacSchedSapProvider*

TdBetFfMacScheduler::GetFfMacSchedSapProvider ()

{

  return m_schedSapProvider;

}

void

TdBetFfMacScheduler::DoCschedCellConfigReq (const struct FfMacCschedSapProvider::CschedCellConfigReqParameters& params)

{

  NS_LOG_FUNCTION (this);

  // Read the subset of parameters used

  m_cschedCellConfig = params;

  FfMacCschedSapUser::CschedUeConfigCnfParameters cnf;

  cnf.m_result = SUCCESS;

  m_cschedSapUser->CschedUeConfigCnf (cnf);

  return;

}

void

TdBetFfMacScheduler::DoCschedUeConfigReq (const struct FfMacCschedSapProvider::CschedUeConfigReqParameters& params)

{

  NS_LOG_FUNCTION (this << " RNTI " << params.m_rnti << " txMode " << (uint16_t)params.m_transmissionMode);

  std::map <uint16_t,uint8_t>::iterator it = m_uesTxMode.find (params.m_rnti);

  if (it == m_uesTxMode.end ())

    {

      m_uesTxMode.insert (std::pair <uint16_t, double> (params.m_rnti, params.m_transmissionMode));

    }

  else

    {

      (*it).second = params.m_transmissionMode;

    }

  return;

}

void

TdBetFfMacScheduler::DoCschedLcConfigReq (const struct FfMacCschedSapProvider::CschedLcConfigReqParameters& params)

{

  NS_LOG_FUNCTION (this << " New LC, rnti: "  << params.m_rnti);

  std::map <uint16_t, tdbetsFlowPerf_t>::iterator it;

  for (uint16_t i = 0; i < params.m_logicalChannelConfigList.size (); i++)

    {

      it = m_flowStatsDl.find (params.m_rnti);

      if (it == m_flowStatsDl.end ())

        {

          tdbetsFlowPerf_t flowStatsDl;

          flowStatsDl.flowStart = Simulator::Now ();

          flowStatsDl.totalBytesTransmitted = 0;

          flowStatsDl.lastTtiBytesTransmitted = 0;

          flowStatsDl.lastAveragedThroughput = 1;

          m_flowStatsDl.insert (std::pair<uint16_t, tdbetsFlowPerf_t> (params.m_rnti, flowStatsDl));

          tdbetsFlowPerf_t flowStatsUl;

          flowStatsUl.flowStart = Simulator::Now ();

          flowStatsUl.totalBytesTransmitted = 0;

          flowStatsUl.lastTtiBytesTransmitted = 0;

          flowStatsUl.lastAveragedThroughput = 1;

          m_flowStatsUl.insert (std::pair<uint16_t, tdbetsFlowPerf_t> (params.m_rnti, flowStatsUl));

        }

      else

        {

          NS_LOG_ERROR ("RNTI already exists");

        }

    }

  return;

}

void

TdBetFfMacScheduler::DoCschedLcReleaseReq (const struct FfMacCschedSapProvider::CschedLcReleaseReqParameters& params)

{

  NS_FATAL_ERROR ("unimplemented");

  return;

}

void

TdBetFfMacScheduler::DoCschedUeReleaseReq (const struct FfMacCschedSapProvider::CschedUeReleaseReqParameters& params)

{

  NS_FATAL_ERROR ("unimplemented");

  return;

}

void

TdBetFfMacScheduler::DoSchedDlRlcBufferReq (const struct FfMacSchedSapProvider::SchedDlRlcBufferReqParameters& params)

{

  NS_LOG_FUNCTION (this << params.m_rnti << (uint32_t) params.m_logicalChannelIdentity);

  // API generated by RLC for updating RLC parameters on a LC (tx and retx queues)

  std::map <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it;

  LteFlowId_t flow (params.m_rnti, params.m_logicalChannelIdentity);

  it =  m_rlcBufferReq.find (flow);

  if (it == m_rlcBufferReq.end ())

    {

      m_rlcBufferReq.insert (std::pair <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters> (flow, params));

    }

  else

    {

      (*it).second = params;

    }

  return;

}

void

TdBetFfMacScheduler::DoSchedDlPagingBufferReq (const struct FfMacSchedSapProvider::SchedDlPagingBufferReqParameters& params)

{

  NS_FATAL_ERROR ("unimplemented");

  return;

}

void

TdBetFfMacScheduler::DoSchedDlMacBufferReq (const struct FfMacSchedSapProvider::SchedDlMacBufferReqParameters& params)

{

  NS_FATAL_ERROR ("unimplemented");

  return;

}

int

TdBetFfMacScheduler::GetRbgSize (int dlbandwidth)

{

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

    {

      if (dlbandwidth < TdBetType0AllocationRbg[i])

        {

          return (i + 1);

        }

    }

  return (-1);

}

int 

TdBetFfMacScheduler::LcActivePerFlow (uint16_t rnti)

{

  std::map <LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it;

  int lcActive = 0;

  for (it = m_rlcBufferReq.begin (); it != m_rlcBufferReq.end (); it++)

    {

      if (((*it).first.m_rnti == rnti) && (((*it).second.m_rlcTransmissionQueueSize > 0)

                                           || ((*it).second.m_rlcRetransmissionQueueSize > 0)

                                           || ((*it).second.m_rlcStatusPduSize > 0) ))

        {

          lcActive++;

        }

      if ((*it).first.m_rnti > rnti)

        {

          break;

        }

    }

  return (lcActive);

}

void

TdBetFfMacScheduler::DoSchedDlTriggerReq (const struct FfMacSchedSapProvider::SchedDlTriggerReqParameters& params)

{

  NS_LOG_FUNCTION (this << " Frame no. " << (params.m_sfnSf >> 4) << " subframe no. " << (0xF & params.m_sfnSf));

  // API generated by RLC for triggering the scheduling of a DL subframe

  // evaluate the relative channel quality indicator for each UE per each RBG 

  // (since we are using allocation type 0 the small unit of allocation is RBG)

  // Resource allocation type 0 (see sec 7.1.6.1 of 36.213)

  RefreshDlCqiMaps ();

  int rbgSize = GetRbgSize (m_cschedCellConfig.m_dlBandwidth);

  int rbgNum = m_cschedCellConfig.m_dlBandwidth / rbgSize;

  std::map <uint16_t, std::vector <uint16_t> > allocationMap;

  std::map <uint16_t, tdbetsFlowPerf_t>::iterator it;

  std::map <uint16_t, tdbetsFlowPerf_t>::iterator itMax = m_flowStatsDl.end ();

  double metricMax = 0.0;

  for (it = m_flowStatsDl.begin (); it != m_flowStatsDl.end (); it++)

    {

      double metric = 1 / (*it).second.lastAveragedThroughput;

      if (metric > metricMax)

        {

          metricMax = metric;

          itMax = it;

        }

    } // end for m_flowStatsDl

  if (itMax == m_flowStatsDl.end ())

    {

      // no UE available for downlink 

      return;

    }

  else

    {

      // assign all RBGs to this UE

      std::vector <uint16_t> tempMap;

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

        {

          tempMap.push_back (i);

        }

      allocationMap.insert (std::pair <uint16_t, std::vector <uint16_t> > ((*itMax).first, tempMap));

    }

  // reset TTI stats of users

  std::map <uint16_t, tdbetsFlowPerf_t>::iterator itStats;

  for (itStats = m_flowStatsDl.begin (); itStats != m_flowStatsDl.end (); itStats++)

    {

      (*itStats).second.lastTtiBytesTransmitted = 0;

    }

  // generate the transmission opportunities by grouping the RBGs of the same RNTI and

  // creating the correspondent DCIs

  FfMacSchedSapUser::SchedDlConfigIndParameters ret;

  std::map <uint16_t, std::vector <uint16_t> >::iterator itMap = allocationMap.begin ();

  while (itMap != allocationMap.end ())

    {

      // create new BuildDataListElement_s for this LC

      BuildDataListElement_s newEl;

      newEl.m_rnti = (*itMap).first;

      // create the DlDciListElement_s

      DlDciListElement_s newDci;

      std::vector <struct RlcPduListElement_s> newRlcPduLe;

      newDci.m_rnti = (*itMap).first;

      uint16_t lcActives = LcActivePerFlow ((*itMap).first);

      std::map <uint16_t,uint8_t>::iterator itCqi;

      itCqi = m_p10CqiRxed.find ((*itMap).first);

      std::map <uint16_t,uint8_t>::iterator itTxMode;

      itTxMode = m_uesTxMode.find ((*itMap).first);

      if (itTxMode == m_uesTxMode.end ())

        {

          NS_FATAL_ERROR ("No Transmission Mode info on user " << (*itMap).first);

        }

      int nLayer = TransmissionModesLayers::TxMode2LayerNum ((*itTxMode).second);

      uint32_t bytesTxed = 0;

      for (uint8_t i = 0; i < nLayer; i++) 

        {

          if (itCqi == m_p10CqiRxed.end ())

            {

              newDci.m_mcs.push_back (0); // no info on this user -> lowest MCS

            }

          else

            {

              newDci.m_mcs.push_back ( m_amc->GetMcsFromCqi ((*itCqi).second) );

            }

        }

      for (uint8_t i = 0; i < nLayer; i++)

	{

          int tbSize = (m_amc->GetTbSizeFromMcs (newDci.m_mcs.at (0), rbgNum * rbgSize) / 8); // (size of TB in bytes according to table 7.1.7.2.1-1 of 36.213)

          newDci.m_tbsSize.push_back (tbSize);

          bytesTxed += tbSize;

        }

      newDci.m_resAlloc = 0;  // only allocation type 0 at this stage