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

/*

 * Copyright (c) 2008,2009 IITP RAS

 *

 * 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: Kirill Andreev <andreev@iitp.ru>

 */

#include "hwmp-protocol.h"

#include "hwmp-mac-plugin.h"

#include "ns3/log.h"

#include "ns3/simulator.h"

#include "ns3/packet.h"

#include "ns3/mesh-point-device.h"

#include "ns3/wifi-net-device.h"

#include "ns3/mesh-point-device.h"

#include "ns3/mesh-wifi-interface-mac.h"

NS_LOG_COMPONENT_DEFINE ("HwmpProtocol");

namespace ns3 {

namespace dot11s {

NS_OBJECT_ENSURE_REGISTERED (HwmpProtocol);

TypeId

HwmpProtocol::GetTypeId ()

{

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

                      .SetParent<MeshL2RoutingProtocol> ()

                      .AddConstructor<HwmpProtocol> ();

  return tid;

}

//    m_rtable (CreateObject<HwmpRtable> ()),

//    m_broadcastPerr (false)

{

}

HwmpProtocol::~HwmpProtocol ()

{

}

void

HwmpProtocol::DoDispose ()

{

#if 0

  for (std::map<Mac48Address, EventId>::iterator i = m_timeoutDatabase.begin (); i != m_timeoutDatabase.end(); i ++)

    i->second.Cancel ();

  m_timeoutDatabase.clear ();

  m_seqnoDatabase.clear ();

  m_rtable = 0;

  /**

   * clear routing queue:

   */

  for (

    std::map<Mac48Address, std::queue<QueuedPacket> >::iterator i =  m_rqueue.begin ();

    i != m_rqueue.end ();

    i++

  )

    {

      while (1)

        {

          if (i->second.empty ())

            break;

          i->second.pop ();

        }

    }

  m_rqueue.clear ();

  /**

   * clear HWMP states

   */

  for (unsigned int i = 0; i < m_hwmpStates.size (); i ++)

    m_hwmpStates[i] = 0;

  m_hwmpStates.clear ();

#endif

}

bool

HwmpProtocol::RequestRoute (

  uint32_t sourceIface,

  const Mac48Address source,

  const Mac48Address destination,

  Ptr<Packet> packet,

  uint16_t protocolType, //ethrnet 'Protocol' field

  MeshL2RoutingProtocol::RouteReplyCallback routeReply

)

{

  NS_LOG_UNCOND("Packet has come!");

  if (sourceIface == GetMeshPoint ()->GetIfIndex())

    // packet from level 3

    {

    }

  else

    // packet from own interface

    {

      if (destination == Mac48Address::GetBroadcast ())

        {

          std::map<Mac48Address, uint32_t>::iterator i = m_seqnoDatabase.find (source);

          if (i == m_seqnoDatabase.end ())

            m_seqnoDatabase[source] = tag.GetSeqno ();

          else

            {

              if (i->second >= tag.GetSeqno ())

                return false;

              m_seqnoDatabase[source] = tag.GetSeqno ();

            }

        }

    }

  if (tag.GetTtl () == 0)

    return false;

  tag.DecrementTtl ();

  if (destination == Mac48Address::GetBroadcast ())

    {

      //add RA tag RA = broadcast

      packet->RemoveAllTags ();

      packet->AddTag (tag);

      routeReply (

        true,

        packet,

        source,

        destination,

        protocolType,

        HwmpRtable::PORT_ANY

      );

      return true;

    }

  result = m_rtable->LookupReactive (destination);

  if (result.retransmitter == Mac48Address::GetBroadcast ())

    {

      //no actual route exists, queue packet and start route

      //discover procedure

      if (sourceIface != GetMeshPoint ()->GetIfIndex())

        {

          //Start path error procedure:

          NS_LOG_DEBUG ("Must Send PERR");

          std::vector<HwmpRtable::FailedDestination> destinations;

          HwmpRtable::FailedDestination dst;

          dst.seqnum = m_rtable->RequestSeqnum (destination);

          dst.destination = destination;

          destinations.push_back (dst);

          StartPathErrorProcedure (destinations, result.ifIndex);

        }

      MeshL2RoutingProtocol::QueuedPacket pkt;

      packet->RemoveAllTags ();

      packet->AddTag (tag);

      pkt.pkt = packet;

      pkt.dst = destination;

      pkt.src = source;

      pkt.protocol = protocolType;

      pkt.reply = routeReply;

      pkt.inPort = sourceIface;

      QueuePacket (pkt);

      for (unsigned int i = 0; i< m_requestCallback.size (); i++)

        {

          if ((m_modes[i] == REACTIVE) || (m_modes[i] == ROOT))

            {

              if (ShouldSendPreq (destination))

                m_requestCallback[i] (destination);

            }

          else

            {

              NS_ASSERT (false);

              //PROACTIVE mode

              //lookup a default route

              result = m_rtable->LookupProactive (m_hwmpStates[i]->GetAssociatedIfaceId());

              if (result.retransmitter == Mac48Address::GetBroadcast ())

                {

                  m_rtable->DeleteProactivePath (m_hwmpStates[i]->GetAssociatedIfaceId());

                  m_modes[i] = REACTIVE;

                  if (ShouldSendPreq (destination))

                    m_requestCallback[i] (destination);

                  continue;

                }

              tag.SetAddress (result.retransmitter);

              packet->RemoveAllTags ();

              packet->AddTag (tag);

              routeReply (

                true,

                packet,

                source,

                destination,

                protocolType,

                result.ifIndex

              );

            }

        }

      for (unsigned int i = 0; i< m_requestCallback.size (); i++)

        {

          m_requestCallback[i] (Mac48Address("00:00:00:00:00:19"));

        }

    }

  else

    {

      tag.SetAddress (result.retransmitter);

      packet->RemoveAllTags ();

      packet->AddTag (tag);

      routeReply (

        true,

        packet,

        source,

        destination,

        protocolType,

        result.ifIndex

      );

    }

#endif

  return true;

}

bool

HwmpProtocol::Install (Ptr<MeshPointDevice> mp)

{

  m_mp = mp;

  std::vector<Ptr<NetDevice> > interfaces = mp->GetInterfaces ();

  for (std::vector<Ptr<NetDevice> >::iterator i = interfaces.begin (); i != interfaces.end(); i++)

    {

      //Checking netdevice:

      const WifiNetDevice * wifiNetDev = dynamic_cast<const WifiNetDevice *> (PeekPointer (*i));

      if (wifiNetDev == NULL)

        return false;

      MeshWifiInterfaceMac * mac = dynamic_cast<MeshWifiInterfaceMac *> (PeekPointer (wifiNetDev->GetMac ()));

      if (mac == NULL)

        return false;

      //Installing plugins:

      Ptr<HwmpMacPlugin> hwmpMac = Create<HwmpMacPlugin> (wifiNetDev->GetIfIndex (), this);

      m_interfaces[wifiNetDev->GetIfIndex ()] = hwmpMac;

      mac->InstallPlugin (hwmpMac);

    }

  mp->SetRoutingProtocol(this);

  return true;

}

#if 0

void

HwmpProtocol::DisablePort (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if ((*i)->GetAssociatedIfaceId () == port)

        {

          m_states[position] = DISABLED;

          m_hwmpStates[position]->Disable ();

          return;

        }

      position ++;

    }

}

void

HwmpProtocol::EnablePort (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if ((*i)->GetAssociatedIfaceId () == port)

        {

          m_states[position] = ENABLED;

          m_hwmpStates[position]->Enable ();

          return;

        }

      position ++;

    }

}

