/* -*-  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
 *
 * Author: Kirill Andreev <andreev@iitp.ru>
 *         Pavel Boyko <boyko@iitp.ru>
 */


#include "ns3/node.h"
#include "ns3/packet.h"
#include "ns3/log.h"
#include "ns3/pointer.h"
#include "ns3/mesh-point-device.h"
#include "ns3/wifi-net-device.h"
#include "ns3/mesh-wifi-interface-mac.h"

NS_LOG_COMPONENT_DEFINE ("MeshPointDevice");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (MeshPointDevice);

TypeId
MeshPointDevice::GetTypeId ()
{
  static TypeId tid = TypeId ("ns3::MeshPointDevice")
                      .SetParent<NetDevice> ()
                      .AddConstructor<MeshPointDevice> ()
                      .AddAttribute ("RoutingProtocol", "The mesh routing protocol used by this mesh point.",
                          PointerValue (),
                          MakePointerAccessor (&MeshPointDevice::GetRoutingProtocol,
                                               &MeshPointDevice::SetRoutingProtocol),
                          MakePointerChecker<MeshL2RoutingProtocol> ())
                      ;
  return tid;
}

MeshPointDevice::MeshPointDevice () : m_ifIndex (0), m_mtu(1500)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_channel = CreateObject<BridgeChannel> ();
}

MeshPointDevice::~MeshPointDevice ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

void
MeshPointDevice::DoDispose ()
{
  NS_LOG_FUNCTION_NOARGS ();
  for (std::vector< Ptr<NetDevice> >::iterator iter = m_ifaces.begin (); iter != m_ifaces.end (); iter++)
    *iter = 0;
  m_ifaces.clear ();
  m_node = 0;
  NetDevice::DoDispose ();

}

//-----------------------------------------------------------------------------
// NetDevice interface implementation
//-----------------------------------------------------------------------------

void
MeshPointDevice::ReceiveFromDevice (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet, uint16_t protocol,
                                       Address const &src, Address const &dst, PacketType packetType)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_LOG_DEBUG ("UID is " << packet->GetUid ());
  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
  const Mac48Address dst48 = Mac48Address::ConvertFrom (dst);
  uint16_t& realProtocol = protocol;
  NS_LOG_DEBUG ("SRC="<<src48<<", DST = "<<dst48<<", I am: "<<m_address);
  if (!m_promiscRxCallback.IsNull ())
    m_promiscRxCallback (this, packet, protocol, src, dst, packetType);
  if(dst48.IsGroup ())
  {
    Ptr<Packet> packet_copy = packet->Copy ();
    if(m_removeRoutingStuff (incomingPort->GetIfIndex(), src48, dst48, packet_copy, realProtocol))
    {
      m_rxCallback (this, packet_copy, realProtocol, src);
      Forward (incomingPort, packet, protocol, src48, dst48);
    }
    return;
  }
  if(dst48 == m_address)
  {
    Ptr<Packet> packet_copy = packet->Copy ();
    if(m_removeRoutingStuff (incomingPort->GetIfIndex (), src48, dst48, packet_copy, realProtocol))
    {
      m_rxCallback (this, packet_copy, realProtocol, src);
    }
    return;
  }
  else
    Forward (incomingPort, packet->Copy (), protocol, src48, dst48);
}

void
MeshPointDevice::Forward (Ptr<NetDevice> inport, Ptr<const Packet> packet,
                             uint16_t protocol, const Mac48Address src, const Mac48Address dst)
{
  // pass through routing protocol
  m_requestRoute (inport->GetIfIndex(), src, dst, packet, protocol, m_myResponse);
}

void
MeshPointDevice::SetName (const std::string name)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_name = name;
}

std::string
MeshPointDevice::GetName () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_name;
}

void
MeshPointDevice::SetIfIndex (const uint32_t index)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_ifIndex = index;
}

uint32_t
MeshPointDevice::GetIfIndex () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_ifIndex;
}

Ptr<Channel>
MeshPointDevice::GetChannel () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_channel;
}

Address
MeshPointDevice::GetAddress () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_address;
}

bool
MeshPointDevice::SetMtu (const uint16_t mtu)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_mtu = mtu;
  return true;
}

uint16_t
MeshPointDevice::GetMtu () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_mtu;
}

bool
MeshPointDevice::IsLinkUp () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}

void
MeshPointDevice::SetLinkChangeCallback (Callback<void> callback)
{
  // do nothing
}

bool
MeshPointDevice::IsBroadcast () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}

Address
MeshPointDevice::GetBroadcast () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return Mac48Address ("ff:ff:ff:ff:ff:ff");
}

bool
MeshPointDevice::IsMulticast () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}

Address
MeshPointDevice::GetMulticast (Ipv4Address multicastGroup) const
{
  NS_LOG_FUNCTION (this << multicastGroup);
  Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);
  return multicast;
}

bool
MeshPointDevice::IsPointToPoint () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return false;
}

bool
MeshPointDevice::IsBridge () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return false;
}


