/* -*-  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/lte-rlc-am-header.h"

#include "ns3/lte-rlc-am.h"

#include "ns3/lte-rlc-sdu-status-tag.h"

#include "ns3/lte-rlc-tag.h"

NS_LOG_COMPONENT_DEFINE ("LteRlcAm");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (LteRlcAm);

LteRlcAm::LteRlcAm ()

{

  NS_LOG_FUNCTION (this);

  // Buffers

  m_txonBufferSize = 0;

  m_retxBuffer.resize (1024);

  m_retxBufferSize = 0;

  m_txedBuffer.resize (1024);

  m_txedBufferSize = 0;

  m_statusPduRequested = false;

  m_statusPduBufferSize = 0;

  // State variables: transmitting side

  m_windowSize = 512;

  m_vtA  = 0;

  m_vtMs = m_vtA + m_windowSize;

  m_vtS  = 0;

  m_pollSn = 0;

  // State variables: receiving side

  m_vrR  = 0;

  m_vrMr = m_vrR + m_windowSize;

  m_vrX  = 0;

  m_vrMs = 0;

  m_vrH  = 0;

  // Counters

  m_pduWithoutPoll  = 0;

  m_byteWithoutPoll = 0;

  // Configurable parameters

  m_maxRetxThreshold = 5;

  m_pollPdu = 1;

  m_pollByte = 50;

  // SDU reassembling process

  m_reassemblingState = WAITING_S0_FULL;

  m_expectedSeqNumber = 0;

  Simulator::ScheduleNow (&LteRlcAm::Start, this);

}

LteRlcAm::~LteRlcAm ()

{

}

TypeId

LteRlcAm::GetTypeId (void)

{

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

    .SetParent<LteRlc> ()

    .AddConstructor<LteRlcAm> ()

    ;

  return tid;

}

/**

 * RLC SAP

 */

void

LteRlcAm::DoTransmitPdcpPdu (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this << p->GetSize ());

  /** Store arrival time */

  Time now = Simulator::Now ();

  RlcTag timeTag (now);

  p->AddPacketTag (timeTag);

  /** Store PDCP PDU */

  LteRlcSduStatusTag tag;

  tag.SetStatus (LteRlcSduStatusTag::FULL_SDU);

  p->AddPacketTag (tag);

  NS_LOG_LOGIC ("Txon Buffer: New packet added");

  m_txonBuffer.push_back (p);

  m_txonBufferSize += p->GetSize ();

  NS_LOG_LOGIC ("NumOfBuffers = " << m_txonBuffer.size() );

  NS_LOG_LOGIC ("txonBufferSize = " << m_txonBufferSize);

  /** Report Buffer Status */

  // Transmission Queue HOL time

  RlcTag txonQueueHolTimeTag;

  m_txonBuffer.front ()->PeekPacketTag (txonQueueHolTimeTag);

  Time txonQueueHolDelay = now - txonQueueHolTimeTag.GetSenderTimestamp ();

  // Retransmission Queue HOL time

  RlcTag retxQueueHolTimeTag;

  Time retxQueueHolDelay (0);

  if ( m_retxBufferSize )

    {

//MRE      m_retxBuffer.front ().m_pdu->PeekPacketTag (retxQueueHolTimeTag);

      retxQueueHolDelay = now - retxQueueHolTimeTag.GetSenderTimestamp ();

    }

  LteMacSapProvider::ReportBufferStatusParameters r;

  r.rnti = m_rnti;

  r.lcid = m_lcid;

  r.txQueueSize = m_txonBufferSize;

  r.txQueueHolDelay = txonQueueHolDelay.GetMilliSeconds ();

  r.retxQueueSize = m_retxBufferSize;

  r.retxQueueHolDelay = retxQueueHolDelay.GetMilliSeconds ();

  if ( m_statusPduRequested && ! m_statusProhibitTimer.IsRunning () )

    {

      r.statusPduSize = m_statusPduBufferSize;

    }

  else

    {

      r.statusPduSize = 0;

    }

  NS_LOG_INFO ("Send ReportBufferStatus: " << r.txQueueSize << ", " << r.txQueueHolDelay << ", " 

                                           << r.retxQueueSize << ", " << r.retxQueueHolDelay << ", " 

                                           << r.statusPduSize);

  m_macSapProvider->ReportBufferStatus (r);

}

