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

/*

 * Copyright (c) 2007,2008,2009 INRIA, UDcast

 *

 * 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

 *

 * Authors: Jahanzeb Farooq <jahanzeb.farooq@sophia.inria.fr>

 *          Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>

 *                               <amine.ismail@UDcast.com>

 */

#include "ns3/simulator.h"

#include "ns3/drop-tail-queue.h"

#include "ns3/node.h"

#include "ss-net-device.h"

#include "wimax-phy.h"

#include "ns3/packet-burst.h"

#include <algorithm>

#include "dl-mac-messages.h"

#include "ul-mac-messages.h"

#include "ss-scheduler.h"

#include "wimax-mac-queue.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/pointer.h"

#include "ns3/enum.h"

#include "service-flow.h"

#include "service-flow-record.h"

#include "service-flow-manager.h"

#include "connection-manager.h"

#include "burst-profile-manager.h"

#include "ss-link-manager.h"

#include "bandwidth-manager.h"

NS_OBJECT_ENSURE_REGISTERED (SubscriberStationNetDevice);

Time SubscriberStationNetDevice::GetDefaultLostDlMapInterval ()

{

  return (MicroSeconds (500000));

}

TypeId

SubscriberStationNetDevice::GetTypeId (void)

{

  static TypeId

    tid =

    TypeId ("ns3::SubscriberStationNetDevice")

    .SetParent<WimaxNetDevice> ()

    .AddConstructor<SubscriberStationNetDevice> ()

    .AddAttribute ("BasicConnection",

                   "Basic connection",

                   PointerValue (),

                   MakePointerAccessor (&SubscriberStationNetDevice::m_basicConnection),

                   MakePointerChecker<WimaxConnection> ())

    .AddAttribute ("PrimaryConnection",

                   "Primary connection",

                   PointerValue (),

                   MakePointerAccessor (&SubscriberStationNetDevice::m_primaryConnection),

                   MakePointerChecker<WimaxConnection> ())

    .AddAttribute ("LostDlMapInterval",

                   "Time since last received DL-MAP message before downlink synchronization is considered lost. Maximum is 600ms",

                   TimeValue (Seconds (0.5)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetLostDlMapInterval,

                                     &SubscriberStationNetDevice::SetLostDlMapInterval),

                   MakeTimeChecker ())

    .AddAttribute ("LostUlMapInterval",

                   "Time since last received UL-MAP before uplink synchronization is considered lost, maximum is 600.",

                   TimeValue (MilliSeconds (500)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetLostUlMapInterval,

                                     &SubscriberStationNetDevice::SetLostUlMapInterval),

                   MakeTimeChecker ())

    .AddAttribute ("MaxDcdInterval",

                   "Maximum time between transmission of DCD messages. Maximum is 10s",

                   TimeValue (Seconds (10)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetMaxDcdInterval,

                                     &SubscriberStationNetDevice::SetMaxDcdInterval),

                   MakeTimeChecker ())

    .AddAttribute ("MaxUcdInterval",

                   "Maximum time between transmission of UCD messages. Maximum is 10s",

                   TimeValue (Seconds (10)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetMaxUcdInterval,

                                     &SubscriberStationNetDevice::SetMaxUcdInterval),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT1",

                   "Wait for DCD timeout. Maximum is 5*maxDcdInterval",

                   TimeValue (Seconds (50)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT1,

                                     &SubscriberStationNetDevice::SetIntervalT1),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT2",

                   "Wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity. Maximum is 5*Ranging interval",

                   TimeValue (Seconds (10)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT2,

                                     &SubscriberStationNetDevice::SetIntervalT2),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT3",

                   "ranging Response reception timeout following the transmission of a ranging request. Maximum is 200ms",

                   TimeValue (Seconds (0.2)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT3,

                                     &SubscriberStationNetDevice::SetIntervalT3),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT7",

                   "wait for DSA/DSC/DSD Response timeout. Maximum is 1s",

                   TimeValue (Seconds (0.1)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT7,

                                     &SubscriberStationNetDevice::SetIntervalT7),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT12",

                   "Wait for UCD descriptor.Maximum is 5*MaxUcdInterval",

                   TimeValue (Seconds (10)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT12,

                                     &SubscriberStationNetDevice::SetIntervalT12),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT20",

                   "Time the SS searches for preambles on a given channel. Minimum is 2 MAC frames",

                   TimeValue (Seconds (0.5)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT20,

                                     &SubscriberStationNetDevice::SetIntervalT20),

                   MakeTimeChecker ())

    .AddAttribute ("IntervalT21",

                   "time the SS searches for (decodable) DL-MAP on a given channel",

                   TimeValue (Seconds (10)),

                   MakeTimeAccessor (&SubscriberStationNetDevice::GetIntervalT21,

                                     &SubscriberStationNetDevice::SetIntervalT21),

                   MakeTimeChecker ())

    .AddAttribute ("MaxContentionRangingRetries",

                   "Number of retries on contention Ranging Requests",

                   UintegerValue (16),

                   MakeUintegerAccessor (&SubscriberStationNetDevice::GetMaxContentionRangingRetries,

                                         &SubscriberStationNetDevice::SetMaxContentionRangingRetries),

                   MakeUintegerChecker<uint8_t> (1, 16))

    .AddAttribute ("SSScheduler",

                   "The ss scheduler attached to this device.",

                   PointerValue (),

                   MakePointerAccessor (&SubscriberStationNetDevice::GetScheduler,

                                        &SubscriberStationNetDevice::SetScheduler),

                   MakePointerChecker<SSScheduler> ())

    .AddAttribute ("LinkManager",

                   "The ss link manager attached to this device.",

                   PointerValue (),

                   MakePointerAccessor (&SubscriberStationNetDevice::GetLinkManager,

                                        &SubscriberStationNetDevice::SetLinkManager),

                   MakePointerChecker<SSLinkManager> ())

    .AddAttribute ("Classifier",

                   "The ss classifier attached to this device.",

                   PointerValue (),

                   MakePointerAccessor (&SubscriberStationNetDevice::GetIpcsClassifier,

                                        &SubscriberStationNetDevice::SetIpcsPacketClassifier),

                   MakePointerChecker<IpcsClassifier> ())

    .AddTraceSource ("SSTxDrop",

                     "A packet has been dropped in the MAC layer before being queued for transmission.",

                     MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssTxDropTrace))

    .AddTraceSource ("SSPromiscRx",

                     "A packet has been received by this device, has been passed up from the physical layer "

                     "and is being forwarded up the local protocol stack.  This is a promiscuous trace,",

                     MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssPromiscRxTrace))

    .AddTraceSource ("SSRx",

                     "A packet has been received by this device, has been passed up from the physical layer "

                     "and is being forwarded up the local protocol stack.  This is a non-promiscuous trace,",

                     MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssRxTrace))

    .AddTraceSource ("SSRxDrop",

                     "A packet has been dropped in the MAC layer after it has been passed up from the physical "

                     "layer.",

                     MakeTraceSourceAccessor (&SubscriberStationNetDevice::m_ssRxDropTrace));

  return tid;

}

