/* -*- 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>

 * 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/pss-ff-mac-scheduler.h>

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

#include <ns3/boolean.h>

#include <cfloat>

#include <set>

#include <ns3/string.h>

#include <algorithm>

static const int PssType0AllocationRbg[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 (PssFfMacScheduler);

class PssSchedulerMemberCschedSapProvider : public FfMacCschedSapProvider

{

public:

  PssSchedulerMemberCschedSapProvider (PssFfMacScheduler* 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:

  PssSchedulerMemberCschedSapProvider ();

  PssFfMacScheduler* m_scheduler;

};

PssSchedulerMemberCschedSapProvider::PssSchedulerMemberCschedSapProvider ()

{

}

PssSchedulerMemberCschedSapProvider::PssSchedulerMemberCschedSapProvider (PssFfMacScheduler* scheduler) : m_scheduler (scheduler)

{

}

void

PssSchedulerMemberCschedSapProvider::CschedCellConfigReq (const struct CschedCellConfigReqParameters& params)

{

  m_scheduler->DoCschedCellConfigReq (params);

}

void

PssSchedulerMemberCschedSapProvider::CschedUeConfigReq (const struct CschedUeConfigReqParameters& params)

{

  m_scheduler->DoCschedUeConfigReq (params);

}

void

PssSchedulerMemberCschedSapProvider::CschedLcConfigReq (const struct CschedLcConfigReqParameters& params)

{

  m_scheduler->DoCschedLcConfigReq (params);

}

void

PssSchedulerMemberCschedSapProvider::CschedLcReleaseReq (const struct CschedLcReleaseReqParameters& params)

{

  m_scheduler->DoCschedLcReleaseReq (params);

}

void

PssSchedulerMemberCschedSapProvider::CschedUeReleaseReq (const struct CschedUeReleaseReqParameters& params)

{

  m_scheduler->DoCschedUeReleaseReq (params);

}

class PssSchedulerMemberSchedSapProvider : public FfMacSchedSapProvider

{

public:

  PssSchedulerMemberSchedSapProvider (PssFfMacScheduler* 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:

  PssSchedulerMemberSchedSapProvider ();

  PssFfMacScheduler* m_scheduler;

};

PssSchedulerMemberSchedSapProvider::PssSchedulerMemberSchedSapProvider ()

{

}

PssSchedulerMemberSchedSapProvider::PssSchedulerMemberSchedSapProvider (PssFfMacScheduler* scheduler)

  : m_scheduler (scheduler)

{

}

void

PssSchedulerMemberSchedSapProvider::SchedDlRlcBufferReq (const struct SchedDlRlcBufferReqParameters& params)

{

  m_scheduler->DoSchedDlRlcBufferReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedDlPagingBufferReq (const struct SchedDlPagingBufferReqParameters& params)

{

  m_scheduler->DoSchedDlPagingBufferReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedDlMacBufferReq (const struct SchedDlMacBufferReqParameters& params)

{

  m_scheduler->DoSchedDlMacBufferReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedDlTriggerReq (const struct SchedDlTriggerReqParameters& params)

{

  m_scheduler->DoSchedDlTriggerReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedDlRachInfoReq (const struct SchedDlRachInfoReqParameters& params)

{

  m_scheduler->DoSchedDlRachInfoReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedDlCqiInfoReq (const struct SchedDlCqiInfoReqParameters& params)

{

  m_scheduler->DoSchedDlCqiInfoReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedUlTriggerReq (const struct SchedUlTriggerReqParameters& params)

{

  m_scheduler->DoSchedUlTriggerReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedUlNoiseInterferenceReq (const struct SchedUlNoiseInterferenceReqParameters& params)

{

  m_scheduler->DoSchedUlNoiseInterferenceReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedUlSrInfoReq (const struct SchedUlSrInfoReqParameters& params)

{

  m_scheduler->DoSchedUlSrInfoReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedUlMacCtrlInfoReq (const struct SchedUlMacCtrlInfoReqParameters& params)

{

  m_scheduler->DoSchedUlMacCtrlInfoReq (params);

}

void

PssSchedulerMemberSchedSapProvider::SchedUlCqiInfoReq (const struct SchedUlCqiInfoReqParameters& params)

{

  m_scheduler->DoSchedUlCqiInfoReq (params);

}

PssFfMacScheduler::PssFfMacScheduler ()

  :   m_cschedSapUser (0),

    m_schedSapUser (0),

    m_timeWindow (99.0),

    m_nextRntiUl (0)

{

  m_amc = CreateObject <LteAmc> ();

  m_cschedSapProvider = new PssSchedulerMemberCschedSapProvider (this);

  m_schedSapProvider = new PssSchedulerMemberSchedSapProvider (this);

  m_ffrSapProvider = 0;

  m_ffrSapUser = new MemberLteFfrSapUser<PssFfMacScheduler> (this);

}

PssFfMacScheduler::~PssFfMacScheduler ()

{

  NS_LOG_FUNCTION (this);

}

void

PssFfMacScheduler::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  m_dlHarqProcessesDciBuffer.clear ();

  m_dlHarqProcessesTimer.clear ();

  m_dlHarqProcessesRlcPduListBuffer.clear ();

  m_dlInfoListBuffered.clear ();

  m_ulHarqCurrentProcessId.clear ();

  m_ulHarqProcessesStatus.clear ();

  m_ulHarqProcessesDciBuffer.clear ();

  delete m_cschedSapProvider;

  delete m_schedSapProvider;

  delete m_ffrSapUser;

}

TypeId

PssFfMacScheduler::GetTypeId (void)

{

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

    .SetParent<FfMacScheduler> ()

    .AddConstructor<PssFfMacScheduler> ()

    .AddAttribute ("CqiTimerThreshold",

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

                   UintegerValue (1000),

                   MakeUintegerAccessor (&PssFfMacScheduler::m_cqiTimersThreshold),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("PssFdSchedulerType",

                   "FD scheduler in PSS (default value is PFsch)",

                   StringValue ("PFsch"),

                   MakeStringAccessor (&PssFfMacScheduler::m_fdSchedulerType),

                   MakeStringChecker ())

    .AddAttribute ("nMux",

                   "The number of UE selected by TD scheduler (default value is 0)",

                   UintegerValue (0),

                   MakeUintegerAccessor (&PssFfMacScheduler::m_nMux),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("HarqEnabled",

                   "Activate/Deactivate the HARQ [by default is active].",

                   BooleanValue (true),

                   MakeBooleanAccessor (&PssFfMacScheduler::m_harqOn),

                   MakeBooleanChecker ())

    .AddAttribute ("UlGrantMcs",

                   "The MCS of the UL grant, must be [0..15] (default 0)",

                   UintegerValue (0),

                   MakeUintegerAccessor (&PssFfMacScheduler::m_ulGrantMcs),

                   MakeUintegerChecker<uint8_t> ())

  ;

  return tid;

}

void

PssFfMacScheduler::SetFfMacCschedSapUser (FfMacCschedSapUser* s)

{

  m_cschedSapUser = s;

}

void

PssFfMacScheduler::SetFfMacSchedSapUser (FfMacSchedSapUser* s)

{

  m_schedSapUser = s;

}

FfMacCschedSapProvider*

PssFfMacScheduler::GetFfMacCschedSapProvider ()

{

  return m_cschedSapProvider;

}

FfMacSchedSapProvider*

PssFfMacScheduler::GetFfMacSchedSapProvider ()

{

  return m_schedSapProvider;

}

void

PssFfMacScheduler::SetLteFfrSapProvider (LteFfrSapProvider* s)

{

  m_ffrSapProvider = s;

}

LteFfrSapUser*

PssFfMacScheduler::GetLteFfrSapUser ()

{

  return m_ffrSapUser;

}

void

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

{

  NS_LOG_FUNCTION (this);

  // Read the subset of parameters used

  m_cschedCellConfig = params;

  m_rachAllocationMap.resize (m_cschedCellConfig.m_ulBandwidth, 0);

  FfMacCschedSapUser::CschedUeConfigCnfParameters cnf;

  cnf.m_result = SUCCESS;

  m_cschedSapUser->CschedUeConfigCnf (cnf);

  return;

}

void

PssFfMacScheduler::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));

      // generate HARQ buffers

      m_dlHarqCurrentProcessId.insert (std::pair <uint16_t,uint8_t > (params.m_rnti, 0));

      DlHarqProcessesStatus_t dlHarqPrcStatus;

      dlHarqPrcStatus.resize (8,0);

      m_dlHarqProcessesStatus.insert (std::pair <uint16_t, DlHarqProcessesStatus_t> (params.m_rnti, dlHarqPrcStatus));

      DlHarqProcessesTimer_t dlHarqProcessesTimer;

      dlHarqProcessesTimer.resize (8,0);

      m_dlHarqProcessesTimer.insert (std::pair <uint16_t, DlHarqProcessesTimer_t> (params.m_rnti, dlHarqProcessesTimer));

      DlHarqProcessesDciBuffer_t dlHarqdci;

      dlHarqdci.resize (8);

      m_dlHarqProcessesDciBuffer.insert (std::pair <uint16_t, DlHarqProcessesDciBuffer_t> (params.m_rnti, dlHarqdci));

      DlHarqRlcPduListBuffer_t dlHarqRlcPdu;

      dlHarqRlcPdu.resize (2);

      dlHarqRlcPdu.at (0).resize (8);

      dlHarqRlcPdu.at (1).resize (8);

      m_dlHarqProcessesRlcPduListBuffer.insert (std::pair <uint16_t, DlHarqRlcPduListBuffer_t> (params.m_rnti, dlHarqRlcPdu));

      m_ulHarqCurrentProcessId.insert (std::pair <uint16_t,uint8_t > (params.m_rnti, 0));

      UlHarqProcessesStatus_t ulHarqPrcStatus;

      ulHarqPrcStatus.resize (8,0);

      m_ulHarqProcessesStatus.insert (std::pair <uint16_t, UlHarqProcessesStatus_t> (params.m_rnti, ulHarqPrcStatus));

      UlHarqProcessesDciBuffer_t ulHarqdci;

      ulHarqdci.resize (8);

      m_ulHarqProcessesDciBuffer.insert (std::pair <uint16_t, UlHarqProcessesDciBuffer_t> (params.m_rnti, ulHarqdci));

    }

  else

    {

      (*it).second = params.m_transmissionMode;

    }

  return;

}

void

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

{

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

  std::map <uint16_t, pssFlowPerf_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 ())

        {

          double tbrDlInBytes = params.m_logicalChannelConfigList.at (i).m_eRabGuaranteedBitrateDl / 8;   // byte/s

          double tbrUlInBytes = params.m_logicalChannelConfigList.at (i).m_eRabGuaranteedBitrateUl / 8;   // byte/s

          pssFlowPerf_t flowStatsDl;

          flowStatsDl.flowStart = Simulator::Now ();

          flowStatsDl.totalBytesTransmitted = 0;

          flowStatsDl.lastTtiBytesTransmitted = 0;

          flowStatsDl.lastAveragedThroughput = 1;

          flowStatsDl.secondLastAveragedThroughput = 1;

          flowStatsDl.targetThroughput = tbrDlInBytes;

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

          pssFlowPerf_t flowStatsUl;

          flowStatsUl.flowStart = Simulator::Now ();

          flowStatsUl.totalBytesTransmitted = 0;

          flowStatsUl.lastTtiBytesTransmitted = 0;

          flowStatsUl.lastAveragedThroughput = 1;

          flowStatsUl.secondLastAveragedThroughput = 1;

          flowStatsUl.targetThroughput = tbrUlInBytes;

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

        }

      else

        {

          // update GBR from UeManager::SetupDataRadioBearer ()

          double tbrDlInBytes = params.m_logicalChannelConfigList.at (i).m_eRabGuaranteedBitrateDl / 8;   // byte/s

          double tbrUlInBytes = params.m_logicalChannelConfigList.at (i).m_eRabGuaranteedBitrateUl / 8;   // byte/s

          m_flowStatsDl[(*it).first].targetThroughput = tbrDlInBytes;

          m_flowStatsUl[(*it).first].targetThroughput = tbrUlInBytes;

        }

    }

  return;

}

void

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

{

  NS_LOG_FUNCTION (this);

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

    {

      std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it = m_rlcBufferReq.begin ();

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

      while (it!=m_rlcBufferReq.end ())

        {

          if (((*it).first.m_rnti == params.m_rnti) && ((*it).first.m_lcId == params.m_logicalChannelIdentity.at (i)))

            {

              temp = it;

              it++;

              m_rlcBufferReq.erase (temp);

            }

          else

            {

              it++;

            }

        }

    }

  return;

}

void

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

{

  NS_LOG_FUNCTION (this);

  m_uesTxMode.erase (params.m_rnti);

  m_dlHarqCurrentProcessId.erase (params.m_rnti);

  m_dlHarqProcessesStatus.erase  (params.m_rnti);

  m_dlHarqProcessesTimer.erase (params.m_rnti);

  m_dlHarqProcessesDciBuffer.erase  (params.m_rnti);

  m_dlHarqProcessesRlcPduListBuffer.erase  (params.m_rnti);

  m_ulHarqCurrentProcessId.erase  (params.m_rnti);

  m_ulHarqProcessesStatus.erase  (params.m_rnti);

  m_ulHarqProcessesDciBuffer.erase  (params.m_rnti);

  m_flowStatsDl.erase  (params.m_rnti);

  m_flowStatsUl.erase  (params.m_rnti);

  m_ceBsrRxed.erase (params.m_rnti);

  std::map<LteFlowId_t, FfMacSchedSapProvider::SchedDlRlcBufferReqParameters>::iterator it = m_rlcBufferReq.begin ();

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

  while (it!=m_rlcBufferReq.end ())

    {

      if ((*it).first.m_rnti == params.m_rnti)

        {

          temp = it;

          it++;

          m_rlcBufferReq.erase (temp);

        }

      else

        {

          it++;

        }

    }

  if (m_nextRntiUl == params.m_rnti)

    {

      m_nextRntiUl = 0;

    }

  return;

}

void

PssFfMacScheduler::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

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

{

  NS_LOG_FUNCTION (this);

  NS_FATAL_ERROR ("method not implemented");