/**
 * @brief 	Helper classes to facilitate safe access to storages which is also
 * 			conforming to RAII principles
 * @details	These helper can be used together with the
 * 			StorageManager classes to manage access to a storage.
 * 			It can take care of thread-safety while also providing
 * 			mechanisms to automatically clear storage data and unlocking the
 * 			pool.
 */
#ifndef TEST_PROTOTYPES_STORAGEACCESSOR_H_
#define TEST_PROTOTYPES_STORAGEACCESSOR_H_

#include <framework/ipc/MutexHelper.h>
#include <framework/storagemanager/StorageManagerIF.h>
#include <memory>


/**
 * @brief   Accessor class which can be returned by pool managers
 *          or passed and set by pool managers to have safe access to the pool
 *          resources.
 */
class ConstStorageAccessor {
	//! StorageManager classes have exclusive access to private variables.
	template<uint8_t NUMBER_OF_POOLS>
	friend class PoolManager;
	template<uint8_t NUMBER_OF_POOLS>
	friend class LocalPool;
public:
	/**
	 * @brief	Simple constructor which takes the store ID of the storage
	 * 			entry to access.
	 * @param storeId
	 */
	ConstStorageAccessor(store_address_t storeId);

	/**
	 * @brief	Move ctor and move assignment allow returning accessors as
	 * 			a returnvalue. They prevent resource being free prematurely.
	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
	 * move-constructors-and-move-assignment-operators-cpp.md
	 * @param
	 * @return
	 */
	ConstStorageAccessor& operator= (ConstStorageAccessor&&);
	ConstStorageAccessor (ConstStorageAccessor&&);

	//! The copy ctor and copy assignemnt should be deleted implicitely
	//! according to https://foonathan.net/2019/02/special-member-functions/
	//! but I still deleted them to make it more explicit. (remember rule of 5).
	ConstStorageAccessor& operator= (ConstStorageAccessor&) = delete;
	ConstStorageAccessor (ConstStorageAccessor&) = delete;

	/**
	 * @brief 	The destructor in default configuration takes care of
	 * 			deleting the accessed pool entry and unlocking the mutex
	 */
	virtual ~ConstStorageAccessor();

	/**
	 * @brief	Returns a pointer to the read-only data
	 * @return
	 */
	const uint8_t* data() const;

	/**
	 * @brief	Copies the read-only data to the supplied pointer
	 * @param pointer
	 */
	void getDataCopy(uint8_t *pointer);

	/**
	 * @brief   Calling this will prevent the Accessor from deleting the data
	 *          when the destructor is called.
	 */
	void release();
	/**
	 * @brief 	Locks the supplied mutex.
	 * @details
	 * The mutex will be unlocked automatically
	 * when this class is destroyed (for example when exiting the scope).
	 * Only one mutex can be locked at a time!
	 * @param mutex
	 * @param mutexTimeout
	 * @return
	 */
	ReturnValue_t lock(MutexIF* mutex,
			uint32_t mutexTimeout = MutexIF::NO_TIMEOUT);
	/**
	 * @brief	Unlocks the mutex (if one has been locked previously).
	 *          Unless this function is called, the mutex is unlocked
	 *          when the class exits the scope.
	 */
	void unlock();


	/**
	 * Get the size of the data
	 * @return
	 */
	size_t size() const;

	/**
	 * Get the storage ID.
	 * @return
	 */
	store_address_t getId() const;

	void print() const;
protected:
	const uint8_t* constDataPointer = nullptr;
	store_address_t storeId;
	size_t size_ = 0;
	//! Managing pool, has to assign itself.
	StorageManagerIF* store = nullptr;
	//! Unique pointer to the mutex lock instance. Is initialized by
	//! the pool manager.
	std::unique_ptr<MutexHelper> mutexLock = nullptr;
	bool deleteData = true;

	enum class AccessState {
		UNINIT,
		READ
	};
	//! Internal state for safety reasons.
	AccessState internalState = AccessState::UNINIT;
	/**
	 * Used by the pool manager instances to assign themselves to the
	 * accessor. This is necessary to delete the data when the acessor
	 * exits the scope ! The internal state will be considered read
	 * when this function is called, so take care all data is set properly as
	 * well.
	 * @param
	 */
	void assignStore(StorageManagerIF*);

};


/**
 * @brief   Child class for modifyable data. Also has a normal pointer member.
 */
class StorageAccessor: public ConstStorageAccessor {
	//! StorageManager classes have exclusive access to private variables.
	template<uint8_t NUMBER_OF_POOLS>
	friend class PoolManager;
	template<uint8_t NUMBER_OF_POOLS>
	friend class LocalPool;
public:
	StorageAccessor(store_address_t storeId);
	/**
	 * @brief	Move ctor and move assignment allow returning accessors as
	 * 			a returnvalue. They prevent resource being free prematurely.
	 * Refer to: https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/
	 * 			 move-constructors-and-move-assignment-operators-cpp.md
	 * @param
	 * @return
	 */
	StorageAccessor& operator= (StorageAccessor&&);
	StorageAccessor (StorageAccessor&&);

	ReturnValue_t write(uint8_t *data, size_t size,
		uint16_t offset);
	uint8_t* data();

private:
	//! Non-const pointer for modifyable data.
	uint8_t* dataPointer = nullptr;
	//! For modifyable data, the const pointer is assigned to the normal
	//! pointer by the pool manager so both access functions can be used safely
	void assignConstPointer();
};

#endif /* TEST_PROTOTYPES_STORAGEACCESSOR_H_ */