#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
#define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_

#include <string>

#include "PlocMPSoCHelper.h"
#include "fsfw/action/CommandActionHelper.h"
#include "fsfw/action/CommandsActionsIF.h"
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
#include "fsfw/ipc/QueueFactory.h"
#include "fsfw/tmtcservices/SourceSequenceCounter.h"
#include "fsfw_hal/linux/gpio/Gpio.h"
#include "fsfw_hal/linux/uart/UartComIF.h"
#include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"
#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"

/**
 * @brief	This is the device handler for the MPSoC of the payload computer.
 *
 * @details The PLOC uses the space packet protocol for communication. Each command will be
 *          answered with at least one acknowledgment and one execution report.
 *          Flight manual:
 * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC ICD:
 * https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263
 *
 * @note The sequence count in the space packets must be incremented with each received and sent
 *       packet otherwise the MPSoC will reply with an acknowledgment failure report.
 *
 * @author	J. Meier
 */
class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
 public:
  /**
   * @brief Constructor
   *
   * @param ojectId             Object ID of the MPSoC handler
   * @param uartcomIFid         Object ID of the UART communication interface
   * @param comCookie           UART communication cookie
   * @param plocMPSoCHelper     Pointer to MPSoC helper object
   * @param uartIsolatorSwitch  Gpio object representing the GPIO connected to the UART isolator
   *                            module in the programmable logic
   * @param supervisorHandler   Object ID of the supervisor handler
   */
  PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
                   PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch,
                   object_id_t supervisorHandler);
  virtual ~PlocMPSoCHandler();
  virtual ReturnValue_t initialize() override;
  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                              const uint8_t* data, size_t size) override;
  void performOperationHook() override;
  MessageQueueIF* getCommandQueuePtr() override;
  void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
  void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override;
  void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override;
  void completionSuccessfulReceived(ActionId_t actionId) override;
  void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;

 protected:
  void doStartUp() override;
  void doShutDown() override;
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
  void fillCommandAndReplyMap() override;
  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
                                        size_t commandDataLen) override;
  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
                             size_t* foundLen) override;
  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
  void setNormalDatapoolEntriesInvalid() override;
  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                        LocalDataPoolManager& poolManager) override;
  ReturnValue_t enableReplyInReplyMap(DeviceCommandMap::iterator command,
                                      uint8_t expectedReplies = 1, bool useAlternateId = false,
                                      DeviceCommandId_t alternateReplyID = 0) override;
  size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
  virtual ReturnValue_t doSendReadHook() override;

 private:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;

  //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
  static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report
  //! P1: Command Id which leads the acknowledgment failure report
  //! P2: The status field inserted by the MPSoC into the data field
  static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC receive execution failure report
  //! P1: Command Id which leads the execution failure report
  //! P2: The status field inserted by the MPSoC into the data field
  static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC reply has invalid crc
  static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
  //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected
  //! count P1: Expected sequence count P2: Received sequence count
  static const Event MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
  //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and
  //! thus also to shutdown the supervisor.
  static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH);

  static const uint16_t APID_MASK = 0x7FF;
  static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
  static const uint8_t STATUS_OFFSET = 10;

  MessageQueueIF* eventQueue = nullptr;
  MessageQueueIF* commandActionHelperQueue = nullptr;

  // Initiate the sequence count with the maximum value. It is incremented before
  // a packet is sent, so the first value will be 0 accordingly using
  // the wrap around of the counter.
  SourceSequenceCounter sequenceCount = SourceSequenceCounter(ccsds::LIMIT_SEQUENCE_COUNT - 1);

  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
  SpacePacketCreator creator;
  ploc::SpTcParams spParams = ploc::SpTcParams(creator);

  /**
   * This variable is used to store the id of the next reply to receive. This is necessary
   * because the PLOC sends as reply to each command at least one acknowledgment and execution
   * report.
   */
  DeviceCommandId_t nextReplyId = mpsoc::NONE;

  UartComIF* uartComIf = nullptr;

  PlocMPSoCHelper* plocMPSoCHelper = nullptr;
  Gpio uartIsolatorSwitch;
  object_id_t supervisorHandler = 0;
  CommandActionHelper commandActionHelper;

  // Used to block incoming commands when MPSoC helper class is currently executing a command
  bool plocMPSoCHelperExecuting = false;

  struct TmMemReadReport {
    static const uint8_t FIX_SIZE = 14;
    size_t rememberRequestedSize = 0;
  };

  TmMemReadReport tmMemReadReport;

  struct TmCamCmdRpt {
    size_t rememberSpacePacketSize = 0;
  };

  TmCamCmdRpt tmCamCmdRpt;

  struct TelemetryBuffer {
    uint16_t length = 0;
    uint8_t buffer[mpsoc::SP_MAX_SIZE];
  };

  TelemetryBuffer tmBuffer;

  enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };

  PowerState powerState = PowerState::OFF;

  /**
   * @brief   Handles events received from the PLOC MPSoC helper
   */
  void handleEvent(EventMessage* eventMessage);

  ReturnValue_t prepareTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcMemRead(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcReplayStop();
  ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcDownlinkPwrOff();
  ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareTcModeIdle();
  void finishTcPrep(size_t packetLen);

  /**
   * @brief   This function checks the crc of the received PLOC reply.
   *
   * @param start Pointer to the first byte of the reply.
   * @param foundLen  Pointer to the length of the whole packet.
   *
   * @return  returnvalue::OK if CRC is ok, otherwise CRC_FAILURE.
   */
  ReturnValue_t verifyPacket(const uint8_t* start, size_t foundLen);

  /**
   * @brief   This function handles the acknowledgment report.
   *
   * @param data  Pointer to the data holding the acknowledgment report.
   *
   * @return  returnvalue::OK if successful, otherwise an error code.
   */
  ReturnValue_t handleAckReport(const uint8_t* data);

  /**
   * @brief   This function handles the data of a execution report.
   *
   * @param data  Pointer to the received data packet.
   *
   * @return  returnvalue::OK if successful, otherwise an error code.
   */
  ReturnValue_t handleExecutionReport(const uint8_t* data);

  /**
   * @brief   This function handles the memory read report.
   *
   * @param data  Pointer to the data buffer holding the memory read report.
   *
   * @return  returnvalue::OK if successful, otherwise an error code.
   */
  ReturnValue_t handleMemoryReadReport(const uint8_t* data);

  ReturnValue_t handleCamCmdRpt(const uint8_t* data);

  /**
   * @brief   Depending on the current active command, this function sets the reply id of the
   *          next reply after a successful acknowledgment report has been received. This is
   *          required by the function getNextReplyLength() to identify the length of the next
   *          reply to read.
   */
  void setNextReplyId();

  /**
   * @brief   This function handles action message replies in case the telemetry has been
   *          requested by another object.
   *
   * @param data  Pointer to the telemetry data.
   * @param dataSize  Size of telemetry in bytes.
   * @param replyId   Id of the reply. This will be added to the ActionMessage.
   */
  void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);

  /**
   * @brief   In case an acknowledgment failure reply has been received this function disables
   *          all previously enabled commands and resets the exepected replies variable of an
   *          active command.
   */
  void disableAllReplies();

  /**
   * @brief   This function sends a failure report if the active action was commanded by an other
   *          object.
   *
   * @param replyId   The id of the reply which signals a failure.
   * @param status    A status byte which gives information about the failure type.
   */
  void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);

  /**
   * @brief   This function disables the execution report reply. Within this function also the
   *          the variable expectedReplies of an active command will be set to 0.
   */
  void disableExeReportReply();

  void printStatus(const uint8_t* data);

  ReturnValue_t prepareTcModeReplay();

  uint16_t getStatus(const uint8_t* data);

  void handleActionCommandFailure(ActionId_t actionId);

  std::string getStatusString(uint16_t status);
};

#endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */