#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_

#include "fsfw/container/DynamicFIFO.h"
#include "fsfw/returnvalues/FwClassIds.h"

#include <utility>
#include <cstdint>

/**
 * @brief	This small helper class scans a given buffer for PUS packets.
 * 			Can be used if PUS packets are serialized in a tightly packed frame.
 * @details
 * The parser uses the length field field of the space packets to find
 * the respective space packet sizes.
 *
 * The parser parses a buffer by taking a pointer and the maximum size to scan.
 * If space packets are found, they are stored in a FIFO which stores pairs
 * consisting of the index in the buffer and the respective packet sizes.
 *
 * If the parser detects split packets (which means that the size of the
 * next packet is larger than the remaining size to scan), it can either
 * store that split packet or throw away the packet.
 * @author   R. Mueller
 */
class SpacePacketParser {
public:
	//! The first entry is the index inside the buffer while the second index
	//! is the size of the PUS packet starting at that index.
	using IndexSizePair = std::pair<size_t, size_t>;

	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PUS_PARSER;
	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);

	/**
	 * @brief   Parser constructor.
	 * @param maxExpectedPusPackets
	 * Maximum expected number of PUS packets. A good estimate is to divide
	 * the frame size by the minimum size of a PUS packet (12 bytes)
	 * @param storeSplitPackets
	 * Specifies whether split packets are also stored inside the FIFO,
	 * with the size being the remaining frame size.
	 */
	SpacePacketParser(std::vector<uint16_t> validPacketIds);

	/**
	 * Parse a given frame for PUS packets
	 * @param frame
	 * @param frameSize
	 * @param foundPackets The number of found packets will be stored here
	 * @return
	 *  -@c NO_PACKET_FOUND if no packet was found
	 *  -@c SPLIT_PACKET if splitting is enabled and a split packet was found
	 *  -@c RETURN_OK if a packet was found. The index and sizes are stored in the internal FIFO
	 */
	ReturnValue_t parseSpacePackets(const uint8_t* buffer, const size_t maxSize,
	        size_t& startIndex, size_t& foundSize);

	ReturnValue_t parseSpacePackets(const uint8_t **buffer, const size_t maxSize,
	        size_t& startIndex, size_t& foundSize, size_t& readLen);
	/**
	 * Accessor function to get a reference to the internal FIFO which
	 * stores pairs of index and packet sizes. This FIFO is filled
	 * by the #parsePusPackets function.
	 * @return
	 */
	//DynamicFIFO<IndexSizePair>& fifo();

	/**
	 * Retrieve the next index and packet size pair from the FIFO.
	 * This also removes it from the FIFO. Please note that if the FIFO
	 * is empty, an empty pair will be returned.
	 * @return
	 */
	//IndexSizePair getNextFifoPair();

private:
	/**
	 * A FIFO is used to store information about multiple PUS packets
	 * inside the receive buffer. The maximum number of entries is defined
	 * by the first constructor argument.
	 */
	//DynamicFIFO<IndexSizePair> indexSizePairFIFO;

	std::vector<uint16_t> validPacketIds;

	//bool storeSplitPackets = false;

//	ReturnValue_t readMultiplePackets(const uint8_t *frame, size_t frameSize,
//			size_t startIndex, uint32_t& foundPackets);
//	ReturnValue_t readNextPacket(const uint8_t *frame,
//			size_t frameSize, size_t& startIndex, uint32_t& foundPackets);
};

#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */