/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2012 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/log.h"

#include "ns3/inet-socket-address.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/epc-x2-header.h"

#include "ns3/epc-x2.h"

NS_LOG_COMPONENT_DEFINE ("EpcX2");

namespace ns3 {

{

  m_remoteIpAddr = remoteIpAddr;

}

X2IfaceInfo::~X2IfaceInfo (void)

{

}

X2IfaceInfo& 

X2IfaceInfo::operator= (const X2IfaceInfo& value)

{

  NS_LOG_FUNCTION (this);

  m_remoteIpAddr = value.m_remoteIpAddr;

  return *this;

}

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

X2CellInfo::X2CellInfo (uint16_t localCellId, uint16_t remoteCellId)

{

  m_localCellId = localCellId;

  m_remoteCellId = remoteCellId;

}

X2CellInfo::~X2CellInfo (void)

{

  m_localCellId = 0;

  m_remoteCellId = 0;

}

X2CellInfo& 

X2CellInfo::operator= (const X2CellInfo& value)

{

  NS_LOG_FUNCTION (this);

  m_localCellId = value.m_localCellId;

  m_remoteCellId = value.m_remoteCellId;

  return *this;

}

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

NS_OBJECT_ENSURE_REGISTERED (EpcX2);

EpcX2::EpcX2 ()

{

  NS_LOG_FUNCTION (this);

  m_x2SapProvider = new EpcX2SpecificEpcX2SapProvider<EpcX2> (this);

}

EpcX2::~EpcX2 ()

{

  NS_LOG_FUNCTION (this);

}

void

EpcX2::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

  m_x2InterfaceSockets.clear ();

  m_x2InterfaceCellIds.clear ();

  delete m_x2SapProvider;

}

TypeId

EpcX2::GetTypeId (void)

{

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

    .SetParent<Object> ();

  return tid;

}

void

EpcX2::SetEpcX2SapUser (EpcX2SapUser * s)

{

  NS_LOG_FUNCTION (this << s);

  m_x2SapUser = s;

}

EpcX2SapProvider*

EpcX2::GetEpcX2SapProvider ()

{

  NS_LOG_FUNCTION (this);

  return m_x2SapProvider;

}

void

{

  int retval;

  NS_ASSERT (retval == 0);

}

void 

EpcX2::RecvFromX2cSocket (Ptr<Socket> socket)

{

  NS_LOG_FUNCTION (this << socket);

  NS_LOG_LOGIC ("Recv X2 message: from Socket");

  Ptr<Packet> packet = socket->Recv ();

  NS_LOG_LOGIC ("packetLen = " << packet->GetSize ());

  NS_ASSERT_MSG (m_x2InterfaceCellIds.find (socket) != m_x2InterfaceCellIds.end (),

                 "Missing infos of local and remote CellId");

  Ptr<X2CellInfo> cellsInfo = m_x2InterfaceCellIds [socket];

  EpcX2Header x2Header;

  packet->RemoveHeader (x2Header);

  NS_LOG_LOGIC ("X2 header: " << x2Header);

  uint8_t messageType = x2Header.GetMessageType ();

  uint8_t procedureCode = x2Header.GetProcedureCode ();

  if (procedureCode == EpcX2Header::HandoverPreparation)

    {

      if (messageType == EpcX2Header::InitiatingMessage)

        {

          NS_LOG_LOGIC ("Recv X2 message: HANDOVER REQUEST");

          EpcX2HandoverRequestHeader x2HoReqHeader;

          packet->RemoveHeader (x2HoReqHeader);

          NS_LOG_INFO ("X2 HandoverRequest header: " << x2HoReqHeader);

          EpcX2SapUser::HandoverRequestParams params;

          params.oldEnbUeX2apId = x2HoReqHeader.GetOldEnbUeX2apId ();

          params.cause          = x2HoReqHeader.GetCause ();

          params.sourceCellId   = cellsInfo->m_remoteCellId;

          params.targetCellId   = x2HoReqHeader.GetTargetCellId ();

          params.ueAggregateMaxBitRateDownlink = x2HoReqHeader.GetUeAggregateMaxBitRateDownlink ();

          params.ueAggregateMaxBitRateUplink   = x2HoReqHeader.GetUeAggregateMaxBitRateUplink ();

          params.bearers        = x2HoReqHeader.GetBearers ();

          params.rrcContext     = packet;

          NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

          NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

          NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

          NS_LOG_LOGIC ("cellsInfo->m_localCellId = " << cellsInfo->m_localCellId);

          NS_ASSERT_MSG (params.targetCellId == cellsInfo->m_localCellId,

                         "TargetCellId mismatches with localCellId");

          m_x2SapUser->RecvHandoverRequest (params);

        }

      else if (messageType == EpcX2Header::SuccessfulOutcome)

        {

          NS_LOG_LOGIC ("Recv X2 message: HANDOVER REQUEST ACK");

          EpcX2HandoverRequestAckHeader x2HoReqAckHeader;

          packet->RemoveHeader (x2HoReqAckHeader);

          NS_LOG_INFO ("X2 HandoverRequestAck header: " << x2HoReqAckHeader);

          EpcX2SapUser::HandoverRequestAckParams params;          

          params.oldEnbUeX2apId = x2HoReqAckHeader.GetOldEnbUeX2apId ();

          params.newEnbUeX2apId = x2HoReqAckHeader.GetNewEnbUeX2apId ();

          params.sourceCellId   = cellsInfo->m_localCellId;

          params.targetCellId   = cellsInfo->m_remoteCellId;

          params.admittedBearers = x2HoReqAckHeader.GetAdmittedBearers ();

          params.notAdmittedBearers = x2HoReqAckHeader.GetNotAdmittedBearers ();

          params.rrcContext     = packet;

          NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

          NS_LOG_LOGIC ("newEnbUeX2apId = " << params.newEnbUeX2apId);

          NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

          NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

          m_x2SapUser->RecvHandoverRequestAck (params);

        }

      else // messageType == EpcX2Header::UnsuccessfulOutcome

        {

          NS_LOG_LOGIC ("Recv X2 message: HANDOVER PREPARATION FAILURE");

          EpcX2HandoverPreparationFailureHeader x2HoPrepFailHeader;

          packet->RemoveHeader (x2HoPrepFailHeader);

          NS_LOG_INFO ("X2 HandoverPreparationFailure header: " << x2HoPrepFailHeader);

          EpcX2SapUser::HandoverPreparationFailureParams params;          

          params.oldEnbUeX2apId = x2HoPrepFailHeader.GetOldEnbUeX2apId ();

          params.sourceCellId   = cellsInfo->m_localCellId;

          params.targetCellId   = cellsInfo->m_remoteCellId;

          params.cause          = x2HoPrepFailHeader.GetCause ();

          params.criticalityDiagnostics = x2HoPrepFailHeader.GetCriticalityDiagnostics ();

          NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

          NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

          NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

          NS_LOG_LOGIC ("cause = " << params.cause);

          NS_LOG_LOGIC ("criticalityDiagnostics = " << params.criticalityDiagnostics);

          m_x2SapUser->RecvHandoverPreparationFailure (params);

        }

    }

  else if (procedureCode == EpcX2Header::LoadIndication)

    {

      if (messageType == EpcX2Header::InitiatingMessage)

        {

          NS_LOG_LOGIC ("Recv X2 message: LOAD INFORMATION");

          EpcX2LoadInformationHeader x2LoadInfoHeader;

          packet->RemoveHeader (x2LoadInfoHeader);

          NS_LOG_INFO ("X2 LoadInformation header: " << x2LoadInfoHeader);

          EpcX2SapUser::LoadInformationParams params;

          params.cellInformationList = x2LoadInfoHeader.GetCellInformationList ();

          NS_LOG_LOGIC ("cellInformationList size = " << params.cellInformationList.size ());

          m_x2SapUser->RecvLoadInformation (params);

        }

    }

  else if (procedureCode == EpcX2Header::SnStatusTransfer)

    {

      if (messageType == EpcX2Header::InitiatingMessage)

        {

          NS_LOG_LOGIC ("Recv X2 message: SN STATUS TRANSFER");

            EpcX2SnStatusTransferHeader x2SnStatusXferHeader;

            packet->RemoveHeader (x2SnStatusXferHeader);

            NS_LOG_INFO ("X2 SnStatusTransfer header: " << x2SnStatusXferHeader);

            EpcX2SapUser::SnStatusTransferParams params;

            params.oldEnbUeX2apId = x2SnStatusXferHeader.GetOldEnbUeX2apId ();

            params.newEnbUeX2apId = x2SnStatusXferHeader.GetNewEnbUeX2apId ();

            params.sourceCellId   = cellsInfo->m_remoteCellId;

            params.targetCellId   = cellsInfo->m_localCellId;

            params.erabsSubjectToStatusTransferList = x2SnStatusXferHeader.GetErabsSubjectToStatusTransferList ();

            NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

            NS_LOG_LOGIC ("newEnbUeX2apId = " << params.newEnbUeX2apId);

            NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

            NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

            NS_LOG_LOGIC ("erabsList size = " << params.erabsSubjectToStatusTransferList.size ());

            m_x2SapUser->RecvSnStatusTransfer (params);

        }

    }

  else if (procedureCode == EpcX2Header::UeContextRelease)

    {

      if (messageType == EpcX2Header::InitiatingMessage)

        {

          NS_LOG_LOGIC ("Recv X2 message: UE CONTEXT RELEASE");

          EpcX2UeContextReleaseHeader x2UeCtxReleaseHeader;

          packet->RemoveHeader (x2UeCtxReleaseHeader);

          NS_LOG_INFO ("X2 UeContextRelease header: " << x2UeCtxReleaseHeader);

          EpcX2SapUser::UeContextReleaseParams params;

          params.oldEnbUeX2apId = x2UeCtxReleaseHeader.GetOldEnbUeX2apId ();

          params.newEnbUeX2apId = x2UeCtxReleaseHeader.GetNewEnbUeX2apId ();

          NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

          NS_LOG_LOGIC ("newEnbUeX2apId = " << params.newEnbUeX2apId);

          m_x2SapUser->RecvUeContextRelease (params);

        }

    }

  else if (procedureCode == EpcX2Header::ResourceStatusReporting)

    {

      if (messageType == EpcX2Header::InitiatingMessage)

        {

          NS_LOG_LOGIC ("Recv X2 message: RESOURCE STATUS UPDATE");

          EpcX2ResourceStatusUpdateHeader x2ResStatUpdHeader;

          packet->RemoveHeader (x2ResStatUpdHeader);

          NS_LOG_INFO ("X2 ResourceStatusUpdate header: " << x2ResStatUpdHeader);

          EpcX2SapUser::ResourceStatusUpdateParams params;

          params.enb1MeasurementId = x2ResStatUpdHeader.GetEnb1MeasurementId ();

          params.enb2MeasurementId = x2ResStatUpdHeader.GetEnb2MeasurementId ();

          params.cellMeasurementResultList = x2ResStatUpdHeader.GetCellMeasurementResultList ();

          NS_LOG_LOGIC ("enb1MeasurementId = " << params.enb1MeasurementId);

          NS_LOG_LOGIC ("enb2MeasurementId = " << params.enb2MeasurementId);

          NS_LOG_LOGIC ("cellMeasurementResultList size = " << params.cellMeasurementResultList.size ());

          m_x2SapUser->RecvResourceStatusUpdate (params);

        }

    }

  else

    {

      NS_ASSERT_MSG (false, "ProcedureCode NOT SUPPORTED!!!");

    }

}

//

// Implementation of the X2 SAP Provider

//

void

EpcX2::DoSendHandoverRequest (EpcX2SapProvider::HandoverRequestParams params)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

  NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

  NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

  NS_ASSERT_MSG (m_x2InterfaceSockets.find (params.targetCellId) != m_x2InterfaceSockets.end (),

                 "Missing infos for targetCellId = " << params.targetCellId);

  Ptr<X2IfaceInfo> socketInfo = m_x2InterfaceSockets [params.targetCellId];

  Ipv4Address targetIpAddr = socketInfo->m_remoteIpAddr;

  NS_LOG_LOGIC ("sourceSocket = " << sourceSocket);

  NS_LOG_LOGIC ("targetIpAddr = " << targetIpAddr);

  NS_LOG_INFO ("Send X2 message: HANDOVER REQUEST");

  // Build the X2 message

  EpcX2HandoverRequestHeader x2HoReqHeader;

  x2HoReqHeader.SetOldEnbUeX2apId (params.oldEnbUeX2apId);

  x2HoReqHeader.SetCause (params.cause);

  x2HoReqHeader.SetTargetCellId (params.targetCellId);

  x2HoReqHeader.SetUeAggregateMaxBitRateDownlink (params.ueAggregateMaxBitRateDownlink);

  x2HoReqHeader.SetUeAggregateMaxBitRateUplink (params.ueAggregateMaxBitRateUplink);

  x2HoReqHeader.SetBearers (params.bearers);

  EpcX2Header x2Header;

  x2Header.SetMessageType (EpcX2Header::InitiatingMessage);

  x2Header.SetProcedureCode (EpcX2Header::HandoverPreparation);

  x2Header.SetLengthOfIes (x2HoReqHeader.GetLengthOfIes ());

  x2Header.SetNumberOfIes (x2HoReqHeader.GetNumberOfIes ());

  NS_LOG_INFO ("X2 header: " << x2Header);

  NS_LOG_INFO ("X2 HandoverRequest header: " << x2HoReqHeader);

  // Build the X2 packet

  Ptr<Packet> packet = (params.rrcContext != 0) ? (params.rrcContext) : (Create <Packet> ());

  packet->AddHeader (x2HoReqHeader);

  packet->AddHeader (x2Header);

  NS_LOG_INFO ("packetLen = " << packet->GetSize ());

  // Send the X2 message through the socket

  sourceSocket->SendTo (packet, 0, InetSocketAddress (targetIpAddr, m_x2cUdpPort));

}

