#pragma once

#include "IcmpV6Layer.h"

#include "IpAddress.h"

#include "Layer.h"

#include "MacAddress.h"

#include "TLVData.h"

#include <vector>

/// @file

/// @namespace pcpp

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

namespace pcpp

{

  /// An enum representing the available option types for Neighbor Discovery in IPv6 (see RFC 4861)

  enum class NDPNeighborOptionTypes : int

  {

    NDP_OPTION_SOURCE_LINK_LAYER = 1,

    NDP_OPTION_TARGET_LINK_LAYER = 2,

    NDP_OPTION_PREFIX_INFORMATION = 3,

    NDP_OPTION_REDIRECTED_HEADER = 4,

    NDP_OPTION_MTU = 5,

    NDP_OPTION_UNKNOWN = 255

  };

  /// @class NdpOption

  /// A wrapper class for NDP options. This class does not create or modify NDP option records, but rather

  /// serves as a wrapper and provides useful methods for retrieving data from them

  class NdpOption : public TLVRecord<uint8_t, uint8_t>

  {

  public:

    /// A c'tor for this class that gets a pointer to the option raw data (byte array)

    /// @param[in] optionRawData A pointer to the NDP option raw data

    explicit NdpOption(uint8_t* optionRawData) : TLVRecord(optionRawData)

    {}

    /// A d'tor for this class, currently does nothing

    ~NdpOption() override = default;

    /// @return NDP option type casted as pcpp::NDPNeighborOptionTypes enum. If the data is null a value

    /// of NDP_OPTION_UNKNOWN is returned

    NDPNeighborOptionTypes getNdpOptionType() const

    {

      if (m_Data == nullptr)

        return NDPNeighborOptionTypes::NDP_OPTION_UNKNOWN;

      return static_cast<NDPNeighborOptionTypes>(m_Data->recordType);

    }

    // implement abstract methods

    size_t getTotalSize() const override

    {

      if (m_Data == nullptr)

        return 0;

      return static_cast<size_t>(m_Data->recordLen) * 8;

    }

    size_t getDataSize() const override

    {

      if (m_Data == nullptr)

      {

        return 0;

      }

      // length value is stored in units of 8 octets

      return static_cast<size_t>(m_Data->recordLen) * 8 - (2 * sizeof(uint8_t));

    }

  };

  /// @class NdpOptionBuilder

  /// A class for building NDP option records. This builder receives the NDP option parameters in its c'tor,

  /// builds the NDP option raw buffer and provides a build() method to get a NdpOption object out of it

  class NdpOptionBuilder : public TLVRecordBuilder

  {

  public:

    /// A c'tor for building NDP options which their value is a byte array. The NdpOption object can be later

    /// retrieved by calling build(). Each option is padded to have a 64-bit boundary.

    /// @param[in] optionType NDP option type

    /// @param[in] optionValue A buffer containing the option value. This buffer is read-only and isn't modified in

    /// any way.

    /// @param[in] optionValueLen Option value length in bytes

    NdpOptionBuilder(NDPNeighborOptionTypes optionType, const uint8_t* optionValue, uint8_t optionValueLen)

        : TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen)

    {}

    /// Build the NdpOption object out of the parameters defined in the c'tor. Padding bytes are added to the

    /// option for option length with 64-bit boundaries.

    /// @return The NdpOption object

