#include "FreshMpsocHandler.h"

#include "eive/objects.h"
#include "fsfw/action/CommandActionHelper.h"
#include "fsfw/devicehandlers/FreshDeviceHandlerBase.h"
#include "fsfw/ipc/QueueFactory.h"
#include "fsfw/returnvalues/returnvalue.h"
#include "linux/payload/MpsocCommunication.h"
#include "linux/payload/plocSupvDefs.h"

FreshMpsocHandler::FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
                                     PlocMpsocSpecialComHelper* specialComHelper,
                                     Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
    : FreshDeviceHandlerBase(cfg),
      comInterface(comInterface),
      specialComHelper(specialComHelper),
      commandActionHelper(this),
      uartIsolatorSwitch(uartIsolatorSwitch),
      hkReport(this) {
  commandActionHelperQueue = QueueFactory::instance()->createMessageQueue(10);
  eventQueue = QueueFactory::instance()->createMessageQueue(10);
  spParams.maxSize = sizeof(commandBuffer);
  spParams.buf = commandBuffer;
}

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

  if (opCode == OpCode::DEFAULT_OPERATION) {
    performDefaultDeviceOperation();
  } else if (opCode == OpCode::PARSE_TM) {
    // Just need to call this once, this should take care of processing the whole received
    // Linux UART RX buffer.
    comInterface.readSerialInterface();
    // Handle all received packets.
    while (true) {
      ReturnValue_t result = comInterface.parseAndRetrieveNextPacket();
      if (result == returnvalue::OK) {
        break;
      }
    }
  }
}

void FreshMpsocHandler::performDefaultDeviceOperation() {
  if (transitionActive) {
    if (targetMode == MODE_ON or targetMode == MODE_NORMAL) {
      handleTransitionToOn();
    } else if (targetMode == MODE_OFF) {
      handleTransitionToOff();
    } else {
      // This should never happen.
      sif::error << "FreshMpsocHandler: Invalid transition mode: " << targetMode << std::endl;
      targetMode = MODE_OFF;
      targetSubmode = 0;
      handleTransitionToOff();
    }
  } else {
    if (mode == MODE_NORMAL and not activeCmdInfo.pending) {
      // TODO: Take care of regular periodic commanding here.
    }
  }

  if (activeCmdInfo.pending and activeCmdInfo.cmdCountdown.hasTimedOut()) {
    sif::warning << "PlocMpsocHandler: Command " << activeCmdInfo.pendingCmd << " has timed out"
                 << std::endl;
    activeCmdInfo.reset();
    cmdDoneHandler(false, mpsoc::COMMAND_TIMEOUT);
  }
  EventMessage event;
  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
       result = eventQueue->receiveMessage(&event)) {
    switch (event.getMessageId()) {
      case EventMessage::EVENT_MESSAGE:
        handleEvent(&event);
        break;
      default:
        sif::debug << "PlocMPSoCHandler::performOperationHook: Did not subscribe to this event"
                   << " message" << std::endl;
        break;
    }
  }
  CommandMessage message;
  for (ReturnValue_t result = commandActionHelperQueue->receiveMessage(&message);
       result == returnvalue::OK; result = commandActionHelperQueue->receiveMessage(&message)) {
    result = commandActionHelper.handleReply(&message);
    if (result == returnvalue::OK) {
      continue;
    }
  }
}

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;
  }

  specialComHelper->setSequenceCount(&commandSequenceCount);
  result = commandActionHelper.initialize();
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  return result;
}

// HK manager abstract functions.
LocalPoolDataSetBase* FreshMpsocHandler::getDataSetHandle(sid_t sid) {
  if (sid == hkReport.getSid()) {
    return &hkReport;
  }
  return nullptr;
}

