#pragma once

#include "fsfw/action.h"
#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
#include "fsfw/devicehandlers/DeviceHandlerIF.h"
#include "fsfw/fdir/FailureIsolationBase.h"
#include "fsfw/health/HasHealthIF.h"
#include "fsfw/health/HealthHelper.h"
#include "fsfw/modes/HasModesIF.h"
#include "fsfw/objectmanager.h"
#include "fsfw/parameters/ParameterHelper.h"
#include "fsfw/parameters/ReceivesParameterMessagesIF.h"
#include "fsfw/retval.h"
#include "fsfw/subsystem/ModeTreeChildIF.h"
#include "fsfw/subsystem/ModeTreeConnectionIF.h"
#include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/tasks/PeriodicTaskIF.h"

struct DhbConfig {
  explicit DhbConfig(object_id_t objectId) : objectId(objectId) {}
  object_id_t objectId;
  FailureIsolationBase* fdirInstance = nullptr;
  object_id_t defaultFdirParent = objects::NO_OBJECT;
  uint32_t msgQueueDepth = 10;
};

class FreshDeviceHandlerBase : public SystemObject,
                               public DeviceHandlerIF,
                               public HasModesIF,
                               public HasHealthIF,
                               public ExecutableObjectIF,
                               public ModeTreeChildIF,
                               public ModeTreeConnectionIF,
                               public HasActionsIF,
                               public ReceivesParameterMessagesIF,
                               public HasLocalDataPoolIF {
 public:
  explicit FreshDeviceHandlerBase(DhbConfig config);
  ~FreshDeviceHandlerBase() override;

  /**
   * Periodic helper executed function, implemented by child class.
   */
  virtual void performDeviceOperation(uint8_t opCode) = 0;

  [[nodiscard]] object_id_t getObjectId() const override;

  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;

  HasHealthIF::HealthState getHealth() override;

  // Mode Tree Overrides.
  [[nodiscard]] const HasHealthIF* getOptHealthIF() const override;
  [[nodiscard]] const HasModesIF& getModeIF() const override;
  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
  ModeTreeChildIF& getModeTreeChildIF() override;

  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;

 protected:
  // Pool Manager overrides.
  LocalDataPoolManager* getHkManagerHandle() override;
  ActionHelper actionHelper;
  ModeHelper modeHelper;
  HealthHelper healthHelper;
  ParameterHelper paramHelper;
  LocalDataPoolManager poolManager;

  bool hasCustomFdir = false;
  FailureIsolationBase* fdirInstance;
  object_id_t defaultFdirParent;

  /**
   * Pointer to the task which executes this component,
   * is invalid before setTaskIF was called.
   */
  PeriodicTaskIF* executingTask = nullptr;

  Mode_t mode = HasModesIF::MODE_UNDEFINED;
  Submode_t submode = 0;

  MessageQueueIF* messageQueue;

  /**
   * The default queue handler will process all messages for the interfaces implemented
   * by this class. If there are special requirements, for example that action commands are
   * received on a different queue, the user can override this function for those special
   * requirements.
   */
  virtual ReturnValue_t handleQueue();

  // Mode Helpers.
  virtual void modeChanged(Mode_t mode, Submode_t submode);
  /**
   * The default implementation sets the new mode immediately. If this is not applicable for
   * certain modes, the user should provide a custom implementation, which performs rougly
   * the same functionality of this function, when all the steps have been taken to reach the
   * new mode.
   */
  void startTransition(Mode_t mode, Submode_t submode) override;
  virtual void setMode(Mode_t newMode, Submode_t newSubmode);
  virtual void setMode(Mode_t newMode);
  void getMode(Mode_t* mode, Submode_t* submode) override;
  void setToExternalControl() override;
  void announceMode(bool recursive) override;
  // System Object overrides.
  ReturnValue_t initialize() override;

  /**
   * Implemented by child class. Handle all command messages which are
   * not health, mode, action or housekeeping messages.
   * @param message
   * @return
   */
  virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;

  // HK manager abstract functions.
  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                        LocalDataPoolManager& poolManager) override = 0;

  // Mode abstract functions
  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                 uint32_t* msToReachTheMode) override = 0;
  // Health Overrides.
  ReturnValue_t setHealth(HealthState health) override;
  // Action override. Forward to user.
  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                              const uint8_t* data, size_t size) override = 0;
  // Executable overrides.
  ReturnValue_t performOperation(uint8_t opCode) override;
  ReturnValue_t initializeAfterTaskCreation() override;

  /**
   * This calls the FDIR instance event trigger function.
   * @param event
   * @param parameter1
   * @param parameter2
   */
  void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override;
  /**
   * This calls the FDIR instance event forward function.
   * @param event
   * @param parameter1
   * @param parameter2
   */
  void forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const override;
  /**
   * This implementation handles the FDIR parameters. The user can override this to handle
   * custom parameters.
   * @param domainId
   * @param uniqueId
   * @param parameterWrapper
   * @param newValues
   * @param startAtIndex
   * @return
   */
  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;

  virtual ReturnValue_t performDeviceOperationPreQueueHandling(uint8_t opCode);

 private:
  // Executable Overrides.
  void setTaskIF(PeriodicTaskIF* task) override;
};