#pragma once

#include "Layer.h"

#include <algorithm>

#include <iterator>

/// @file

/// @namespace pcpp

/// @brief The main namespace for the PcapPlusPlus lib

namespace pcpp

{

  /// @struct udphdr

  /// Represents an UDP protocol header

#pragma pack(push, 1)

  struct udphdr

  {

    /// Source port

    uint16_t portSrc;

    /// Destination port

    uint16_t portDst;

    /// Length of header and payload in bytes

    uint16_t length;

    ///  Error-checking of the header and data

    uint16_t headerChecksum;

  };

#pragma pack(pop)

  static_assert(sizeof(udphdr) == 8, "udphdr size is not 8 bytes");

  /// @class UdpLayer

  /// Represents an UDP (User Datagram Protocol) protocol layer

  class UdpLayer : public Layer

  {

  public:

    /// A constructor that creates the layer from an existing packet raw data

    /// @param[in] data A pointer to the raw data (will be casted to @ref udphdr)

    /// @param[in] dataLen Size of the data in bytes

    /// @param[in] prevLayer A pointer to the previous layer

    /// @param[in] packet A pointer to the Packet instance where layer will be stored in

    UdpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)

        : Layer(data, dataLen, prevLayer, packet, UDP)

    {}

    /// A constructor that allocates a new UDP header with source and destination ports

    /// @param[in] portSrc Source UDP port address

    /// @param[in] portDst Destination UDP port

    UdpLayer(uint16_t portSrc, uint16_t portDst);

    /// Get a pointer to the UDP header. Notice this points directly to the data, so every change will change the

    /// actual packet data

    /// @return A pointer to the @ref udphdr

    udphdr* getUdpHeader() const

    {

      return reinterpret_cast<udphdr*>(m_Data);

    }

    /// @return UDP source port

    uint16_t getSrcPort() const;

    /// @return UDP destination port

    uint16_t getDstPort() const;

    /// Calculate the checksum from header and data and possibly write the result to @ref udphdr#headerChecksum

    /// @param[in] writeResultToPacket If set to true then checksum result will be written to @ref

    /// udphdr#headerChecksum

    /// @return The checksum result

    uint16_t calculateChecksum(bool writeResultToPacket);

    /// A static method that validates the input data

    /// @param[in] data The pointer to the beginning of a byte stream of an UDP packet

    /// @param[in] dataLen The length of the byte stream

    /// @return True if the data is valid and can represent a UDP packet

    static inline bool isDataValid(const uint8_t* data, size_t dataLen);

    // implement abstract methods

    /// Currently identifies the following next layers: DnsLayer, DhcpLayer, VxlanLayer, SipRequestLayer,

    /// SipResponseLayer, RadiusLayer. Otherwise sets PayloadLayer

    void parseNextLayer() override;

    /// @return Size of @ref udphdr

    size_t getHeaderLen() const override

    {

      return sizeof(udphdr);

    }

    /// Calculate @ref udphdr#headerChecksum field

    void computeCalculateFields() override;

    std::string toString() const override;

    OsiModelLayer getOsiModelLayer() const override

    {

      return OsiModelTransportLayer;

    }

    /// @struct SerializedFields

    /// Fields written by UdpLayer's serializeLayer(), in addition to

    /// Layer::SerializedFields.

    struct SerializedFields : Layer::SerializedFields

    {

      /// @return All field descriptors for UdpLayer

      static std::vector<FieldDescriptor> all()

      {

        auto result = Layer::SerializedFields::all();

        std::initializer_list<FieldDescriptor> extra{ SrcPort, DstPort, Checksum };

        std::copy(extra.begin(), extra.end(), std::back_inserter(result));

        return result;

      }

      /// @brief Source port, in host byte order

      static const FieldDescriptor SrcPort;

      /// @brief Destination port, in host byte order

      static const FieldDescriptor DstPort;

      /// @brief Checksum, as a hex string

      static const FieldDescriptor Checksum;

    };

  protected:

    void serializeLayer(ObjectScope& serializer) const override;

  };

  bool UdpLayer::isDataValid(const uint8_t* data, size_t dataLen)

  {

    return data && dataLen >= sizeof(udphdr);

  }

}  // namespace pcpp