#ifndef BSP_Q7S_DEVICES_STRIMAGELOADER_H_
#define BSP_Q7S_DEVICES_STRIMAGELOADER_H_

#include <string>
#include "ArcsecDatalinkLayer.h"
#include "fsfw/osal/linux/BinarySemaphore.h"
#include "bsp_q7s/memory/SdCardManager.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
#include "fsfw/devicehandlers/CookieIF.h"

extern "C" {
    #include "thirdparty/arcsec_star_tracker/common/generated/tmtcstructs.h"
    #include "thirdparty/arcsec_star_tracker/client/generated/actionreq.h"
}

/**
 * @brief   An object of this class runs in a separate task and is responsible for uploading and
 *          downloading images to/from the star tracker. This is required because uploading and
 *          downloading via the star tracker handler takes a lot of time because each upload or
 *          download packet can transport a maximum of 1024 bytes.
 */
class StrImageLoader: public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
public:

    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_IMAGE_LOADER;

    //! [EXPORT] : [COMMENT] Try to upload image but specified image does not exist
    static const Event IMAGE_FILE_NOT_EXISTS = MAKE_EVENT(0, severity::LOW);
    //! [EXPORT] : [COMMENT] Sending image upload packet to star tracker failed
    //!P1: Return code of communication interface sendMessage function
    //!P2: Position of upload packet for which the transmission failed
    static const Event SENDING_UPLOAD_PACKET_FAILED = MAKE_EVENT(1, severity::LOW);
    //! [EXPORT] : [COMMENT] Communication interface requesting reply failed
    //!P1: Return code of failed request
    //!P1: Upload position for which the request failed
    static const Event UPLOAD_REQUESTING_MSG_FAILED = MAKE_EVENT(2, severity::LOW);
    //! [EXPORT] : [COMMENT] Uploading image to star tracker was successful
    static const Event IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
    //! [EXPORT] : [COMMENT] Failed to read communication interface reply data
    //!P1: Return code of failed communication interface read call
    //!P1: Upload position for which the read call failed
    static const Event UPLOAD_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
    //! [EXPORT] : [COMMENT] Unexpected stop of decoding sequence
    //!P1: Return code of failed communication interface read call
    //!P1: Upload position for which the read call failed
    static const Event UPLOAD_COM_ERROR = MAKE_EVENT(5, severity::LOW);
    //! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off)
    //!P1: Position of upload packet for which no reply was sent
    static const Event NO_REPLY = MAKE_EVENT(6, severity::LOW);
    //! [EXPORT] : [COMMENT] Received reply with invalid type ID
    static const Event INVALID_TYPE_ID = MAKE_EVENT(7, severity::LOW);
    //! [EXPORT] : [COMMENT] Status field in reply signals error
    static const Event STATUS_ERROR = MAKE_EVENT(8, severity::LOW);
    //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred
    //P1: Return value of decoding function
    //P2: Position of upload packet for which reply decoding failed
    static const Event DEC_ERROR = MAKE_EVENT(9, severity::LOW);


    StrImageLoader(object_id_t objectId);
    virtual ~StrImageLoader();

    ReturnValue_t initialize() override;
    ReturnValue_t performOperation(uint8_t operationCode = 0) override;

    void setComIF(DeviceCommunicationIF* communicationInterface_);
    void setComCookie(CookieIF* comCookie_);

    /**
     * @brief   Starts sequence to upload image to star tracker
     *
     * @param image Name including absolute path if to image to upload. Must be previously
     *              transferred to the OBC with the CFDP protocoll.
     */
    ReturnValue_t startImageUpload(std::string image);

    /**
     * @brief   Calling this function initiates the download of an image from the star tracker.
     */
    ReturnValue_t startImageDownload();

private:

    static const uint8_t INTERFACE_ID = CLASS_ID::STR_IMG_LOADER;

    //! [EXPORT] : [COMMENT] SD card specified in path string not mounted
    static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA0);
    //! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
    static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA1);

    // Size of one image part which can be sent per action request
    static const size_t SIZE_IMAGE_PART = 1024;

    static const uint32_t MAX_POLLS = 10000;

    enum class InternalState {
        IDLE,
        UPLOAD_IMAGE,
        DOWNLOAD_IMAGE
    };

    InternalState internalState = InternalState::IDLE;

    ArcsecDatalinkLayer datalinkLayer;

    BinarySemaphore semaphore;

    // Absolute path and name to image to upload
    std::string uploadImage;

    SdCardManager* sdcMan = nullptr;

    uint8_t commandBuffer[StarTracker::MAX_FRAME_SIZE];

    /**
     * Communication object responsible for low level access of star tracker
     * Must be set by star tracker handler
     */
    DeviceCommunicationIF * communicationInterface = nullptr;
    // Communication cookie. Must be set by the star tracker handler
    CookieIF* comCookie = nullptr;

    // Queue id of raw data receiver
    MessageQueueId_t rawDataReceiver = MessageQueueIF::NO_QUEUE;

    /**
     * @brief   Performs image uploading
     */
    ReturnValue_t performImageUpload();

    /**
     * @brief   Sends a upload image packet and receives the action reply.
     *
     * @param uploadReq Pointer to upload request structure to send
     *
     * @return  RETURN_OK if successful, otherwise RETURN_FALIED
     */
    ReturnValue_t uploadSendAndRead(struct UploadActionRequest* uploadReq);

    /**
     * @brief   Checks the reply to an upload action request
     *
     * @return  RETURN_OK if reply confirms success of upload packet transfer, otherwise
     *          REUTRN_FAILED
     */
    ReturnValue_t checkUploadReply();
};

#endif /* BSP_Q7S_DEVICES_STRIMAGELOADER_H_ */