#ifndef MISSION_DEVICES_GOMSPACEDEVICEHANDLER_H_
#define MISSION_DEVICES_GOMSPACEDEVICEHANDLER_H_

#include <mission/devices/devicedefinitions/GomSpacePackets.h>

#include "fsfw/devicehandlers/DeviceHandlerBase.h"
#include "mission/devices/devicedefinitions/GomspaceActions.h"
#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
#include "returnvalues/classIds.h"

/**
 * @brief	This is the device handler class for all gomspace devices.
 *
 * @details
 * All gomspace devices are similar with respect to commanding. Thusmost of the functionality to
 * command a gomspace device can be accommodated in one class. For device specific functions, a new
 * class could be created by inheriting from the GomspaceDeviceHandler.
 *
 * Flight manual:
 * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/Gomspace_PCDU_P60_System
 */
class GomspaceDeviceHandler : public DeviceHandlerBase {
 public:
  static constexpr uint8_t CLASS_ID = CLASS_ID::GOM_SPACE_HANDLER;
  static const ReturnValue_t PACKET_TOO_LONG = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
  static const ReturnValue_t INVALID_TABLE_ID = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
  static const ReturnValue_t INVALID_ADDRESS = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
  static const ReturnValue_t INVALID_PARAM_SIZE = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 3);
  static const ReturnValue_t INVALID_PAYLOAD_SIZE = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 4);
  static const ReturnValue_t UNKNOWN_REPLY_ID = HasReturnvaluesIF::makeReturnCode(CLASS_ID, 5);

  /**
   * @brief	Constructor
   *
   * @param maxConfigTableAddress	The maximum memory address of the configu-
   * 								ration table of a gomspace device.
   * @param maxHkTableAddress	The maximum memory address of a value in the
   * 							houskeeping (telemetry) table of a gomspace
   * 							device.
   */
  GomspaceDeviceHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
                        FailureIsolationBase *customFdir, uint16_t maxConfigTableAddress,
                        uint16_t maxHkTableAddress, uint16_t hkTableReplySize);
  virtual ~GomspaceDeviceHandler();

  /**
   * @brief   This function can be used to set a gomspace device to normal mode immediately after
   *          object creation.
   */
  void setModeNormal();

  /**
   * @brief	Function to generate the ping command for the ComIF.
   */
  ReturnValue_t handleAction(PingAction *action);

  /**
   * @brief	Function to generate the command to reboot a gomspace device
   * 			via the ComIF.
   */
  ReturnValue_t handleAction(RebootAction *action);

  /**
   * @brief	Function to generate the command to force a ground watchdog
   * 			reset in a gomspace device.
   */
  ReturnValue_t handleAction(GndwdtResetAction *action);

  /**
   * @brief	Function to generate the command to get a parameter from a
   * 			gomspace device. Command will be sent to the ComIF over the
   * 			rawPacket buffer.
   */
  ReturnValue_t handleAction(ParamGetAction *action);

  /**
   * @brief	Function to generate the command to set a parameter. Command
   * 			will be sent to the ComIF over the rawPacket buffer.
   */
  ReturnValue_t handleAction(ParamSetAction *action);
  ReturnValue_t handleAction(RequestHkTableAction *action);
  ReturnValue_t handleAction(PrintSwitchVIAction *action);
  ReturnValue_t handleAction(PrintLatchupsAction *action);

 protected:
  static const uint8_t MAX_PACKET_LEN = 36;
  static const uint8_t PARAM_SET_OK = 1;
  static const uint8_t PING_REPLY_SIZE = 2;

  uint8_t rememberRequestedSize = 0;
  uint8_t rememberCommandId = GomspaceCommands::NONE;
  uint8_t cspPacket[MAX_PACKET_LEN];

  uint16_t maxConfigTableAddress;
  uint16_t maxHkTableAddress;

  /** The size of the reply following a full hk table request.*/
  uint16_t hkTableReplySize;

  LocalPoolDataSetBase *hkTableDataset = nullptr;

  PingAction pingAction = PingAction(this);
  RebootAction rebootAction = RebootAction(this);
  GndwdtResetAction gndwdtResetAction = GndwdtResetAction(this);
  ParamGetAction paramGetAction = ParamGetAction(this);
  ParamSetAction paramSetAction = ParamSetAction(this);
  RequestHkTableAction requestHkTableAction = RequestHkTableAction(this);
  PrintSwitchVIAction printSwitchVIAction = PrintSwitchVIAction(this);
  PrintLatchupsAction printLatchupsAction = PrintLatchupsAction(this);

  void doStartUp() override;
  void doShutDown() override;
  virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
  virtual void fillCommandAndReplyMap() 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;

  /**
   * This command handles printing the HK table to the console. This is useful for debugging
   * purposes
   * @return
   * TODO replace by overriding the handleAction()?
   */
  virtual ReturnValue_t printStatus(DeviceCommandId_t cmd);

  /**
   * @brief	Because housekeeping tables are device specific the handling of the reply is
   * 			given to the child class.
   * @param id	The id of the command which initiates the full table request.
   * @param packet	Pointer to the reply containing the hk table.
   */
  virtual void letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) = 0;

  virtual LocalPoolDataSetBase *getDataSetHandle(sid_t sid) = 0;

  /**
   * @brief   Can be overriden by child classes to implement device specific commands.
   * @return Return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED to let this handler handle
   *   the command or RETURN_OK if the child handles the command
   */
  virtual ReturnValue_t childCommandHook(DeviceCommandId_t cmd, const uint8_t *commandData,
                                         size_t commandDataLen);

  ReturnValue_t parsePduHkTable(PDU::PduCoreHk &coreHk, PDU::PduAuxHk &auxHk,
                                const uint8_t *packet);
  ReturnValue_t initializePduPool(localpool::DataPool &localDataPoolMap,
                                  LocalDataPoolManager &poolManager,
                                  std::array<uint8_t, PDU::CHANNELS_LEN> initOutEnb);

 private:
  SetParamMessageCache setParamCacher;

  /**
   * Callback is called on a parameter set command. It is called before executing it and
   * after successful execution
   * @param unpacker Passed before
   * @param beforeSet False for callback before execution, true if called after successful
   *   execution
   * @return
   */
  virtual ReturnValue_t setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes,
                                         bool afterExecution);
};

#endif /* MISSION_DEVICES_GOMSPACEDEVICEHANDLER_H_ */