SubscriberStationNetDevice::SubscriberStationNetDevice (void)

{

  InitSubscriberStationNetDevice ();

}

void

SubscriberStationNetDevice::InitSubscriberStationNetDevice (void)

{

  m_lostDlMapInterval = MilliSeconds (500);

  m_lostUlMapInterval = MilliSeconds (500);

  m_maxDcdInterval = Seconds (10);

  m_maxUcdInterval = Seconds (10);

  m_intervalT1 = Seconds (5 * m_maxDcdInterval.GetSeconds ());

  m_intervalT2 = Seconds (5 * 2); // shall be 5 * RangingInterval, if ranging interval=see T2 at page 638) means Initial Ranging Interval=see page 637)

  m_intervalT3 = MilliSeconds (200);

  m_intervalT7 = Seconds (0.1); // maximum is 1

  m_intervalT12 = Seconds (5 * m_maxUcdInterval.GetSeconds ());

  m_intervalT21 = Seconds (11);

  m_maxContentionRangingRetries = 16;

  m_dcdCount = 0;

  m_baseStationId = Mac48Address ("00:00:00:00:00:00");

  m_ucdCount = 0;

  m_allocationStartTime = 0;

  m_nrDlMapElements = 0;

  m_nrUlMapElements = 0;

  m_nrDlMapRecvd = 0;

  m_nrUlMapRecvd = 0;

  m_nrDcdRecvd = 0;

  m_nrUcdRecvd = 0;

  m_modulationType = WimaxPhy::MODULATION_TYPE_BPSK_12;

  m_areManagementConnectionsAllocated = false;

  m_areServiceFlowsAllocated = false;

  m_basicConnection = 0;

  m_primaryConnection = 0;

  m_dlBurstProfile = new OfdmDlBurstProfile ();

  m_ulBurstProfile = new OfdmUlBurstProfile ();

  m_classifier = CreateObject<IpcsClassifier> ();

  m_linkManager = CreateObject<SSLinkManager> (this);

  m_scheduler = CreateObject<SSScheduler> (this);

  m_serviceFlowManager = CreateObject<SsServiceFlowManager> (this);

}