/**

 * MAC SAP

 */

void

LteRlcAm::DoNotifyTxOpportunity (uint32_t bytes, uint8_t layer)

{

  NS_LOG_FUNCTION (this << bytes);

  NS_ASSERT_MSG (bytes > 2, "Tx opportunity too small = " << bytes);

  if ( m_statusPduRequested && ! m_statusProhibitTimer.IsRunning () )

    {

      NS_LOG_LOGIC ("Sending STATUS PDU");

      Ptr<Packet> packet = Create<Packet> ();

      LteRlcAmHeader rlcAmHeader;

      rlcAmHeader.SetControlPdu (LteRlcAmHeader::STATUS_PDU);

      rlcAmHeader.SetAckSn (m_vrR);

      NS_LOG_LOGIC ("AM RLC header: " << rlcAmHeader);

      packet->AddHeader (rlcAmHeader);

      // Send RLC PDU to MAC layer

      LteMacSapProvider::TransmitPduParameters params;

      params.pdu = packet;

      params.rnti = m_rnti;

      params.lcid = m_lcid;

      m_macSapProvider->TransmitPdu (params);

      return;

    }

  else if ( m_retxBufferSize > 0 )

    {

      NS_LOG_LOGIC ("Sending data from Retransmission Buffer");

      Ptr<Packet> packet = m_retxBuffer.at (m_vtA.GetValue ()).m_pdu->Copy ();

      if ( packet->GetSize () <= bytes )

        {

          LteRlcAmHeader rlcAmHeader;

          packet->PeekHeader (rlcAmHeader);

          NS_LOG_LOGIC ("AM RLC header: " << rlcAmHeader);

          // Send RLC PDU to MAC layer

          LteMacSapProvider::TransmitPduParameters params;

          params.pdu = packet;

          params.rnti = m_rnti;

          params.lcid = m_lcid;

          m_macSapProvider->TransmitPdu (params);

          return;

        }

      else

        {

          NS_LOG_LOGIC ("Tx opportunity too small for retransmission of the packet (" << packet->GetSize () << " bytes)");

          NS_LOG_LOGIC ("Waiting for bigger tx opportunity");

          return;

        }

    }

  else if ( m_txonBufferSize > 0 )

    {

      NS_LOG_LOGIC ("Sending data from Transmission Buffer");

    }

  else

    {

      NS_LOG_LOGIC ("No data pending");

      return;

    }

  //

  //

  // Build new PDU

  //

  //

  Ptr<Packet> packet = Create<Packet> ();

  LteRlcAmHeader rlcAmHeader;

  rlcAmHeader.SetDataPdu ();

  // Build Data field

  uint32_t nextSegmentSize = bytes - 4;

  uint32_t nextSegmentId = 1;

  uint32_t dataFieldTotalSize = 0;

  uint32_t dataFieldAddedSize = 0;

  std::vector < Ptr<Packet> > dataField;

  // Remove the first packet from the transmission buffer.

  // If only a segment of the packet is taken, then the remaining is given back later

  if ( m_txonBuffer.size () == 0 )

    {

      NS_LOG_LOGIC ("No data pending");

      return;

    }

  NS_LOG_LOGIC ("SDUs in TxonBuffer  = " << m_txonBuffer.size ());

  NS_LOG_LOGIC ("First SDU buffer  = " << *(m_txonBuffer.begin()));

  NS_LOG_LOGIC ("First SDU size    = " << (*(m_txonBuffer.begin()))->GetSize ());

  NS_LOG_LOGIC ("Next segment size = " << nextSegmentSize);

  NS_LOG_LOGIC ("Remove SDU from TxBuffer");

  Ptr<Packet> firstSegment = (*(m_txonBuffer.begin ()))->Copy ();

  m_txonBufferSize -= (*(m_txonBuffer.begin()))->GetSize ();

  NS_LOG_LOGIC ("txBufferSize      = " << m_txonBufferSize );

  m_txonBuffer.erase (m_txonBuffer.begin ());

  while ( firstSegment && (firstSegment->GetSize () > 0) && (nextSegmentSize > 0) )

    {

      NS_LOG_LOGIC ("WHILE .. firstSegment && firstSegment->GetSize > 0 && nextSegmentSize > 0 ..");

      NS_LOG_LOGIC ("    FirstSegment size = " << firstSegment->GetSize ());

      NS_LOG_LOGIC ("    Next segment size = " << nextSegmentSize);

      if ( firstSegment->GetSize () > nextSegmentSize )

        {

          NS_LOG_LOGIC ("    IF firstSegment > NextSegmentSize");

          // Segment txBuffer.FirstBuffer and

          // Give back the remaining segment to the transmission buffer

          Ptr<Packet> newSegment = firstSegment->CreateFragment (0, nextSegmentSize);

          // Status tag of the new and remaining segments

          // Note: This is the only place where a PDU is segmented and

          // therefore its status can change

          LteRlcSduStatusTag oldTag, newTag;    // TODO CreateFragment copy the tag???

          firstSegment->RemovePacketTag (oldTag);

          newSegment->RemovePacketTag (newTag);

          if (oldTag.GetStatus () == LteRlcSduStatusTag::FULL_SDU)

            {

              newTag.SetStatus (LteRlcSduStatusTag::FIRST_SEGMENT);

              oldTag.SetStatus (LteRlcSduStatusTag::LAST_SEGMENT);

            }

          else if (oldTag.GetStatus () == LteRlcSduStatusTag::LAST_SEGMENT)

            {

              newTag.SetStatus (LteRlcSduStatusTag::MIDDLE_SEGMENT);

              //oldTag.SetStatus (LteRlcSduStatusTag::LAST_SEGMENT);

            }

          firstSegment->AddPacketTag (oldTag);

          newSegment->AddPacketTag (newTag);  // TODO What happens if we add two tags???

          // Give back the remaining segment to the transmission buffer

          firstSegment->RemoveAtStart (nextSegmentSize);

          m_txonBuffer.insert (m_txonBuffer.begin (), firstSegment);

          m_txonBufferSize += (*(m_txonBuffer.begin()))->GetSize ();

          firstSegment = 0; // TODO how to put a null ptr to Packet?

          NS_LOG_LOGIC ("    TX buffer: Give back the remaining segment");

          NS_LOG_LOGIC ("    TX buffers = " << m_txonBuffer.size ());

          NS_LOG_LOGIC ("    Front buffer size = " << (*(m_txonBuffer.begin()))->GetSize ());

          NS_LOG_LOGIC ("    txBufferSize = " << m_txonBufferSize );

          // Add Segment to Data field

          dataFieldAddedSize = newSegment->GetSize ();

          dataFieldTotalSize += dataFieldAddedSize;

          dataField.push_back (newSegment);

          newSegment = 0; // TODO how to put a null ptr to Packet?

          // ExtensionBit (Next_Segment - 1) = 0

          rlcAmHeader.PushExtensionBit (LteRlcAmHeader::DATA_FIELD_FOLLOWS);

          // no LengthIndicator for the last one

          nextSegmentSize -= dataFieldAddedSize;

          nextSegmentId++;

          // nextSegmentSize MUST be zero

          // (NO more segments) → exit

          // break;

        }

      else if ( (firstSegment->GetSize () == nextSegmentSize) || (m_txonBuffer.size () == 0) )

        {

          NS_LOG_LOGIC ("    IF firstSegment == NextSegmentSize || txonBuffer.size == 0");

          // Add txBuffer.FirstBuffer to DataField

          dataFieldAddedSize = firstSegment->GetSize ();

          dataFieldTotalSize += dataFieldAddedSize;

          dataField.push_back (firstSegment);

          firstSegment = 0;

          // ExtensionBit (Next_Segment - 1) = 0

          rlcAmHeader.PushExtensionBit (LteRlcAmHeader::DATA_FIELD_FOLLOWS);

          // no LengthIndicator for the last one

          nextSegmentSize -= dataFieldAddedSize;

          nextSegmentId++;

          NS_LOG_LOGIC ("        SDUs in TxBuffer  = " << m_txonBuffer.size ());

          if (m_txonBuffer.size () > 0)

            {

              NS_LOG_LOGIC ("        First SDU buffer  = " << *(m_txonBuffer.begin()));

              NS_LOG_LOGIC ("        First SDU size    = " << (*(m_txonBuffer.begin()))->GetSize ());

            }

          NS_LOG_LOGIC ("        Next segment size = " << nextSegmentSize);

          // nextSegmentSize MUST be zero (only if txonBuffer is not empty)

          // (NO more segments) → exit

          // break;

        }

      else // (firstSegment->GetSize () < m_nextSegmentSize) && (m_txBuffer.size () > 0)

        {

          NS_LOG_LOGIC ("    IF firstSegment < NextSegmentSize && txonBuffer.size > 0");

          // Add txBuffer.FirstBuffer to DataField

          dataFieldAddedSize = firstSegment->GetSize ();

          dataFieldTotalSize += dataFieldAddedSize;

          dataField.push_back (firstSegment);

          // ExtensionBit (Next_Segment - 1) = 1

          rlcAmHeader.PushExtensionBit (LteRlcAmHeader::E_LI_FIELDS_FOLLOWS);

          // LengthIndicator (Next_Segment)  = txBuffer.FirstBuffer.length()

          rlcAmHeader.PushLengthIndicator (firstSegment->GetSize ());

          nextSegmentSize -= ((nextSegmentId % 2) ? (2) : (1)) + dataFieldAddedSize;

          nextSegmentId++;

          NS_LOG_LOGIC ("        SDUs in TxBuffer  = " << m_txonBuffer.size ());

          if (m_txonBuffer.size () > 0)

            {

              NS_LOG_LOGIC ("        First SDU buffer  = " << *(m_txonBuffer.begin()));

              NS_LOG_LOGIC ("        First SDU size    = " << (*(m_txonBuffer.begin()))->GetSize ());

            }

          NS_LOG_LOGIC ("        Next segment size = " << nextSegmentSize);

          NS_LOG_LOGIC ("        Remove SDU from TxBuffer");

          // (more segments)

          firstSegment = (*(m_txonBuffer.begin ()))->Copy ();

          m_txonBufferSize -= (*(m_txonBuffer.begin()))->GetSize ();

          m_txonBuffer.erase (m_txonBuffer.begin ());

          NS_LOG_LOGIC ("        txBufferSize = " << m_txonBufferSize );

        }

    }

  //

  // Build RLC header

  //

  rlcAmHeader.SetSequenceNumber ( m_vtS++ );

  rlcAmHeader.SetResegmentationFlag (LteRlcAmHeader::PDU);

  rlcAmHeader.SetLastSegmentFlag (LteRlcAmHeader::LAST_PDU_SEGMENT);

  rlcAmHeader.SetSegmentOffset (0);

  // Calculate FramingInfo flag according the status of the SDUs in the DataField

  uint8_t framingInfo = 0;

  std::vector< Ptr<Packet> >::iterator it;

  it = dataField.begin ();

  // FIRST SEGMENT

  LteRlcSduStatusTag tag;

  (*it)->RemovePacketTag (tag);

  if ( (tag.GetStatus () == LteRlcSduStatusTag::FULL_SDU) ||

       (tag.GetStatus () == LteRlcSduStatusTag::FIRST_SEGMENT)

     )

    {

      framingInfo |= LteRlcAmHeader::FIRST_BYTE;

    }

  else

    {

      framingInfo |= LteRlcAmHeader::NO_FIRST_BYTE;

    }

  (*it)->AddPacketTag (tag);

  // Add all SDUs (in DataField) to the Packet

  while (it < dataField.end ())

    {

      NS_LOG_LOGIC ("Adding SDU/segment to packet, length = " << (*it)->GetSize ());

      packet->AddAtEnd (*it);

      it++;

    }

  // LAST SEGMENT (Note: There could be only one and be the first one)

  it--;

  (*it)->RemovePacketTag (tag);

  if ( (tag.GetStatus () == LteRlcSduStatusTag::FULL_SDU) ||

        (tag.GetStatus () == LteRlcSduStatusTag::LAST_SEGMENT) )

    {

      framingInfo |= LteRlcAmHeader::LAST_BYTE;

    }

  else

    {

      framingInfo |= LteRlcAmHeader::NO_LAST_BYTE;

    }

  (*it)->AddPacketTag (tag);

  // Set the FramingInfo flag after the calculation

  rlcAmHeader.SetFramingInfo (framingInfo);

  // Calculate the Polling Bit (5.2.2.1)

  rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_NOT_REQUESTED);

  m_pduWithoutPoll++;

  NS_LOG_LOGIC ("PDU_WITHOUT_POLL = " << m_pduWithoutPoll);

  m_byteWithoutPoll += packet->GetSize ();

  NS_LOG_LOGIC ("BYTE_WITHOUT_POLL = " << m_byteWithoutPoll);

  if ( (m_pduWithoutPoll >= m_pollPdu) || (m_byteWithoutPoll >= m_pollByte) ||

       ( (m_txonBuffer.empty ()) && (m_retxBuffer.empty ()) ) ||

       (m_vtS >= m_vtMs)

     )

    {

      rlcAmHeader.SetPollingBit (LteRlcAmHeader::STATUS_REPORT_IS_REQUESTED);

      m_pduWithoutPoll = 0;

      m_byteWithoutPoll = 0;

      m_pollSn = m_vtS - 1;

      NS_LOG_LOGIC ("New POLL_SN = " << m_pollSn);

      if (! m_pollRetransmitTimer.IsRunning () )

        {

          NS_LOG_LOGIC ("Start PollRetransmit timer");

          m_pollRetransmitTimer = Simulator::Schedule (Time ("0.1s"),

                                                       &LteRlcAm::ExpirePollRetransmitTimer, this);

        }

      else

        {

          NS_LOG_LOGIC ("Restart PollRetransmit timer");

          m_pollRetransmitTimer.Cancel ();

          m_pollRetransmitTimer = Simulator::Schedule (Time ("0.1s"),

                                                       &LteRlcAm::ExpirePollRetransmitTimer, this);

        }

    }

  // Build RLC PDU with DataField and Header

  NS_LOG_LOGIC ("AM RLC header: " << rlcAmHeader);

  packet->AddHeader (rlcAmHeader);

  // Store new PDU into the Transmitted PDU Buffer

  NS_LOG_LOGIC ("Put transmitted PDU in the txedBuffer");

  m_txedBufferSize += packet->GetSize ();

  m_txedBuffer.at ( rlcAmHeader.GetSequenceNumber ().GetValue () ) = packet->Copy ();

  // Sender timestamp

  RlcTag rlcTag (Simulator::Now ());

  packet->AddByteTag (rlcTag);

  m_txPdu (m_rnti, m_lcid, packet->GetSize ());

  // Send RLC PDU to MAC layer

  LteMacSapProvider::TransmitPduParameters params;

  params.pdu = packet;

  params.rnti = m_rnti;

  params.lcid = m_lcid;

  params.layer = layer;

  m_macSapProvider->TransmitPdu (params);

}

void

LteRlcAm::DoNotifyHarqDeliveryFailure ()

{

  NS_LOG_FUNCTION (this);

}

void

LteRlcAm::DoReceivePdu (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this << p->GetSize ());

  // Receiver timestamp

  RlcTag rlcTag;

  Time delay;

  if (p->FindFirstMatchingByteTag (rlcTag))