*         Marco Miozzo <mmiozzo@cttc.es>

#include "lte-enb-mac.h"

////////////////////////////////////////

// member SAP forwarders

////////////////////////////////////////

class EnbMemberLteEnbPhySapProvider : public LteEnbPhySapProvider

{

public:

  EnbMemberLteEnbPhySapProvider (EnbLtePhy* phy);

  // inherited from LteEnbPhySapProvider

  virtual void SendMacPdu (Ptr<Packet> p);

  virtual void SetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth);

  virtual void SetCellId (uint16_t cellId);

  virtual void SendIdealControlMessage (Ptr<IdealControlMessage> msg);

private:

  EnbLtePhy* m_phy;

};

EnbMemberLteEnbPhySapProvider::EnbMemberLteEnbPhySapProvider (EnbLtePhy* phy) : m_phy (phy)

{

}

void

EnbMemberLteEnbPhySapProvider::SendMacPdu (Ptr<Packet> p)

{

  m_phy->DoSendMacPdu (p);

}

void

EnbMemberLteEnbPhySapProvider::SetBandwidth (uint8_t ulBandwidth, uint8_t dlBandwidth)

{

  m_phy->DoSetBandwidth (ulBandwidth, dlBandwidth);

}

void

EnbMemberLteEnbPhySapProvider::SetCellId (uint16_t cellId)

{

  m_phy->DoSetCellId (cellId);

}

void

EnbMemberLteEnbPhySapProvider::SendIdealControlMessage (Ptr<IdealControlMessage> msg)

{

  m_phy->DoSendIdealControlMessage (msg);

}

////////////////////////////////////////

// generic EnbLtePhy methods

////////////////////////////////////////

  : m_nrFrames (0),

    m_nrSubFrames (0)

  m_enbPhySapProvider = new EnbMemberLteEnbPhySapProvider (this);

void

EnbLtePhy::SetLteEnbPhySapUser (LteEnbPhySapUser* s)

{

  m_enbPhySapUser = s;

}

LteEnbPhySapProvider*

EnbLtePhy::GetLteEnbPhySapProvider ()

{

  return (m_enbPhySapProvider);

}

bool

EnbLtePhy::AddUePhy (uint8_t rnti, Ptr<UeLtePhy> phy)

{

  std::map <uint8_t, Ptr<UeLtePhy> >::iterator it;

  it = m_ueAttached.find (rnti);

  if (it == m_ueAttached.end ())

    {

      m_ueAttached.insert (std::pair<uint8_t, Ptr<UeLtePhy> > (rnti, phy));

      return (true);

    }

  else

    {

      NS_LOG_ERROR ("UE already attached");

      return (false);

    }

}

EnbLtePhy::DeleteUePhy (uint8_t rnti)

  std::map <uint8_t, Ptr<UeLtePhy> >::iterator it;

  it = m_ueAttached.find (rnti);

  if (it == m_ueAttached.end ())

    {

      NS_LOG_ERROR ("UE not attached");

      return (false);

    }

  else

    {

      m_ueAttached.erase (it);

      return (true);

    }

}

void

EnbLtePhy::DoSendMacPdu (Ptr<Packet> p)

{

//   NS_LOG_FUNCTION (this << pb->GetNPackets () << pb->GetSize ());

//   return GetDownlinkSpectrumPhy ()->StartTx (pb);

  NS_LOG_FUNCTION (this);

  SetMacPdu (p);

}

void

EnbLtePhy::PhyPduReceived (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this);

  m_enbPhySapUser->ReceivePhyPdu (p);

EnbLtePhy::DoSendIdealControlMessage (Ptr<IdealControlMessage> msg)

  // queues the message (wait for MAC-PHY delay)

  SetControlMessages (msg);

  m_enbPhySapUser->ReceiveIdealControlMessage (msg);

  NS_LOG_FUNCTION (this);

  ++m_nrFrames;

  NS_LOG_INFO ("-----frame " << m_nrFrames << "-----");

  m_nrSubFrames = 0;

  NS_LOG_FUNCTION (this);

  ++m_nrSubFrames;

  NS_LOG_INFO ("-----sub frame " << m_nrSubFrames << "-----");

  // send the current burst of control messages

  std::list<Ptr<IdealControlMessage> > ctrlMsg = GetControlMessages ();

  std::vector <int> dlRb;

  if (ctrlMsg.size () > 0)

    {

      std::list<Ptr<IdealControlMessage> >::iterator it;

      it = ctrlMsg.begin ();

      while (it != ctrlMsg.end ())

        {

          Ptr<IdealControlMessage> msg = (*it);

          if (msg->GetMessageType () == IdealControlMessage::DL_DCI)

            {

              std::map <uint8_t, Ptr<UeLtePhy> >::iterator it2;

              Ptr<DlDciIdealControlMessage> dci = DynamicCast<DlDciIdealControlMessage> (msg);

              it2 = m_ueAttached.find (dci->GetDci ().m_rnti);

              if (it2 == m_ueAttached.end ())

                {

                  NS_LOG_ERROR ("UE not attached");

                }

              else

                {

                  // get the tx power spectral density according to DL-DCI(s)

                  // translate the DCI to Spectrum framework

                  uint32_t mask = 0x1;

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

                    {

                      if (((dci->GetDci ().m_rbBitmap & mask) >> i) == 1)

                        {

                          for (int k = 0; k < GetRbgSize (); k++)

                            {

                              dlRb.push_back ((i * GetRbgSize ()) + k);

                              //NS_LOG_DEBUG(this << " [enb]DL-DCI allocated PRB " << (i*GetRbgSize()) + k);

                            }

                        }

                      mask = (mask << 1);

                    }

                  (*it2).second->ReceiveIdealControlMessage (msg);

                }

            }

          else if (msg->GetMessageType () == IdealControlMessage::UL_DCI)

            {

              std::map <uint8_t, Ptr<UeLtePhy> >::iterator it2;

              Ptr<UlDciIdealControlMessage> dci = DynamicCast<UlDciIdealControlMessage> (msg);

              it2 = m_ueAttached.find (dci->GetDci ().m_rnti);

              if (it2 == m_ueAttached.end ())

              {

                NS_LOG_ERROR ("UE not attached");

              }

              else

              {

                (*it2).second->ReceiveIdealControlMessage (msg);

              }

            }

          ctrlMsg.pop_front ();

          it = ctrlMsg.begin ();

        }

    }

  // set the current tx power spectral density

  SetDownlinkSubChannels (dlRb);

  // send the current burts of packets

  Ptr<PacketBurst> pb = GetPacketBurst ();

  if (pb)

    {

      GetDownlinkSpectrumPhy ()->StartTx (pb);

    }

  // trigger the MAC

  Ptr<LteEnbMac> macEntity = GetDevice ()->GetObject<EnbNetDevice> ()->GetMac ();

  m_enbPhySapUser->SubframeIndication (m_nrFrames, m_nrSubFrames);

  // trigger the UE(s)

  std::map <uint8_t, Ptr<UeLtePhy> >::iterator it;

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

    {

      (*it).second->SubframeIndication (m_nrFrames, m_nrSubFrames);

    }

  if (m_nrSubFrames == 10)

void 

EnbLtePhy::GenerateCqiFeedback (const SpectrumValue& sinr)

{

  NS_LOG_FUNCTION (this << sinr);

}