#include "fsfw/internalerror/InternalErrorReporter.h"

#include "fsfw/ipc/MutexFactory.h"
#include "fsfw/ipc/QueueFactory.h"
#include "fsfw/serviceinterface/ServiceInterface.h"

InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
    : SystemObject(setObjectId),
      internalErrorDataset(this) {
  mutex = MutexFactory::instance()->createMutex();
}

InternalErrorReporter::~InternalErrorReporter() {
  MutexFactory::instance()->deleteMutex(mutex);
}

void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
  this->diagnosticPrintout = enable;
}

ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
  uint32_t newQueueHits = getAndResetQueueHits();
  uint32_t newTmHits = getAndResetTmHits();
  uint32_t newStoreHits = getAndResetStoreHits();

#if FSFW_VERBOSE_LEVEL >= 1
  if (diagnosticPrintout) {
    if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::debug << "InternalErrorReporter::performOperation: Errors "
                 << "occured!" << std::endl;
      sif::debug << "Queue errors: " << newQueueHits << std::endl;
      sif::debug << "TM errors: " << newTmHits << std::endl;
      sif::debug << "Store errors: " << newStoreHits << std::endl;
#else
      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
#endif
    }
  }
#endif

  // {
  //   PoolReadGuard readGuard(&internalErrorDataset);
  //   if (readGuard.getReadResult() == returnvalue::OK) {
  //     internalErrorDataset.queueHits.value += newQueueHits;
  //     internalErrorDataset.storeHits.value += newStoreHits;
  //     internalErrorDataset.tmHits.value += newTmHits;
  //     internalErrorDataset.setValidity(true, true);
  //     if ((newQueueHits != 0) or (newStoreHits != 0) or (newTmHits != 0)) {
  //       internalErrorDataset.setChanged(true);
  //     }
  //   }
  // }

  return returnvalue::OK;
}

void InternalErrorReporter::queueMessageNotSent() { incrementQueueHits(); }

void InternalErrorReporter::lostTm() { incrementTmHits(); }

uint32_t InternalErrorReporter::getAndResetQueueHits() {
  uint32_t value;
  mutex->lockMutex(timeoutType, timeoutMs);
  value = queueHits;
  queueHits = 0;
  mutex->unlockMutex();
  return value;
}

void InternalErrorReporter::incrementQueueHits() {
  mutex->lockMutex(timeoutType, timeoutMs);
  queueHits++;
  mutex->unlockMutex();
}

uint32_t InternalErrorReporter::getAndResetTmHits() {
  uint32_t value;
  mutex->lockMutex(timeoutType, timeoutMs);
  value = tmHits;
  tmHits = 0;
  mutex->unlockMutex();
  return value;
}

void InternalErrorReporter::incrementTmHits() {
  mutex->lockMutex(timeoutType, timeoutMs);
  tmHits++;
  mutex->unlockMutex();
}

void InternalErrorReporter::storeFull() { incrementStoreHits(); }

uint32_t InternalErrorReporter::getAndResetStoreHits() {
  uint32_t value;
  mutex->lockMutex(timeoutType, timeoutMs);
  value = storeHits;
  storeHits = 0;
  mutex->unlockMutex();
  return value;
}

void InternalErrorReporter::incrementStoreHits() {
  mutex->lockMutex(timeoutType, timeoutMs);
  storeHits++;
  mutex->unlockMutex();
}

object_id_t InternalErrorReporter::getObjectId() const { return SystemObject::getObjectId(); }

// MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
//   return this->commandQueue->getId();
// }

ReturnValue_t InternalErrorReporter::initialize() {
  return SystemObject::initialize();
}

void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
  this->timeoutType = timeoutType;
  this->timeoutMs = timeoutMs;
}