#define LOG_MODULE PacketLogModuleS7CommLayer

#include "EndianPortable.h"

#include "Logger.h"

#include "S7CommLayer.h"

#include <algorithm>

#include <iostream>

#include <cstring>

#include <sstream>

#include <stdexcept>

namespace pcpp

{

  S7CommLayer::S7CommLayer(uint8_t msgType, uint16_t pduRef, uint16_t paramLength, uint16_t dataLength,

                           uint8_t errorClass, uint8_t errorCode)

  {

    size_t basicHeaderLen = msgType == 0x03 ? sizeof(s7comm_ack_data_hdr) : sizeof(s7commhdr);

    size_t headerLen = basicHeaderLen + paramLength + dataLength;

    allocData(headerLen);

    if (msgType == 0x03)

    {

      auto* ack_d = reinterpret_cast<s7comm_ack_data_hdr*>(m_Data);

      ack_d->protocolId = 0x32;

      ack_d->msgType = msgType;

      ack_d->reserved = 0x0000;

      ack_d->pduRef = htobe16(pduRef);

      ack_d->paramLength = htobe16(paramLength);

      ack_d->dataLength = htobe16(dataLength);

      ack_d->errorClass = errorClass;

      ack_d->errorCode = errorCode;

    }

    else

    {

      auto* s7commHdr = reinterpret_cast<s7commhdr*>(m_Data);

      s7commHdr->protocolId = 0x32;

      s7commHdr->msgType = msgType;

      s7commHdr->reserved = 0x0000;

      s7commHdr->pduRef = htobe16(pduRef);

      s7commHdr->paramLength = htobe16(paramLength);

      s7commHdr->dataLength = htobe16(dataLength);

    }

    m_Parameter = nullptr;

    m_Protocol = S7COMM;

  }

  std::string S7CommLayer::toString() const

  {

    std::ostringstream str;

    str << "S7Comm Layer, ";

    switch (getS7commHeader()->msgType)

    {

    case 0x01:

      str << "Job Request";

      break;

    case 0x02:

      str << "Ack";

      break;

    case 0x03:

      str << "Ack-Data";

      break;

    case 0x07:

      str << "Userdata";

      break;

    default:

      str << "Unknown message";

    }

    return str.str();

  }

  static constexpr const char* msgTypeToString(uint8_t msgType)

  {

    switch (msgType)

    {

    case 0x01:

      return "JobRequest";

    case 0x02:

      return "Ack";

    case 0x03:

      return "AckData";

    case 0x07:

      return "Userdata";

    default:

      return "Unknown";

    }

  }

  const FieldDescriptor S7CommLayer::SerializedFields::MsgType{ Layer::SerializedFields::MaxID + 1, "msgType" };

  const FieldDescriptor S7CommLayer::SerializedFields::MsgTypeName{ Layer::SerializedFields::MaxID + 2,

                                                                  "msgTypeName" };

  const FieldDescriptor S7CommLayer::SerializedFields::PduRef{ Layer::SerializedFields::MaxID + 3, "pduRef" };

  const FieldDescriptor S7CommLayer::SerializedFields::ParamLength{ Layer::SerializedFields::MaxID + 4,

                                                                  "paramLength" };

  const FieldDescriptor S7CommLayer::SerializedFields::DataLength{ Layer::SerializedFields::MaxID + 5, "dataLength" };

  const FieldDescriptor S7CommLayer::SerializedFields::ErrorClass{ Layer::SerializedFields::MaxID + 6, "errorClass" };

  const FieldDescriptor S7CommLayer::SerializedFields::ErrorCode{ Layer::SerializedFields::MaxID + 7, "errorCode" };

  void S7CommLayer::serializeLayer(ObjectScope& serializer) const

  {

    serializer.writeField(SerializedFields::MsgType, getMsgType());

    serializer.writeField(SerializedFields::MsgTypeName, msgTypeToString(getMsgType()));

    serializer.writeField(SerializedFields::PduRef, getPduRef());

    serializer.writeField(SerializedFields::ParamLength, getParamLength());

    serializer.writeField(SerializedFields::DataLength, getDataLength());

    auto* ackDataHeader = getS7commAckDataHeader();

    if (ackDataHeader != nullptr)

    {

      serializer.writeField(SerializedFields::ErrorClass, ackDataHeader->errorClass);

      serializer.writeField(SerializedFields::ErrorCode, ackDataHeader->errorCode);

    }

  }

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

  {

    if (!data || dataSize < sizeof(s7commhdr))

      return false;

    return data[0] == 0x32;

  }

  uint8_t S7CommLayer::getProtocolId() const

  {

    return getS7commHeader()->protocolId;

  }

  uint8_t S7CommLayer::getMsgType() const

  {

    return getS7commHeader()->msgType;

  }

  uint16_t S7CommLayer::getParamLength() const

  {

    return be16toh(getS7commHeader()->paramLength);

  }

  uint16_t S7CommLayer::getPduRef() const

  {

    return be16toh(getS7commHeader()->pduRef);

  }

  uint16_t S7CommLayer::getDataLength() const

  {

    return be16toh(getS7commHeader()->dataLength);

  }

  void S7CommLayer::setMsgType(uint8_t msgType) const

  {

    getS7commHeader()->msgType = msgType;

  }

  uint8_t S7CommLayer::getErrorCode() const

  {

    auto* ackDataHeader = getS7commAckDataHeader();

    if (ackDataHeader == nullptr)

    {

      throw std::runtime_error("Error code field not present!");

    }

    return ackDataHeader->errorCode;

  }

  uint8_t S7CommLayer::getErrorClass() const

  {

    auto* ackDataHeader = getS7commAckDataHeader();

    if (ackDataHeader == nullptr)

    {

      throw std::runtime_error("Error class field not present!");

    }

    return ackDataHeader->errorClass;

  }

  void S7CommLayer::setPduRef(uint16_t pduRef) const

  {

    getS7commHeader()->pduRef = htobe16(pduRef);

  }

  void S7CommLayer::setErrorCode(uint8_t errorCode) const

  {

    auto* ackDataHeader = getS7commAckDataHeader();

    if (ackDataHeader == nullptr)

    {

      PCPP_LOG_ERROR("Cannot set the error code, the layer has no Ack-Data header");

      return;

    }

    ackDataHeader->errorCode = errorCode;

  }

  void S7CommLayer::setErrorClass(uint8_t errorClass) const

  {

    auto* ackDataHeader = getS7commAckDataHeader();

    if (ackDataHeader == nullptr)

    {

      PCPP_LOG_ERROR("Cannot set the error class, the layer has no Ack-Data header");

      return;

    }

    ackDataHeader->errorClass = errorClass;

  }

  const S7CommParameter* S7CommLayer::getParameter()

  {

    if (!m_Parameter)

    {

      // the parameter length comes from the packet, so keep it inside the layer

      size_t offset = std::min(getS7commHeaderLength(), m_DataLen);

      size_t paramLength = std::min(static_cast<size_t>(getParamLength()), m_DataLen - offset);

      m_Parameter = std::unique_ptr<S7CommParameter>(new S7CommParameter(m_Data + offset, paramLength));

    }

    return m_Parameter.get();

  }

  size_t S7CommLayer::getS7commHeaderLength() const

  {

    if (getS7commHeader()->msgType == 0x03)

    {

      return sizeof(s7comm_ack_data_hdr);

    }

    return sizeof(s7commhdr);

  }

}  // namespace pcpp