#define LOG_MODULE PacketLogModuleLayer

#include "Layer.h"

#include "Logger.h"

#include "Packet.h"

#include <cstring>

#include <stdexcept>

namespace pcpp

{

  Layer::~Layer()

  {

    if (!isAllocatedToPacket())

      delete[] m_Data;

  }

  Layer::Layer(const Layer& other) : m_Protocol(other.m_Protocol), m_NextLayer(nullptr), m_PrevLayer(nullptr)

  {

    m_DataLen = other.getHeaderLen();

    m_Data = new uint8_t[other.m_DataLen];

    memcpy(m_Data, other.m_Data, other.m_DataLen);

  }

  Layer& Layer::operator=(const Layer& other)

  {

    if (this == &other)

      return *this;

    // Should this really always delete m_Data? What if the layer is attached to a packet?

    if (m_Data != nullptr)

      delete[] m_Data;

    // Reset allocation info as the layer is considered copied and not attached to any packet.

    m_AllocationInfo = internal::LayerAllocationInfo{};

    m_DataLen = other.getHeaderLen();

    m_Protocol = other.m_Protocol;

    m_NextLayer = nullptr;

    m_PrevLayer = nullptr;

    m_Data = new uint8_t[other.m_DataLen];

    memcpy(m_Data, other.m_Data, other.m_DataLen);

    return *this;

  }

  bool Layer::isMemberOfProtocolFamily(ProtocolTypeFamily protocolTypeFamily) const

  {

    return m_Protocol != UnknownProtocol && internal::protoFamilyContainsProtocol(protocolTypeFamily, m_Protocol);

  }

  void Layer::copyData(uint8_t* toArr) const

  {

    memcpy(toArr, m_Data, m_DataLen);

  }

  size_t Layer::copyData(uint8_t* dest, size_t destSize) const

  {

    size_t bytesToCopy = (std::min)(destSize, m_DataLen);

    memcpy(dest, m_Data, bytesToCopy);

    return bytesToCopy;

  }

  const FieldDescriptor Layer::SerializedFields::ProtocolName{ MaxID, "protocolName" };

  const FieldDescriptor Layer::SerializedFields::ProtocolId{ MaxID - 1, "protocolId" };

  const FieldDescriptor Layer::SerializedFields::Length{ MaxID, "length" };

  const FieldDescriptor LayerObject{ 0, "layer" };

  void Layer::serialize(ISerializer& serializer) const

  {

    auto layerObject = serializer.writeObject(LayerObject);

    layerObject.writeField(SerializedFields::ProtocolName, protocolTypeToString(m_Protocol));

    layerObject.writeField(SerializedFields::ProtocolId, m_Protocol);

    layerObject.writeField(SerializedFields::Length, getHeaderLen());

    serializeLayer(layerObject);

  }

  void Layer::allocData(size_t dataLen, bool zeroInit)

  {

    if (m_Data != nullptr)

    {

      throw std::runtime_error(

          "Layer already has allocated data. Use extendLayer or shortenLayer to modify the data length.");

    }

    if (m_AllocationInfo.attachedPacket != nullptr)

    {

      // TODO: Allocate the layer data through the attached packet

      throw std::logic_error("not implemented");

    }

    m_Data = new uint8_t[dataLen];

    m_DataLen = dataLen;

    if (zeroInit)

    {

      std::fill_n(m_Data, m_DataLen, 0);

    }

  }

  bool Layer::extendLayer(int offsetInLayer, size_t numOfBytesToExtend)

  {

    if (m_Data == nullptr)

    {

      PCPP_LOG_ERROR("Layer's data is nullptr");

      return false;

    }

    if (getAttachedPacket() == nullptr)

    {

      if (static_cast<size_t>(offsetInLayer) > m_DataLen)

      {

        PCPP_LOG_ERROR("Requested offset is larger than data length");

        return false;

      }

      uint8_t* newData = new uint8_t[m_DataLen + numOfBytesToExtend];

      memcpy(newData, m_Data, offsetInLayer);

      memcpy(newData + offsetInLayer + numOfBytesToExtend, m_Data + offsetInLayer, m_DataLen - offsetInLayer);

      delete[] m_Data;

      m_Data = newData;

      m_DataLen += numOfBytesToExtend;

      return true;

    }

    return getAttachedPacket()->extendLayer(this, offsetInLayer, numOfBytesToExtend);

  }

  bool Layer::shortenLayer(int offsetInLayer, size_t numOfBytesToShorten)

  {

    if (m_Data == nullptr)

    {

      PCPP_LOG_ERROR("Layer's data is nullptr");

      return false;

    }

    if (static_cast<size_t>(offsetInLayer) + numOfBytesToShorten > m_DataLen)

    {

      PCPP_LOG_ERROR("Requested number of bytes to shorten is larger than data length");

      return false;

    }

    if (getAttachedPacket() == nullptr)

    {

      if (static_cast<size_t>(offsetInLayer) >= m_DataLen)

      {

        PCPP_LOG_ERROR("Requested offset is larger than data length");

        return false;

      }

      uint8_t* newData = new uint8_t[m_DataLen - numOfBytesToShorten];

      memcpy(newData, m_Data, offsetInLayer);

      memcpy(newData + offsetInLayer, m_Data + offsetInLayer + numOfBytesToShorten,

             m_DataLen - offsetInLayer - numOfBytesToShorten);

      delete[] m_Data;

      m_Data = newData;

      m_DataLen -= numOfBytesToShorten;

      return true;

    }

    return getAttachedPacket()->shortenLayer(this, offsetInLayer, numOfBytesToShorten);

  }

}  // namespace pcpp