SubscriberStationNetDevice::SubscriberStationNetDevice (Ptr<Node> node, Ptr<WimaxPhy> phy)

{

  InitSubscriberStationNetDevice ();

  this->SetNode (node);

  this->SetPhy (phy);

}

SubscriberStationNetDevice::~SubscriberStationNetDevice (void)

{

}

void

SubscriberStationNetDevice::DoDispose (void)

{

  delete m_dlBurstProfile;

  delete m_ulBurstProfile;

  m_scheduler = 0;

  m_serviceFlowManager = 0;

  m_basicConnection = 0;

  m_primaryConnection = 0;

  m_classifier = 0;

  m_dlBurstProfile = 0;

  m_ulBurstProfile = 0;

  m_linkManager = 0;

  WimaxNetDevice::DoDispose ();

}

void

SubscriberStationNetDevice::SetLostDlMapInterval (Time lostDlMapInterval)

{

  m_lostDlMapInterval = lostDlMapInterval;

}

Time

SubscriberStationNetDevice::GetLostDlMapInterval (void) const

{

  return m_lostDlMapInterval;

}

void

SubscriberStationNetDevice::SetLostUlMapInterval (Time lostUlMapInterval)

{

  m_lostUlMapInterval = lostUlMapInterval;

}

Time

SubscriberStationNetDevice::GetLostUlMapInterval (void) const

{

  return m_lostUlMapInterval;

}

void

SubscriberStationNetDevice::SetMaxDcdInterval (Time maxDcdInterval)

{

  m_maxDcdInterval = maxDcdInterval;

}

Time

SubscriberStationNetDevice::GetMaxDcdInterval (void) const

{

  return m_maxDcdInterval;

}

void

SubscriberStationNetDevice::SetMaxUcdInterval (Time maxUcdInterval)

{

  m_maxUcdInterval = maxUcdInterval;

}

Time

SubscriberStationNetDevice::GetMaxUcdInterval (void) const

{

  return m_maxUcdInterval;

}

void

SubscriberStationNetDevice::SetIntervalT1 (Time interval)

