#pragma once

#include "fsfw/action.h"
#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
#include "fsfw/devicehandlers/DeviceHandlerIF.h"
#include "fsfw/health/HasHealthIF.h"
#include "fsfw/health/HealthHelper.h"
#include "fsfw/modes/HasModesIF.h"
#include "fsfw/objectmanager.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;
  uint32_t msgQueueDepth = 10;
};
class FreshDeviceHandlerBase : public SystemObject,
                               public DeviceHandlerIF,
                               public HasModesIF,
                               public HasHealthIF,
                               public ExecutableObjectIF,
                               public ModeTreeChildIF,
                               public ModeTreeConnectionIF,
                               public HasActionsIF,
                               public HasLocalDataPoolIF {
 public:
  explicit FreshDeviceHandlerBase(DhbConfig config);
  virtual ~FreshDeviceHandlerBase() 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;

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

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

  // Executable overrides.
  ReturnValue_t performOperation(uint8_t opCode) override;
  ReturnValue_t initializeAfterTaskCreation() override;

  // System Object overrides.
  ReturnValue_t initialize() override;
  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;

  // Health Overrides.
  ReturnValue_t setHealth(HealthState health) override;
  HasHealthIF::HealthState getHealth() override;

  // Executable Overrides.
  void setTaskIF(PeriodicTaskIF* task) 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;

  // Action overrides.
  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                      const uint8_t* data, size_t size) = 0;

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

 protected:
  virtual ReturnValue_t handleQueue();

  // Mode Helpers.
  virtual void modeChanged(Mode_t mode, Submode_t submode);
  void startTransition(Mode_t mode, Submode_t submode) override;
  void getMode(Mode_t* mode, Submode_t* submode) override;
  void setToExternalControl() override;
  void announceMode(bool recursive) override;

 private:
  ActionHelper actionHelper;
  ModeHelper modeHelper;
  HealthHelper healthHelper;
  LocalDataPoolManager poolManager;

  /**
   * 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;

  // Pool Manager overrides.
  LocalDataPoolManager* getHkManagerHandle() override;
};