#ifndef FSFW_UTIL_UNSIGNEDBYTEFIELD_H
#define FSFW_UTIL_UNSIGNEDBYTEFIELD_H

#include "fsfw/serialize.h"

template<typename T>
class UnsignedByteField: public SerializeIF {
 public:
  static_assert(std::is_unsigned<T>::value);

  explicit UnsignedByteField(T value): value(value) {}
  [[nodiscard]] ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                                Endianness streamEndianness) const override {
    return SerializeAdapter::serialize(&value, buffer, size, maxSize, streamEndianness);
  }

  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                                    Endianness streamEndianness) override {
    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
  }

  [[nodiscard]] size_t getSerializedSize() const override {
    return sizeof(T);
  }

  [[nodiscard]] T getValue() const {
    return value;
  }

  void setValue(T value_) {
    value = value_;
  }
 private:
  T value;
};

class U32ByteField: public UnsignedByteField<uint32_t> {
 public:
  explicit U32ByteField(uint32_t value): UnsignedByteField<uint32_t>(value) {}
};

class U16ByteField: public UnsignedByteField<uint16_t> {
 public:
  explicit U16ByteField(uint16_t value): UnsignedByteField<uint16_t>(value) {}
};

class U8ByteField: public UnsignedByteField<uint8_t> {
 public:
  explicit U8ByteField(uint8_t value): UnsignedByteField<uint8_t>(value) {}
};

#endif  // FSFW_UTIL_UNSIGNEDBYTEFIELD_H