ReturnValue_t FreshMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
  localDataPoolMap.emplace(mpsoc::poolid::STATUS, &peStatus);
  localDataPoolMap.emplace(mpsoc::poolid::MODE, &peMode);
  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_PWR_ON, &peDownlinkPwrOn);
  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, &peDownlinkReplyActive);
  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, &peDownlinkJesdSyncStatus);
  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_DAC_STATUS, &peDownlinkDacStatus);
  localDataPoolMap.emplace(mpsoc::poolid::CAM_STATUS, &peCameraStatus);
  localDataPoolMap.emplace(mpsoc::poolid::CAM_SDI_STATUS, &peCameraSdiStatus);
  localDataPoolMap.emplace(mpsoc::poolid::CAM_FPGA_TEMP, &peCameraFpgaTemp);
  localDataPoolMap.emplace(mpsoc::poolid::CAM_SOC_TEMP, &peCameraSocTemp);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_TEMP, &peSysmonTemp);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCINT, &peSysmonVccInt);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCAUX, &peSysmonVccAux);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCBRAM, &peSysmonVccBram);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPAUX, &peSysmonVccPaux);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPINT, &peSysmonVccPint);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPDRO, &peSysmonVccPdro);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB12V, &peSysmonMb12V);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB3V3, &peSysmonMb3V3);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB1V8, &peSysmonMb1V8);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC12V, &peSysmonVcc12V);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC5V, &peSysmonVcc5V);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3, &peSysmonVcc3V3);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3VA, &peSysmonVcc3V3VA);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC2V5DDR, &peSysmonVcc2V5DDR);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC1V2DDR, &peSysmonVcc1V2DDR);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V9, &peSysmonVcc0V9);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V6VTT, &peSysmonVcc0V6VTT);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_SAFE_COTS_CUR, &peSysmonSafeCotsCur);
  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_NVM4_XO_CUR, &peSysmonNvm4XoCur);
  localDataPoolMap.emplace(mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, &peSemUncorrectableErrs);
  localDataPoolMap.emplace(mpsoc::poolid::SEM_CORRECTABLE_ERRS, &peSemCorrectableErrs);
  localDataPoolMap.emplace(mpsoc::poolid::SEM_STATUS, &peSemStatus);
  localDataPoolMap.emplace(mpsoc::poolid::REBOOT_MPSOC_REQUIRED, &peRebootMpsocRequired);
  poolManager.subscribeForRegularPeriodicPacket(
      subdp::RegularHkPeriodicParams(hkReport.getSid(), false, 10.0));
  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) {
  ReturnValue_t result = returnvalue::OK;
  switch (actionId) {
    case mpsoc::SET_UART_TX_TRISTATE: {
      uartIsolatorSwitch.pullLow();
      return EXECUTION_FINISHED;
      break;
    }
    case mpsoc::RELEASE_UART_TX: {
      uartIsolatorSwitch.pullHigh();
      return EXECUTION_FINISHED;
      break;
      default:
        break;
    }
  }

  if (specialComHelperExecuting) {
    return mpsoc::MPSOC_HELPER_EXECUTING;
  }

  switch (actionId) {
    case mpsoc::TC_FLASH_WRITE_FULL_FILE: {
      mpsoc::FlashBasePusCmd flashWritePusCmd;
      result = flashWritePusCmd.extractFields(data, size);
      if (result != returnvalue::OK) {
        return result;
      }
      result = specialComHelper->startFlashWrite(flashWritePusCmd.getObcFile(),
                                                 flashWritePusCmd.getMPSoCFile());
      if (result != returnvalue::OK) {
        return result;
      }
      specialComHelperExecuting = true;
      return EXECUTION_FINISHED;
    }
    case mpsoc::TC_FLASH_READ_FULL_FILE: {
      mpsoc::FlashReadPusCmd flashReadPusCmd;
      result = flashReadPusCmd.extractFields(data, size);
      if (result != returnvalue::OK) {
        return result;
      }
      result = specialComHelper->startFlashRead(flashReadPusCmd.getObcFile(),
                                                flashReadPusCmd.getMPSoCFile(),
                                                flashReadPusCmd.getReadSize());
      if (result != returnvalue::OK) {
        return result;
      }
      specialComHelperExecuting = true;
      return EXECUTION_FINISHED;
    }
    case (mpsoc::OBSW_RESET_SEQ_COUNT): {
      commandSequenceCount = 0;
      return EXECUTION_FINISHED;
    }
    default:
      break;
  }
  // For longer commands, do not set these.
  // TODO: Do all the stuff the form buildDeviceFromDevice blah did.
  executeRegularCmd(actionId, commandedBy, data, 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() {}

MessageQueueIF* FreshMpsocHandler::getCommandQueuePtr() { return commandActionHelperQueue; }

void FreshMpsocHandler::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) { return; }

void FreshMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
                                           ReturnValue_t returnCode) {
  switch (actionId) {
    case supv::START_MPSOC: {
      sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to start MPSoC" << std::endl;
      break;
    }
    case supv::SHUTDOWN_MPSOC: {
      triggerEvent(mpsoc::MPSOC_SHUTDOWN_FAILED);
      sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to shutdown MPSoC" << std::endl;
      break;
    }
    default:
      sif::debug << "PlocMPSoCHandler::stepFailedReceived: Received unexpected action reply"
                 << std::endl;
      break;
  }
  powerState = PowerState::SUPV_FAILED;
}

void FreshMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
  return;
}

void FreshMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) {
  if (actionId == supv::ACK_REPORT) {
    // I seriously don't know why this happens..
    //    sif::warning
    //        << "FreshMpsocHandler::completionSuccessfulReceived: Only received ACK report.
    //        Consider
    //        "
    //           "increasing the MPSoC boot timer."
    //        << std::endl;
  } else if (actionId != supv::EXE_REPORT) {
    sif::warning << "FreshMpsocHandler::completionSuccessfulReceived: Did not expect the action "
                 << "ID " << actionId << std::endl;
    return;
  }
  switch (powerState) {
    case PowerState::PENDING_STARTUP: {
      mpsocBootTransitionCd.resetTimer();
      powerState = PowerState::DONE;
      break;
    }
    case PowerState::PENDING_SHUTDOWN: {
      powerState = PowerState::DONE;
      break;
    }
    default: {
      break;
    }
  }
}

void FreshMpsocHandler::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
  handleActionCommandFailure(actionId);
}

void FreshMpsocHandler::handleActionCommandFailure(ActionId_t actionId) {
  switch (actionId) {
    case supv::ACK_REPORT:
    case supv::EXE_REPORT:
      break;
    default:
      sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect the action ID "
                   << actionId << std::endl;
      return;
  }
  switch (powerState) {
    case PowerState::PENDING_STARTUP: {
      sif::info << "PlocMPSoCHandler::handleActionCommandFailure: MPSoC boot command failed"
                << std::endl;
      // This is commonly the case when the MPSoC is already operational. Thus the power state is
      // set to on here
      break;
    }
    case PowerState::PENDING_SHUTDOWN: {
      // FDIR will intercept event and switch PLOC power off
      triggerEvent(mpsoc::MPSOC_SHUTDOWN_FAILED);
      sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Failed to shutdown MPSoC"
                   << std::endl;
      break;
    }
    default:
      break;
  }
  powerState = PowerState::SUPV_FAILED;
  return;
}