    NdpOption build() const;

  };

  /// @class NDPLayerBase

  /// Represents a base for NDP packet types

  class NDPLayerBase : public IcmpV6Layer

  {

  public:

    ~NDPLayerBase() override = default;

    /// @return The number of NDP options in this layer

    size_t getNdpOptionCount() const;

    /// Get a NDP option by type.

    /// @param[in] option NDP option type

    /// @return An NdpOption object that contains the first option that matches this type, or logical null

    /// (NdpOption#isNull() == true) if no such option found

    NdpOption getNdpOption(NDPNeighborOptionTypes option) const;

    /// @return The first NDP option in the packet. If the current layer contains no options the returned value will

    /// contain a logical null (NdpOption#isNull() == true)

    NdpOption getFirstNdpOption() const;

    /// Get the NDP option that comes after a given option. If the given option was the last one, the

    /// returned value will contain a logical null (IdpOption#isNull() == true)

    /// @param[in] option An NDP option object that exists in the current layer

    /// @return A NdpOption object that contains the NDP option data that comes next, or logical null if the given

    /// NDP option: (1) was the last one; or (2) contains a logical null; or (3) doesn't belong to this packet

    NdpOption getNextNdpOption(NdpOption& option) const;

    /// Add a new NDP option at the end of the layer (after the last NDP option)

    /// @param[in] optionBuilder An NdpOptionBuilder object that contains the NDP option data to be added

    /// @return A NdpOption object that contains the newly added NDP option data or logical null

    /// (NdpOption#isNull() == true) if addition failed. In case of a failure a corresponding error message will be

    /// printed to log

    NdpOption addNdpOption(const NdpOptionBuilder& optionBuilder);

    /// Remove all NDP options from the layer

    /// @return True if options removed successfully or false if some error occurred (an appropriate error message

    /// will be printed to log)

    bool removeAllNdpOptions();

    /// @struct SerializedFields

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

    /// IcmpV6Layer::SerializedFields.

    struct SerializedFields : IcmpV6Layer::SerializedFields

    {

      /// @brief The highest field ID used by NDPLayerBase

      static constexpr uint16_t MaxID = IcmpV6Layer::SerializedFields::MaxID + 1;

      /// @return All field descriptors for NDPLayerBase

      static std::vector<FieldDescriptor> all()

      {

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

        std::initializer_list<FieldDescriptor> extra{ Options };

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

        return result;

      }

      /// @brief Array of NDP options; elements described by Option

      static const FieldDescriptor Options;

      /// @brief One option's type name; an Options element, not included in all()

      static const FieldDescriptor Option;

    };

  protected:

    NDPLayerBase() = default;

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

        : IcmpV6Layer(data, dataLen, prevLayer, packet)

    {}

    void serializeOptions(ObjectScope& serializer) const;

  private:

    TLVRecordReader<NdpOption> m_OptionReader;

    virtual size_t getNdpHeaderLen() const = 0;

    virtual uint8_t* getNdpOptionsBasePtr() const

    {

      return m_Data + getNdpHeaderLen();

    };

    NdpOption addNdpOptionAt(const NdpOptionBuilder& optionBuilder, int offset);

  };

  /// @class NDPNeighborSolicitationLayer

  /// Represents a NDP Neighbor Solicitation protocol layer

  class NDPNeighborSolicitationLayer : public NDPLayerBase

  {

  public:

    /// @struct ndpneighborsolicitationhdr

    /// Represents neighbor solicitation message format

#pragma pack(push, 1)

    struct ndpneighborsolicitationhdr : icmpv6hdr

    {

      /// Reserved

      uint32_t reserved;

      /// Target address - Target address of solicitation message

      uint8_t targetIP[16];

    };

#pragma pack(pop)

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

    /// @param[in] data A pointer to the raw data

    /// @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

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

        : NDPLayerBase(data, dataLen, prevLayer, packet)

    {}

    /// Checks whether the data is large enough to be parsed as a neighbor solicitation message

    /// @param[in] data A pointer to the raw data

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

    /// @return True if the data is at least the size of the neighbor solicitation header

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

    {

      return data != nullptr && dataLen >= sizeof(ndpneighborsolicitationhdr);

    }

    /// A constructor for a new NDPNeighborSolicitationLayer object

    /// @param[in] code Code field

    /// @param[in] targetIP Target IP address for which the solicitation shall be created

    NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address& targetIP);

    /// A constructor for a new NDPNeighborSolicitationLayer object

    /// @param[in] code Code field

    /// @param[in] targetIP Target IP address for which the solicitation shall be created

    /// @param[in] srcMac Mac address which shall be put in the linklayer option

    NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address& targetIP, const MacAddress& srcMac);

    ~NDPNeighborSolicitationLayer() override = default;

    /// @return Get the IP address specified as the target IP address in the solicitation message

    IPv6Address getTargetIP() const

    {

      return IPv6Address(getNdpHeader()->targetIP);

    };

    /// Checks if the layer has a link layer address option set

    /// @return true if link layer address option is available, false otherwise

    bool hasLinkLayerAddress() const;

    /// Get the Link Layer Address

    /// @return Mac address which is specified in the link layer address option

    MacAddress getLinkLayerAddress() const;

    std::string toString() const override;

    /// @struct SerializedFields

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

    /// NDPLayerBase::SerializedFields.

    struct SerializedFields : NDPLayerBase::SerializedFields

    {

      /// @return All field descriptors for NDPNeighborSolicitationLayer

      static std::vector<FieldDescriptor> all()

      {

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

        std::initializer_list<FieldDescriptor> extra{ TargetIP, LinkLayerAddress };

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

        return result;

      }

      /// @brief Target IPv6 address, as a string

      static const FieldDescriptor TargetIP;

      /// @brief Link-layer MAC address option, as a string (if present)

      static const FieldDescriptor LinkLayerAddress;

    };

  protected:

    void serializeLayer(ObjectScope& serializer) const override;

  private:

    void initLayer(uint8_t code, const IPv6Address& targetIP);

    ndpneighborsolicitationhdr* getNdpHeader() const

    {

      return reinterpret_cast<ndpneighborsolicitationhdr*>(m_Data);

    }

    size_t getNdpHeaderLen() const override

    {

      return sizeof(ndpneighborsolicitationhdr);

    };

  };

  /// @class NDPNeighborAdvertisementLayer

  /// Represents a NDP Neighbor Advertisement protocol layer

  class NDPNeighborAdvertisementLayer : public NDPLayerBase

  {

  public:

    /// @struct ndpneighboradvertisementhdr

    /// Represents neighbor advertisement message format

#pragma pack(push, 1)

    struct ndpneighboradvertisementhdr : icmpv6hdr

    {

#if (BYTE_ORDER == LITTLE_ENDIAN)

      uint32_t

          /// Unused field

          reserved : 5,

          /// Flag indicating that this entry should override the old one

          override : 1,

          /// Flag indicating that the advertisement was sent in response to a Neighbor Solicitation from the

          /// Destination address

          solicited : 1,

          /// Flag indicating that the advertisement is sent by a router

          router : 1,

          /// Unused field

          reserved2 : 24;

#else

      uint32_t

          /// Flag indicating that the advertisement is sent by a router

          router : 1,

          /// Flag indicating that the advertisement was sent in response to a Neighbor Solicitation from the

          /// Destination address

          solicited : 1,

          /// Flag indicating that this entry should override the old one

          override : 1,

          /// Unused field

          reserved : 29;

#endif

      /// Target address - Either source address of advertisement or address for requested MAC

      uint8_t targetIP[16];

    };

#pragma pack(pop)

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

    /// @param[in] data A pointer to the raw data

    /// @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

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

        : NDPLayerBase(data, dataLen, prevLayer, packet)

    {}

    /// Checks whether the data is large enough to be parsed as a neighbor advertisement message

    /// @param[in] data A pointer to the raw data

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

    /// @return True if the data is at least the size of the neighbor advertisement header

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

    {

      return data != nullptr && dataLen >= sizeof(ndpneighboradvertisementhdr);

    }

    /// A constructor that allocates a new NDP Advertisement Layer with target link-layer address option

    /// @param[in] code Code field

    /// @param[in] targetIP The target IP address from the Neighbor Solicitation message (solicited advertisements)

    /// or the address whose link-layer address has changed (unsolicited advertisement)

    /// @param[in] targetMac Adds the target link-layer address into the option field of the layer

    /// @param[in] routerFlag The router flag

    /// @param[in] unicastFlag The solicited flag

    /// @param[in] overrideFlag The override flag

    NDPNeighborAdvertisementLayer(uint8_t code, const IPv6Address& targetIP, const MacAddress& targetMac,

                                  bool routerFlag, bool unicastFlag, bool overrideFlag);

    /// A constructor that allocates a new NDP Advertisement Layer

    /// @param code Code field

    /// @param targetIP The target IP address from the Neighbor Solicitation message (solicited advertisements) or

    /// the address whose link-layer address has changed (unsolicited advertisement)

    /// @param routerFlag The router flag

    /// @param unicastFlag The solicited flag

    /// @param overrideFlag The override flag

    NDPNeighborAdvertisementLayer(uint8_t code, const IPv6Address& targetIP, bool routerFlag, bool unicastFlag,

                                  bool overrideFlag);

    ~NDPNeighborAdvertisementLayer() override = default;

    /// @return Get the target MAC address

    MacAddress getTargetMac() const;

    /// @return Get the target IP address

    IPv6Address getTargetIP() const

    {

      return IPv6Address(getNdpHeader()->targetIP);

    }

    /// @return Get information if the target link-layer address was added in the option field of the header

    bool hasTargetMacInfo() const;

    /// @return Get the router flag

    bool getRouterFlag() const

    {

      return getNdpHeader()->router;

    }

    /// @return Get the unicast flag

    bool getUnicastFlag() const

    {

      return getNdpHeader()->solicited;

    }

    /// @return Get the override flag

    bool getOverrideFlag() const

    {

      return getNdpHeader()->override;

    }

    std::string toString() const override;

    /// @struct SerializedFields

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

    /// NDPLayerBase::SerializedFields.

    struct SerializedFields : NDPLayerBase::SerializedFields

    {

      /// @return All field descriptors for NDPNeighborAdvertisementLayer

      static std::vector<FieldDescriptor> all()

      {

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

        std::initializer_list<FieldDescriptor> extra{ TargetIP, RouterFlag, UnicastFlag, OverrideFlag,

                                                    TargetMac };

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

        return result;

      }

      /// @brief Target IPv6 address, as a string

      static const FieldDescriptor TargetIP;

      /// @brief Router flag

      static const FieldDescriptor RouterFlag;

      /// @brief Solicited (unicast) flag

      static const FieldDescriptor UnicastFlag;

      /// @brief Override flag

      static const FieldDescriptor OverrideFlag;

      /// @brief Target MAC address option, as a string (if present)

      static const FieldDescriptor TargetMac;

    };

  protected:

    void serializeLayer(ObjectScope& serializer) const override;

  private:

    void initLayer(uint8_t code, const IPv6Address& targetIP, bool routerFlag, bool unicastFlag, bool overrideFlag);

    ndpneighboradvertisementhdr* getNdpHeader() const

    {

      return reinterpret_cast<ndpneighboradvertisementhdr*>(m_Data);

    }

    size_t getNdpHeaderLen() const override

    {

      return sizeof(ndpneighboradvertisementhdr);

    };

  };

}  // namespace pcpp