#include "HousekeepingSet.h"

#include "GeneratesHousekeepingIF.h"

#ifdef FSFW_INTROSPECTION
HousekeepingSet::HousekeepingSet(GeneratesHousekeepingIF* owner) {
  if (owner != nullptr) {
    helper = owner->getHousekeepingHelper();
    helper->registerSet(this);
  }
}

void HousekeepingSet::setEnum(EnumIF* theEnum) {
  id = theEnum->getValue();
  description = theEnum->getDescription();
}
#else
HousekeepingSet::HousekeepingSet(GeneratesHousekeepingIF* owner, HousekeepingSetId_t id) : id(id) {
  if (owner != nullptr) {
    helper = owner->getHousekeepingHelper();
    helper->registerSet(this);
  }
}
#endif

HousekeepingSet::~HousekeepingSet() {}

void HousekeepingSet::report(const Action* action) {
  if (helper == nullptr) {
    helper->reportHousekeeping(this, action);
  }
}

ReturnValue_t HousekeepingSet::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                                         Endianness streamEndianness) const {
  ReturnValue_t result = SerializeAdapter::serialize(&id, buffer, size, maxSize, streamEndianness);
  if (result != returnvalue::OK) {
    return result;
  }
  for (auto parameter : *getParameters()) {
    result = parameter->serialize(buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
  }
  return result;
}

size_t HousekeepingSet::getSerializedSize() const {
  size_t size = SerializeAdapter::getSerializedSize(&id);
  for (auto parameter : *getParameters()) {
    size += parameter->getSerializedSize();
  }
  return size;
}

ReturnValue_t HousekeepingSet::deSerialize(const uint8_t** buffer, size_t* size,
                                           Endianness streamEndianness) {
  ReturnValue_t result = returnvalue::OK;

  /**
   * When deserializing, the id needs to be deserialized first, to find the correct class to
   * deserialize with. Consequentely, it is assumed, that the pointer was already advanced
   *
   * SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness); if (result !=
   */
  for (auto parameter : *getParameters()) {
    result = parameter->deSerialize(buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
  }
  return result;
}

void HousekeepingSet::registerParameter(ParameterIF* parameter) {
  parameterList.push_back(parameter);
}

std::vector<ParameterIF*> const* HousekeepingSet::getParameters() const { return &parameterList; }