bool
MeshPointDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
{
  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
  return m_requestRoute (m_ifIndex, m_address, dst48, packet, protocolNumber, m_myResponse);
}

bool
MeshPointDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
{
  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
  return m_requestRoute (m_ifIndex, src48, dst48, packet, protocolNumber, m_myResponse);
}

Ptr<Node>
MeshPointDevice::GetNode () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_node;
}

void
MeshPointDevice::SetNode (Ptr<Node> node)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_node = node;
}

bool
MeshPointDevice::NeedsArp () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return true;
}

void
MeshPointDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_rxCallback = cb;
}

void
MeshPointDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_promiscRxCallback = cb;
}

bool
MeshPointDevice::SupportsSendFrom () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return false; // don't allow to bridge mesh network with something else.
}

Address
MeshPointDevice::GetMulticast (Ipv6Address addr) const
{
  NS_LOG_FUNCTION (this << addr);
  return Mac48Address::GetMulticast (addr);
}

//-----------------------------------------------------------------------------
// Interfaces
//-----------------------------------------------------------------------------
uint32_t
MeshPointDevice::GetNInterfaces () const
{
  NS_LOG_FUNCTION_NOARGS ();
  return m_ifaces.size ();
}

Ptr<NetDevice>
MeshPointDevice::GetInterface (uint32_t n) const
{
  for(std::vector< Ptr<NetDevice> >::const_iterator i = m_ifaces.begin (); i != m_ifaces.end (); i ++)
    if((*i)->GetIfIndex() == n)
      return (*i);
  
  NS_FATAL_ERROR ("Mesh point interface is not found by index");
  return 0;
}
std::vector<Ptr<NetDevice> >
MeshPointDevice::GetInterfaces () const
{
  return m_ifaces;
}
void
MeshPointDevice::AddInterface (Ptr<NetDevice> iface)
{
  NS_LOG_FUNCTION_NOARGS ();
  
  NS_ASSERT (iface != this);
  if (!Mac48Address::IsMatchingType (iface->GetAddress ()))
  {
    NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be used as a mesh point interface.");
  }
  if (!iface->SupportsSendFrom ())
  {
    NS_FATAL_ERROR ("Device does not support SendFrom: cannot be used as a mesh point interface.");
  }
  
  // Mesh point has MAC address of it's first interface
  if (m_ifaces.empty()) 
    m_address = Mac48Address::ConvertFrom (iface->GetAddress ());
  
  const WifiNetDevice * wifiNetDev = dynamic_cast<const WifiNetDevice *> (PeekPointer (iface));
  if (wifiNetDev == 0)
    NS_FATAL_ERROR ("Device is not a WiFi NIC: cannot be used as a mesh point interface.");
      
  MeshWifiInterfaceMac * ifaceMac = dynamic_cast<MeshWifiInterfaceMac *> (PeekPointer (wifiNetDev->GetMac ()));
  if (ifaceMac == 0)
    NS_FATAL_ERROR ("WiFi device doesn't have correct MAC installed: cannot be used as a mesh point interface.");

  ifaceMac->SetMeshPointAddress (m_address);
  
  // Receive frames from this interface
  m_node->RegisterProtocolHandler (MakeCallback (&MeshPointDevice::ReceiveFromDevice, this),
                                   0, iface, /*promiscuous = */true);
  
  m_ifaces.push_back (iface);
  m_channel->AddChannel (iface->GetChannel ());
}

//-----------------------------------------------------------------------------
// Protocols
//-----------------------------------------------------------------------------

void
MeshPointDevice::SetRoutingProtocol (Ptr<MeshL2RoutingProtocol> protocol)
{
  NS_LOG_FUNCTION_NOARGS ();
  
  NS_ASSERT_MSG (PeekPointer(protocol->GetMeshPoint()) == this, "Routing protocol must be installed on mesh point to be useful.");
  
  m_routingProtocol = protocol;
  m_requestRoute = MakeCallback (&MeshL2RoutingProtocol::RequestRoute, protocol);
  m_removeRoutingStuff = MakeCallback (&MeshL2RoutingProtocol::RemoveRoutingStuff, protocol);
  m_myResponse = MakeCallback (&MeshPointDevice::DoSend, this);
}

Ptr<MeshL2RoutingProtocol>
MeshPointDevice::GetRoutingProtocol () const
{
  return m_routingProtocol;
}

void
MeshPointDevice::DoSend (bool success, Ptr<Packet> packet, Mac48Address src, Mac48Address dst, uint16_t protocol, uint32_t outIface)
{
  if (!success)
    {
      NS_LOG_DEBUG ("Resolve failed");
      return;
    }
  // Ok, now I know the route, just SendFrom
  if (outIface != 0xffffffff)
    GetInterface (outIface)->SendFrom(packet, src, dst, protocol);
  else
    for (std::vector<Ptr<NetDevice> >::iterator i = m_ifaces.begin (); i != m_ifaces.end(); i++)
      (*i) -> SendFrom (packet, src, dst, protocol);
}

} // namespace ns3