{

  m_intervalT1 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT1 (void) const

{

  return m_intervalT1;

}

void

SubscriberStationNetDevice::SetIntervalT2 (Time interval)

{

  m_intervalT2 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT2 (void) const

{

  return m_intervalT2;

}

void

SubscriberStationNetDevice::SetIntervalT3 (Time interval)

{

  m_intervalT3 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT3 (void) const

{

  return m_intervalT3;

}

void

SubscriberStationNetDevice::SetIntervalT7 (Time interval)

{

  m_intervalT7 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT7 (void) const

{

  return m_intervalT7;

}

void

SubscriberStationNetDevice::SetIntervalT12 (Time interval)

{

  m_intervalT12 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT12 (void) const

{

  return m_intervalT12;

}

void

SubscriberStationNetDevice::SetIntervalT20 (Time interval)

{

  m_intervalT20 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT20 (void) const

{

  return m_intervalT20;

}

void

SubscriberStationNetDevice::SetIntervalT21 (Time interval)

{

  m_intervalT21 = interval;

}

Time

SubscriberStationNetDevice::GetIntervalT21 (void) const

{

  return m_intervalT21;

}

void

SubscriberStationNetDevice::SetMaxContentionRangingRetries (uint8_t maxContentionRangingRetries)

{

  m_maxContentionRangingRetries = maxContentionRangingRetries;

}

uint8_t

SubscriberStationNetDevice::GetMaxContentionRangingRetries (void) const

{

  return m_maxContentionRangingRetries;

}

void

SubscriberStationNetDevice::SetBasicConnection (Ptr<WimaxConnection> basicConnection)

{

  m_basicConnection = basicConnection;

}

Ptr<WimaxConnection>

SubscriberStationNetDevice::GetBasicConnection (void) const

{

  return m_basicConnection;

}

void

SubscriberStationNetDevice::SetPrimaryConnection (Ptr<WimaxConnection> primaryConnection)

{

  m_primaryConnection = primaryConnection;

}

Ptr<WimaxConnection>

SubscriberStationNetDevice::GetPrimaryConnection (void) const

{

  return m_primaryConnection;

}

Cid

SubscriberStationNetDevice::GetBasicCid (void) const

{

  return m_basicConnection->GetCid ();

}

Cid

SubscriberStationNetDevice::GetPrimaryCid (void) const

{

  return m_primaryConnection->GetCid ();

}

void

SubscriberStationNetDevice::SetModulationType (WimaxPhy::ModulationType modulationType)

{

  m_modulationType = modulationType;

}

WimaxPhy::ModulationType

SubscriberStationNetDevice::GetModulationType (void) const

{

  return m_modulationType;

}

void

SubscriberStationNetDevice::SetAreManagementConnectionsAllocated (bool areManagementConnectionsAllocated)

{

  m_areManagementConnectionsAllocated = areManagementConnectionsAllocated;

}

bool

SubscriberStationNetDevice::GetAreManagementConnectionsAllocated (void) const

{

  return m_areManagementConnectionsAllocated;

}

void

SubscriberStationNetDevice::SetAreServiceFlowsAllocated (bool areServiceFlowsAllocated)

{

  m_areServiceFlowsAllocated = areServiceFlowsAllocated;

}

bool

SubscriberStationNetDevice::GetAreServiceFlowsAllocated (void) const

{

  return m_areServiceFlowsAllocated;

}

Ptr<SSScheduler>

SubscriberStationNetDevice::GetScheduler (void) const

{

  return m_scheduler;

}

void

SubscriberStationNetDevice::SetScheduler (Ptr<SSScheduler> scheduler)

{

  m_scheduler = scheduler;

}

bool

SubscriberStationNetDevice::HasServiceFlows (void) const

{

  return GetServiceFlowManager ()->GetServiceFlows (ServiceFlow::SF_TYPE_ALL).size () > 0;

}

Ptr<IpcsClassifier>

SubscriberStationNetDevice::GetIpcsClassifier () const

{

  return m_classifier;

}

void

SubscriberStationNetDevice::SetIpcsPacketClassifier (Ptr<IpcsClassifier> classifier)

{

  m_classifier = classifier;

}

Ptr<SSLinkManager>