void

EpcX2::DoSendHandoverRequestAck (EpcX2SapProvider::HandoverRequestAckParams params)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

  NS_LOG_LOGIC ("newEnbUeX2apId = " << params.newEnbUeX2apId);

  NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);

  NS_LOG_LOGIC ("targetCellId = " << params.targetCellId);

  NS_ASSERT_MSG (m_x2InterfaceSockets.find (params.sourceCellId) != m_x2InterfaceSockets.end (),

                 "Socket infos not defined for sourceCellId = " << params.sourceCellId);

  Ipv4Address remoteIpAddr = m_x2InterfaceSockets [params.sourceCellId]->m_remoteIpAddr;

  NS_LOG_LOGIC ("localSocket = " << localSocket);

  NS_LOG_LOGIC ("remoteIpAddr = " << remoteIpAddr);

  NS_LOG_INFO ("Send X2 message: HANDOVER REQUEST ACK");

  // Build the X2 message

  EpcX2HandoverRequestAckHeader x2HoAckHeader;

  x2HoAckHeader.SetOldEnbUeX2apId (params.oldEnbUeX2apId);

  x2HoAckHeader.SetNewEnbUeX2apId (params.newEnbUeX2apId);

  x2HoAckHeader.SetAdmittedBearers (params.admittedBearers);

  x2HoAckHeader.SetNotAdmittedBearers (params.notAdmittedBearers);

  EpcX2Header x2Header;

  x2Header.SetMessageType (EpcX2Header::SuccessfulOutcome);

  x2Header.SetProcedureCode (EpcX2Header::HandoverPreparation);

  x2Header.SetLengthOfIes (x2HoAckHeader.GetLengthOfIes ());

  x2Header.SetNumberOfIes (x2HoAckHeader.GetNumberOfIes ());

  NS_LOG_INFO ("X2 header: " << x2Header);

  NS_LOG_INFO ("X2 HandoverAck header: " << x2HoAckHeader);

  NS_LOG_INFO ("RRC context: " << params.rrcContext);

  // Build the X2 packet

  Ptr<Packet> packet = (params.rrcContext != 0) ? (params.rrcContext) : (Create <Packet> ());

  packet->AddHeader (x2HoAckHeader);

  packet->AddHeader (x2Header);

  NS_LOG_INFO ("packetLen = " << packet->GetSize ());

  // Send the X2 message through the socket

  localSocket->SendTo (packet, 0, InetSocketAddress (remoteIpAddr, m_x2cUdpPort));

}

void

EpcX2::DoSendHandoverPreparationFailure (EpcX2SapProvider::HandoverPreparationFailureParams params)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC ("oldEnbUeX2apId = " << params.oldEnbUeX2apId);

  NS_LOG_LOGIC ("sourceCellId = " << params.sourceCellId);