void

HwmpProtocol::SetRoot (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if (((*i)->GetAssociatedIfaceId () == port)||(port == HwmpRtable::PORT_ANY))

        {

          if (m_hwmpStates[position]->SetRoot ())

            {

              m_modes[position] = ROOT;

              NS_LOG_DEBUG ("I am proactive");

            }

        }

      position ++;

    }

}

void

HwmpProtocol::SetProactive (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if ((*i)->GetAssociatedIfaceId () == port)

        {

          m_modes[position] = PROACTIVE;

          return;

        }

      position ++;

    }

}

bool

HwmpProtocol::IsRoot (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if ((*i)->GetAssociatedIfaceId () == port)

        if (m_modes[position] == ROOT)

          return true;

      position ++;

    }

  return false;

}

void

HwmpProtocol::UnSetRoot (uint32_t port)

{

  int position = 0;

  for (std::vector<Ptr<HwmpProtocolState> >::iterator i = m_hwmpStates.begin (); i != m_hwmpStates.end(); i++)

    {

      if (((*i)->GetAssociatedIfaceId () == port)||(port == HwmpRtable::PORT_ANY))

        {

          m_modes[position] = REACTIVE;

          m_hwmpStates[position]->UnSetRoot ();

        }

      position ++;

    }

}

void