ReturnValue_t FreshMpsocHandler::executeRegularCmd(ActionId_t actionId,
                                                   MessageQueueId_t commandedBy,
                                                   const uint8_t* commandData,
                                                   size_t commandDataLen) {
  ReturnValue_t result;
  switch (actionId) {
    case (mpsoc::TC_MEM_WRITE): {
      result = prepareTcMemWrite(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_MEM_READ): {
      result = prepareTcMemRead(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_FLASHDELETE): {
      result = prepareTcFlashDelete(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_REPLAY_START): {
      result = prepareTcReplayStart(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_REPLAY_STOP): {
      result = prepareTcReplayStop();
      break;
    }
    case (mpsoc::TC_DOWNLINK_PWR_ON): {
      result = prepareTcDownlinkPwrOn(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_DOWNLINK_PWR_OFF): {
      result = prepareTcDownlinkPwrOff();
      break;
    }
    case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): {
      result = prepareTcReplayWriteSequence(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_GET_HK_REPORT): {
      result = prepareTcGetHkReport();
      break;
    }
    case (mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT): {
      result = prepareTcGetDirContent(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_MODE_REPLAY): {
      result = prepareTcModeReplay();
      break;
    }
    case (mpsoc::TC_MODE_IDLE): {
      result = prepareTcModeIdle();
      break;
    }
    case (mpsoc::TC_CAM_CMD_SEND): {
      result = prepareTcCamCmdSend(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_CAM_TAKE_PIC): {
      result = prepareTcCamTakePic(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_SIMPLEX_SEND_FILE): {
      result = prepareTcSimplexSendFile(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_DOWNLINK_DATA_MODULATE): {
      result = prepareTcDownlinkDataModulate(commandData, commandDataLen);
      break;
    }
    case (mpsoc::TC_MODE_SNAPSHOT): {
      result = prepareTcModeSnapshot();
      break;
    }
    default:
      sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
                 << std::endl;
      result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
      break;
  }

  if (result == returnvalue::OK) {
    activeCmdInfo.start(actionId, commandedBy);
    /**
     * Flushing the receive buffer to make sure there are no data left from a faulty reply.
     */
    comInterface.getComHelper().flushUartRxBuffer();
  }

  return result;
}

ReturnValue_t FreshMpsocHandler::prepareTcMemWrite(const uint8_t* commandData,
                                                   size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcMemWrite tcMemWrite(spParams, commandSequenceCount);
  result = tcMemWrite.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcMemWrite);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
                                                  size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcMemRead tcMemRead(spParams, commandSequenceCount);
  result = tcMemRead.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcMemRead);
  tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData,
                                                      size_t commandDataLen) {
  if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
    return mpsoc::NAME_TOO_LONG;
  }
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcFlashDelete tcFlashDelete(spParams, commandSequenceCount);
  std::string filename = std::string(reinterpret_cast<const char*>(commandData), commandDataLen);
  result = tcFlashDelete.setPayload(filename);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcFlashDelete);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcReplayStart(const uint8_t* commandData,
                                                      size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcReplayStart tcReplayStart(spParams, commandSequenceCount);
  result = tcReplayStart.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcReplayStart);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcReplayStop() {
  mpsoc::TcReplayStop tcReplayStop(spParams, commandSequenceCount);
  finishTcPrep(tcReplayStop);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
                                                        size_t commandDataLen) {
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, commandSequenceCount);
  result = tcDownlinkPwrOn.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcDownlinkPwrOn);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOff() {
  mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, commandSequenceCount);
  finishTcPrep(tcDownlinkPwrOff);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcGetHkReport() {
  mpsoc::TcGetHkReport tcGetHkReport(spParams, commandSequenceCount);
  finishTcPrep(tcGetHkReport);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
                                                              size_t commandDataLen) {
  mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, commandSequenceCount);
  ReturnValue_t result = tcReplayWriteSeq.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcReplayWriteSeq);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcModeReplay() {
  mpsoc::TcModeReplay tcModeReplay(spParams, commandSequenceCount);
  finishTcPrep(tcModeReplay);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcModeIdle() {
  mpsoc::TcModeIdle tcModeIdle(spParams, commandSequenceCount);
  finishTcPrep(tcModeIdle);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcCamCmdSend(const uint8_t* commandData,
                                                     size_t commandDataLen) {
  mpsoc::TcCamcmdSend tcCamCmdSend(spParams, commandSequenceCount);
  ReturnValue_t result = tcCamCmdSend.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcCamCmdSend);
  // TODO: Send this synchronously now..
  // nextReplyId = mpsoc::TM_CAM_CMD_RPT;
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcCamTakePic(const uint8_t* commandData,
                                                     size_t commandDataLen) {
  mpsoc::TcCamTakePic tcCamTakePic(spParams, commandSequenceCount);
  ReturnValue_t result = tcCamTakePic.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcCamTakePic);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcSimplexSendFile(const uint8_t* commandData,
                                                          size_t commandDataLen) {
  mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, commandSequenceCount);
  ReturnValue_t result = tcSimplexSendFile.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcSimplexSendFile);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcGetDirContent(const uint8_t* commandData,
                                                        size_t commandDataLen) {
  mpsoc::TcGetDirContent tcGetDirContent(spParams, commandSequenceCount);
  ReturnValue_t result = tcGetDirContent.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcGetDirContent);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData,
                                                               size_t commandDataLen) {
  mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, commandSequenceCount);
  ReturnValue_t result = tcDownlinkDataModulate.setPayload(commandData, commandDataLen);
  if (result != returnvalue::OK) {
    return result;
  }
  finishTcPrep(tcDownlinkDataModulate);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::prepareTcModeSnapshot() {
  mpsoc::TcModeSnapshot tcModeSnapshot(spParams, commandSequenceCount);
  finishTcPrep(tcModeSnapshot);
  return returnvalue::OK;
}

ReturnValue_t FreshMpsocHandler::finishTcPrep(mpsoc::TcBase& tcBase) {
  // TODO: Fix this, similar to how it was done for the SUPV. might be able to implement this
  // in a simpler way, only allowing strictly sequential commanding.
  // nextReplyId = mpsoc::ACK_REPORT;
  ReturnValue_t result = tcBase.finishPacket();
  if (result != returnvalue::OK) {
    return result;
  }
  // rawPacket = commandBuffer;
  // rawPacketLen = tcBase.getFullPacketLen();
  commandSequenceCount++;

  if (DEBUG_MPSOC_COMMUNICATION) {
    sif::debug << "SEND MPSOC packet. APID 0x" << std::hex << std::setw(3) << tcBase.getApid()
               << " Size " << std::dec << tcBase.getFullPacketLen() << " SSC "
               << tcBase.getSeqCount() << std::endl;
  }
  activeCmdInfo.cmdCountdown.resetTimer();
  return returnvalue::OK;
}

void FreshMpsocHandler::handleEvent(EventMessage* eventMessage) {
  // TODO: Shouldn't we check for specific events?
  object_id_t objectId = eventMessage->getReporter();
  switch (objectId) {
    case objects::PLOC_MPSOC_HANDLER: {
      specialComHelperExecuting = false;
      break;
    }
    default:
      sif::debug << "PlocMPSoCHandler::handleEvent: Did not subscribe to this event" << std::endl;
      break;
  }
}

void FreshMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
  activeCmdInfo.pending = false;
  if (activeCmdInfo.commandedBy != MessageQueueIF::NO_QUEUE) {
    actionHelper.finish(success, activeCmdInfo.commandedBy, activeCmdInfo.pendingCmd, result);
  }
}

ReturnValue_t FreshMpsocHandler::handleDeviceReply() {
  ReturnValue_t result = returnvalue::OK;

  // SpacePacketReader spacePacket;
  // spacePacket.setReadOnlyData(start, remainingSize);
  auto& replyReader = comInterface.getSpReader();
  if (DEBUG_MPSOC_COMMUNICATION) {
    sif::debug << "RECV MPSOC packet. APID 0x" << std::hex << std::setw(3) << replyReader.getApid()
               << std::dec << " Size " << replyReader.getFullPacketLen() << " SSC "
               << replyReader.getSequenceCount() << std::endl;
  }
  if (replyReader.isNull()) {
    return returnvalue::FAILED;
  }
  auto res = replyReader.checkSize();
  if (res != returnvalue::OK) {
    return res;
  }
  uint16_t apid = replyReader.getApid();

  // auto handleDedicatedReply = [&](DeviceCommandId_t replyId) {
  //*foundLen = spacePacket.getFullPacketLen();
  // foundPacketLen = *foundLen;
  // *foundId = replyId;
  // };
  switch (apid) {
    case (mpsoc::apid::ACK_SUCCESS):
      // *foundLen = mpsoc::SIZE_ACK_REPORT;
      //*foundId = mpsoc::ACK_REPORT;
      result = handleAckReport();

      break;
    case (mpsoc::apid::ACK_FAILURE):
      // *foundLen = mpsoc::SIZE_ACK_REPORT;
      //*foundId = mpsoc::ACK_REPORT;
      break;
    case (mpsoc::apid::TM_MEMORY_READ_REPORT):
      // *foundLen = tmMemReadReport.rememberRequestedSize;
      //*foundId = mpsoc::TM_MEMORY_READ_REPORT;
      result = handleMemoryReadReport(packet);
      break;
    case (mpsoc::apid::TM_CAM_CMD_RPT):
      // handleDedicatedReply(mpsoc::TM_CAM_CMD_RPT);
      result = handleCamCmdRpt(packet);
      break;
    case (mpsoc::apid::TM_HK_GET_REPORT): {
      // handleDedicatedReply(mpsoc::TM_GET_HK_REPORT);
      result = handleGetHkReport(packet);
      break;
    }
    case (mpsoc::apid::TM_FLASH_DIRECTORY_CONTENT): {
      // handleDedicatedReply(mpsoc::TM_FLASH_DIRECTORY_CONTENT);
      // result = verifyPacket(packet, foundPacketLen);
      // if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
      // sif::warning << "PLOC MPSoC: Flash directory content reply invalid CRC" << std::endl;
      // }
      /** Send data to commanding queue */
      handleDeviceTm(packet + mpsoc::DATA_FIELD_OFFSET,
                     foundPacketLen - mpsoc::DATA_FIELD_OFFSET - mpsoc::CRC_SIZE,
                     mpsoc::TM_FLASH_DIRECTORY_CONTENT);
      // nextReplyId = mpsoc::EXE_REPORT;
      return result;
      break;
    }
    case (mpsoc::apid::EXE_SUCCESS):
      //*foundLen = mpsoc::SIZE_EXE_REPORT;
      //*foundId = mpsoc::EXE_REPORT;
      result = handleExecutionReport(packet);
      break;
    case (mpsoc::apid::EXE_FAILURE):
      //*foundLen = mpsoc::SIZE_EXE_REPORT;
      //*foundId = mpsoc::EXE_REPORT;
      result = handleExecutionReport(packet);
      break;
    default: {
      sif::debug << "FreshMpsocHandler:: Reply has invalid APID 0x" << std::hex << std::setfill('0')
                 << std::setw(2) << apid << std::dec << std::endl;
      //*foundLen = remainingSize;
      return mpsoc::INVALID_APID;
    }
  }

  // TODO: Rework sequence count handling.
  uint16_t sequenceCount = replyReader.getSequenceCount();
  if (sequenceCount != lastReplySequenceCount + 1) {
    // TODO: Trigger event for possible missing reply packet to inform operator.
  }
  lastReplySequenceCount = sequenceCount;

  return result;
}

ReturnValue_t FreshMpsocHandler::handleAckReport() {
  ReturnValue_t result = returnvalue::OK;
  auto& replyReader = comInterface.getSpReader();

  // result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
  // if (result == mpsoc::CRC_FAILURE) {
  // sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
  // nextReplyId = mpsoc::NONE;
  // replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
  // triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
  // sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
  // disableAllReplies();
  // return IGNORE_REPLY_DATA;
  //}

  // uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;

  switch (replyReader.getApid()) {
    case mpsoc::apid::ACK_FAILURE: {
      // DeviceCommandId_t commandId = getPendingCommand();
      uint16_t status = mpsoc::getStatusFromRawData(replyReader.getFullData());
      sif::warning << "MPSoC ACK Failure: " << mpsoc::getStatusString(status) << std::endl;
      if (activeCmdInfo.pendingCmd != DeviceHandlerIF::NO_COMMAND_ID) {
        triggerEvent(ACK_FAILURE, commandId, status);
      }
      sendFailureReport(mpsoc::ACK_REPORT, status);
      disableAllReplies();
      nextReplyId = mpsoc::NONE;
      result = IGNORE_REPLY_DATA;
      break;
    }
    case mpsoc::apid::ACK_SUCCESS: {
      setNextReplyId();
      break;
    }
    default: {
      sif::debug << "PlocMPSoCHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
      result = returnvalue::FAILED;
      break;
    }
  }

  return result;
}