#ifndef FSFW_OSAL_LINUX_MESSAGEQUEUE_H_
#define FSFW_OSAL_LINUX_MESSAGEQUEUE_H_

#include <fsfw/ipc/MessageQueueBase.h>
#include <mqueue.h>

#include "fsfw/internalerror/InternalErrorReporterIF.h"
#include "fsfw/ipc/MessageQueueIF.h"
#include "fsfw/ipc/MessageQueueMessage.h"
#include "fsfw/ipc/definitions.h"
/**
 * @brief		This class manages sending and receiving of message queue messages.
 *
 * @details
 * Message queues are used to pass asynchronous messages between processes.
 * They work like post boxes, where all incoming messages are stored in FIFO
 * order. This class creates a new receiving queue and provides methods to fetch
 * received messages. Being a child of MessageQueueSender, this class also
 * provides methods to send a message to a user-defined or a default destination.
 * In addition it also provides a reply method to answer to the queue it
 * received its last message from.
 *
 * The MessageQueue should be used as "post box" for a single owning object.
 * So all message queue communication is "n-to-one".
 *
 * The creation of message queues, as well as sending and receiving messages,
 * makes use of the operating system calls provided.
 *	@ingroup message_queue
 */
class MessageQueue : public MessageQueueBase {
  friend class MessageQueueSenderIF;

 public:
  /**
   * @brief	The constructor initializes and configures the message queue.
   * @details	By making use of the according operating system call, a message queue is created
   * 			and initialized. The message depth - the maximum number of messages to be
   * 			buffered - may be set with the help of a parameter, whereas the message size
   * is automatically set to the maximum message queue message size. The operating system sets the
   * message queue id, or i case of failure, it is set to zero.
   * @param message_depth	The number of messages to be buffered before passing an error to the
   * 						sender. Default is three.
   * @param max_message_size	With this parameter, the maximum message size can be adjusted.
   * 							This should be left default.
   */
  MessageQueue(uint32_t messageDepth = 3,
               size_t maxMessageSize = MessageQueueMessage::MAX_MESSAGE_SIZE,
               MqArgs* args = nullptr);

  /** Copying message queues forbidden */
  MessageQueue(const MessageQueue&) = delete;
  MessageQueue& operator=(const MessageQueue&) = delete;

  /**
   * @brief	The destructor deletes the formerly created message queue.
   * @details	This is accomplished by using the delete call provided by the operating system.
   */
  virtual ~MessageQueue();

  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
  ReturnValue_t flush(uint32_t* count) override;
  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;

 protected:
  /**
   * Implementation to be called from any send Call within MessageQueue and MessageQueueSenderIF
   * 	 \details	This method takes the message provided, adds the sentFrom information and
   * passes it on to the destination provided with an operating system call. The OS's return value
   * is returned. \param sendTo	This parameter specifies the message queue id to send the message
   * to. \param message	This is a pointer to a previously created message, which is sent. \param
   * sentFrom	The sentFrom information can be set to inject the sender's queue id into the
   * message. This variable is set to zero by default. \param ignoreFault If set to true, the
   * internal software fault counter is not incremented if queue is full.
   */
  static ReturnValue_t sendMessageFromMessageQueue(MessageQueueId_t sendTo,
                                                   MessageQueueMessageIF* message,
                                                   MessageQueueId_t sentFrom = NO_QUEUE,
                                                   bool ignoreFault = false);

 private:
  /**
   * The name of the message queue, stored for unlinking
   */
  char name[16] = {};

  static uint16_t queueCounter;
  const size_t maxMessageSize;

  static constexpr const char* CLASS_NAME = "MessageQueue";
  ReturnValue_t handleOpenError(mq_attr* attributes, uint32_t messageDepth);
};

#endif /* FSFW_OSAL_LINUX_MESSAGEQUEUE_H_ */