#include "FreshMpsocHandler.h"

#include "fsfw/devicehandlers/FreshDeviceHandlerBase.h"
#include "fsfw/ipc/QueueFactory.h"
#include "fsfw/returnvalues/returnvalue.h"
#include "linux/payload/MpsocCommunication.h"

FreshMpsocHandler::FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
                                     PlocMpsocSpecialComHelper* plocMPSoCHelper,
                                     Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
    : FreshDeviceHandlerBase(cfg), comInterface(comInterface) {
  eventQueue = QueueFactory::instance()->createMessageQueue(10);
}

void FreshMpsocHandler::performDeviceOperation(uint8_t opCode) {
  if (not transitionActive and mode == MODE_OFF) {
    // Nothing to do for now.
    return;
  }
}

ReturnValue_t FreshMpsocHandler::handleCommandMessage(CommandMessage* message) {
  return FreshDeviceHandlerBase::handleCommandMessage(message);
}

ReturnValue_t FreshMpsocHandler::initialize() {
  ReturnValue_t result = FreshDeviceHandlerBase::initialize();
  if (result != returnvalue::OK) {
    return result;
  }
  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
  if (manager == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "PlocMPSoCHandler::initialize: Invalid event manager" << std::endl;
#endif
    return ObjectManagerIF::CHILD_INIT_FAILED;
    ;
  }
  result = manager->registerListener(eventQueue->getId());
  if (result != returnvalue::OK) {
    return result;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_FAILED));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(),
      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(),
      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_SUCCESSFUL));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_FAILED));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }

  result = specialComHelper->setComIF(communicationInterface);
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  specialComHelper->setComCookie(comCookie);
  specialComHelper->setSequenceCount(&sequenceCount);
  result = commandActionHelper.initialize();
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  return result;
}

// HK manager abstract functions.
LocalPoolDataSetBase* FreshMpsocHandler::getDataSetHandle(sid_t sid) {}
ReturnValue_t FreshMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
  return returnvalue::OK;
}

// Mode abstract functions
ReturnValue_t FreshMpsocHandler::checkModeCommand(Mode_t mode, Submode_t submode,
                                                  uint32_t* msToReachTheMode) {
  return returnvalue::OK;
}

// Action override. Forward to user.
ReturnValue_t FreshMpsocHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                               const uint8_t* data, size_t size) {
  return returnvalue::OK;
}

/**
 * @overload
 * @param submode
 */
void FreshMpsocHandler::startTransition(Mode_t newMode, Submode_t submode) {}

ReturnValue_t FreshMpsocHandler::performDeviceOperationPreQueueHandling(uint8_t opCode) {
  return returnvalue::OK;
}

void FreshMpsocHandler::handleTransitionToOn() {}

void FreshMpsocHandler::handleTransitionToOff() {}