#define LOG_MODULE PacketLogModuleWakeOnLanLayer

#include "WakeOnLanLayer.h"

#include "GeneralUtils.h"

#include "Logger.h"

namespace pcpp

{

  void WakeOnLanLayer::init(uint16_t len)

  {

    m_Data = new uint8_t[len];

    m_DataLen = len;

    m_Protocol = WakeOnLan;

    memset(getWakeOnLanHeader()->sync, 0xFF, 6);

  }

  WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress& targetAddr)

  {

    init(sizeof(wol_header));

    setTargetAddr(targetAddr);

  }

  WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress& targetAddr, uint8_t* password, uint8_t len)

  {

    init(sizeof(wol_header) + len);

    setTargetAddr(targetAddr);

    setPassword(password, len);

  }

  WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress& targetAddr, const pcpp::MacAddress& password)

  {

    init(sizeof(wol_header) + 6);

    setTargetAddr(targetAddr);

    setPassword(password);

  }

  WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress& targetAddr, const IPv4Address& password)

  {

    init(sizeof(wol_header) + 4);

    setTargetAddr(targetAddr);

    setPassword(password);

  }

  pcpp::MacAddress WakeOnLanLayer::getTargetAddr() const

  {

    return pcpp::MacAddress(getWakeOnLanHeader()->addrBody);

  }

  void WakeOnLanLayer::setTargetAddr(const pcpp::MacAddress& targetAddr)

  {

    for (size_t idx = 0; idx < 16; ++idx)

      memcpy(&(getWakeOnLanHeader()->addrBody[idx * 6]), targetAddr.getRawData(), 6);

  }

  std::string WakeOnLanLayer::getPassword() const

  {

    size_t passSize = m_DataLen - sizeof(wol_header);

    switch (passSize)

    {

    case 0:

      return std::string();

    case 4:

      return IPv4Address(&m_Data[sizeof(wol_header)]).toString();

    case 6:

      return MacAddress(&m_Data[sizeof(wol_header)]).toString();

    default:

      return byteArrayToHexString(&m_Data[sizeof(wol_header)], passSize);

    }

  }

  bool WakeOnLanLayer::setPassword(const uint8_t* password, uint8_t len)

  {

    if (len)

    {

      if (m_DataLen > sizeof(wol_header) + len)

      {

        if (!shortenLayer(sizeof(wol_header), m_DataLen - (sizeof(wol_header) + len)))

        {

          PCPP_LOG_ERROR("Can't shorten Wake on LAN layer");

          return false;

        }

      }

      else if (m_DataLen < sizeof(wol_header) + len)

      {

        if (!extendLayer(m_DataLen, (sizeof(wol_header) + len) - m_DataLen))

        {

          PCPP_LOG_ERROR("Can't extend Wake on LAN layer");

          return false;

        }

      }

      memcpy(&m_Data[sizeof(wol_header)], password, len);

    }

    return true;

  }

  bool WakeOnLanLayer::setPassword(const std::string& password)

  {

    return setPassword(reinterpret_cast<const uint8_t*>(password.c_str()), password.size());

  }

  bool WakeOnLanLayer::setPassword(const MacAddress& addr)

  {

    return setPassword(addr.getRawData(), 6);

  }

  bool WakeOnLanLayer::setPassword(const IPv4Address& addr)

  {

    return setPassword(addr.toBytes(), 4);

  }

  bool WakeOnLanLayer::isDataValid(const uint8_t* data, size_t dataSize)

  {

    if (data && dataSize >= sizeof(wol_header))

    {

      // It should repeat same MAC address at the payload 16 times

      pcpp::MacAddress bufAddr(&data[6]);

      for (size_t idx = 1; idx < 16; ++idx)

      {

        if (bufAddr != pcpp::MacAddress(&data[6 + idx * 6]))

          return false;

      }

      return true;

    }

    return false;

  }

  std::string WakeOnLanLayer::toString() const

  {

    return "Wake On LAN Layer, target address: " + getTargetAddr().toString();

  }

}  // namespace pcpp