HwmpProtocol::ObtainRoutingInformation (

  HwmpProtocolState::INFO info

)

{

  switch (info.type)

    {

    case HwmpProtocolState::INFO_PREP:

      if (info.me != info.source)

        {

          m_rtable->AddPrecursor (info.source, info.outPort, info.nextHop);

          m_rtable->AddPrecursor (info.destination, info.outPort, info.prevHop);

          NS_LOG_DEBUG ("path to "<<info.source<<" precursor is "<<info.nextHop);

          NS_LOG_DEBUG ("path to "<<info.destination<<" precursor is "<<info.prevHop);

        }

    case HwmpProtocolState::INFO_PREQ:

      m_rtable->AddReactivePath (

        info.destination,

        info.nextHop,

        info.outPort,

        info.metric,

        info.lifetime,

        info.dsn);

      SendAllPossiblePackets (info.destination);

      break;

    case HwmpProtocolState::INFO_PERR:

      //delete first subentry

    case HwmpProtocolState::INFO_PROACTIVE:

      //add information to the root MP.

      m_rtable->AddProactivePath (

        info.metric,

        info.destination,

        info.nextHop,

        info.outPort,

        info.lifetime,

        info.dsn);

      //Set mode as PROACTIVE:

      SetProactive (info.outPort);

      break;

    case HwmpProtocolState::INFO_NEW_PEER:

#if 0

      m_rtable->AddReactivePath (

        info.destination,

        info.nextHop,

        info.outPort,

        info.metric,

        Seconds (0),

        0);

#endif

      break;

    case HwmpProtocolState::INFO_FAILED_PEER:

      /**

       * Conditions for generating PERR

       */

    {

      NS_LOG_DEBUG ("Failed peer"<<info.destination);

      std::vector<HwmpRtable::FailedDestination> failedDestinations =

        m_rtable->GetUnreachableDestinations (info.destination, info.outPort);

      /**

       * Entry about peer does not contain seqnum

       */

      HwmpRtable::FailedDestination peer;

      peer.destination = info.destination;

      peer.seqnum = 0;

      failedDestinations.push_back (peer);

      StartPathErrorProcedure (failedDestinations, info.outPort);

    }

    break;

    default:

      return;

    }

}

HwmpRtable::LookupResult

HwmpProtocol::RequestRouteForAddress (const Mac48Address& dst)

{

  return m_rtable->LookupReactive (dst);

}

HwmpRtable::LookupResult

HwmpProtocol::RequestRootPathForPort (uint32_t port)

{

  return m_rtable->LookupProactive (port);

}

void

HwmpProtocol::StartPathErrorProcedure (std::vector<HwmpRtable::FailedDestination> destinations, uint32_t port)

{

  NS_LOG_DEBUG ("START PERR");

  for (unsigned int i  = 0; i < m_hwmpStates.size (); i++)

    if (m_hwmpStates[i]->GetAssociatedIfaceId () == port)

      m_pathErrorCallback[i] (destinations);

}

std::vector<Mac48Address>

HwmpProtocol::GetRetransmittersForFailedDestinations (std::vector<HwmpRtable::FailedDestination> failedDest, uint32_t port)

{

  std::vector<Mac48Address> retransmitters;

  if (m_broadcastPerr)

    retransmitters.push_back (Mac48Address::GetBroadcast());

  else