#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_
#define MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_

#include "fsfw/serialize/SerialBufferAdapter.h"
#include "fsfw/serialize/SerializeElement.h"
#include "fsfw/serialize/SerialLinkedListAdapter.h"

namespace GOMSPACE{
	static const uint16_t IGNORE_CHECKSUM = 0x0bb0;
	/* CSP port to ping gomspace devices. */
	static const uint8_t PING_PORT = 1;
	static const uint8_t REBOOT_PORT = 4;
	/* CSP port of gomspace devices to request or set parameters */
	static const uint8_t PARAM_PORT = 7;
}

/**
 * @brief	A serial linked list adapter implementation to generate ping
 * 			messages for gomspace devices.
 *
 * @details	A ping request simply sends back the received data provided by the
 * 			data buffer. cspPort and querySize are only informations required
 * 			by the CspComI and other than the data array not physically
 * 			transmitted to the target device.
 */
class CspPing : public SerialLinkedListAdapter<SerializeIF> {
public:
	/**
	 * @brief	Constructor
	 *
	 * @param querySize_	The size of bytes replied by the ping request.
	 * 						Amounts to the number of bytes send.
	 * @param parameters_	Pointer to data which should be sent to the device.
	 * 						All data will be sent back by the ping target.
	 * @param paramterCount_	Number of bytes to send with the ping request.
	 */
	CspPing(uint16_t querySize_, const uint8_t* parameters_,
			uint8_t parameterCount_) :
			querySize(querySize_), data(parameters_, parameterCount_) {
		setLinks();
	}

private:
	CspPing(const CspPing &command);
	void setLinks() {
		setStart(&cspPort);
		cspPort.setNext(&querySize);
		querySize.setNext(&data);
	}
	SerializeElement<uint8_t> cspPort = GOMSPACE::PING_PORT;
	SerializeElement<uint16_t> querySize;
	SerializeElement<SerialBufferAdapter<uint8_t>> data;
};


/**
 * @brief	A serial linked list adapter implementation of the gs_rparam_query_t
 * 			struct defined in rparam.h. Can be used to build the message to set
 * 			a parameter in gomspace devices.
 *
 * @note	cspPort and querySize will not be sent with the CSP packet to the
 * 			gomspace device but are required for the CspComIF to get the port
 * 			and the size to query.
 */
class CspSetParamCommand : public SerialLinkedListAdapter<SerializeIF> {
public:
	CspSetParamCommand(uint8_t action_, uint8_t tableId_,
			uint16_t addresslength_, uint16_t checksum_, uint16_t seq_,
			uint16_t total_, uint16_t addr_, const uint8_t* parameters_,
			uint8_t parameterCount_) :
			action(action_), tableId(tableId_), addresslength(addresslength_), checksum(
					checksum_), seq(seq_), total(total_), addr(addr_), parameters(
					parameters_, parameterCount_) {
		setLinks();
	}

private:
	CspSetParamCommand(const CspSetParamCommand &command);
	void setLinks() {
		setStart(&cspPort);
		cspPort.setNext(&querySize);
		querySize.setNext(&action);
		action.setNext(&tableId);
		tableId.setNext(&addresslength);
		addresslength.setNext(&checksum);
		checksum.setNext(&seq);
		seq.setNext(&addr);
		addr.setNext(&parameters);
	}
	SerializeElement<uint8_t> cspPort = GOMSPACE::PARAM_PORT;
	/* Only parameters are set. No data will be queried with this command */
	SerializeElement<uint16_t> querySize = 0;
	SerializeElement<uint8_t> action;
	SerializeElement<uint8_t> tableId;
	SerializeElement<uint16_t> addresslength;
	SerializeElement<uint16_t> checksum;
	SerializeElement<uint16_t> seq;
	SerializeElement<uint16_t> total;
	SerializeElement<uint16_t> addr;
	SerializeElement<SerialBufferAdapter<uint8_t>> parameters;
};


/**
 * @brief	This class can be used to generate a get param command for the
 * 			gomspace devices which will be sent to the device communication
 * 			interface object.
 *
 * @note 	cspPort and querySize only serve as information for the CspComIF
 * 			and will not be transmitted physically to the target device.
 */
class CspGetParamCommand : public SerialLinkedListAdapter<SerializeIF> {
public:

	CspGetParamCommand(uint16_t querySize_, uint8_t action_, uint8_t tableId_,
			uint16_t addresslength_, uint16_t checksum_, uint16_t seq_,
			uint16_t total_, uint16_t addr_) :
			querySize(querySize_), action(action_), tableId(tableId_), addresslength(
					addresslength_), checksum(checksum_), seq(seq_), total(
					total_), addr(addr_) {
		fixedValuesInit();
		setLinks();
	}

private:
	CspGetParamCommand(const CspGetParamCommand &command);
	void setLinks() {
		setStart(&cspPort);
		cspPort.setNext(&querySize);
		querySize.setNext(&action);
		action.setNext(&tableId);
		tableId.setNext(&addresslength);
		addresslength.setNext(&checksum);
		checksum.setNext(&seq);
		seq.setNext(&total);
		total.setNext(&addr);
	}
	void fixedValuesInit(){
		cspPort.entry = GOMSPACE::PARAM_PORT;
	}
	SerializeElement<uint8_t> cspPort;
	SerializeElement<uint16_t> querySize; // size of bytes to query
	/* Following information will also be physically transmitted to the target
	 * device*/
	SerializeElement<uint8_t> action;
	SerializeElement<uint8_t> tableId;
	SerializeElement<uint16_t> addresslength; // size of address
	SerializeElement<uint16_t> checksum;
	SerializeElement<uint16_t> seq;
	SerializeElement<uint16_t> total;
	SerializeElement<uint16_t> addr;
};


/**
 * @brief	This class can be used to deserialize replies from gomspace devices
 * 			and extract the relevant data.
 */
class CspGetParamReply : public SerialLinkedListAdapter<SerializeIF> {
public:
	/* The size of the header of a gomspace CSP packet. */
	static const uint8_t GS_HDR_LENGTH = 12;
	/**
	 * @brief	Constructor
	 *
	 * @param payloadBuffer	Pointer to a buffer to store the payload data of
	 * 						the CSP packet.
	 * @param payloadBufferSz	The size of the payload buffer where the payload
	 * 							data will be stored.
	 */
	CspGetParamReply(uint8_t* payloadBuffer_, uint8_t payloadBufferSz_) :
			payload(payloadBuffer_, payloadBufferSz_) {
		setLinks();
	}

	uint8_t getAction(){
		return action;
	}

	uint8_t getTableId(){
		return tableId;
	}

	uint16_t getLength(){
		return length;
	}

	uint16_t getAddress(){
		return addr;
	}

private:
	CspGetParamReply(const CspGetParamReply &reply);
	void setLinks() {
		setStart(&action);
		action.setNext(&tableId);
		seq.setNext(&addr);
		addr.setNext(&payload);
	}

	SerializeElement<uint8_t> action;
	SerializeElement<uint8_t> tableId;
	SerializeElement<uint16_t> length; //length of payload data
	SerializeElement<uint16_t> checksum;
	SerializeElement<uint16_t> seq;
	SerializeElement<uint16_t> total;
	SerializeElement<uint16_t> addr;
	SerializeElement<SerialBufferAdapter<uint8_t>> payload;
};


/**
 * @brief	This class generates telemetry packets containing data from
 * 			CSP get-parameter-replies.
 */
class ParamReply : public SerialLinkedListAdapter<SerializeIF> {
public:
	/**
	 * @brief	Constructor
	 *
	 * @param payloadBuffer	Pointer to a buffer to store the payload data of
	 * 						the CSP packet.
	 * @param payloadBufferSz	The size of the payload buffer where the payload
	 * 							data will be stored.
	 */
	ParamReply(uint8_t action_, uint8_t tableId_, uint16_t addr_,
			uint16_t length_, uint8_t* payloadBuffer_, uint8_t payloadBufferSz_) :
			payload(payloadBuffer_, payloadBufferSz_) {
		setLinks();
	}

private:
	ParamReply(const CspGetParamReply &reply);
	void setLinks() {
		setStart(&action);
		action.setNext(&tableId);
		tableId.setNext(&addr);
		addr.setNext(&length);
		length.setNext(&payload);
	}
	SerializeElement<uint8_t> action;
	SerializeElement<uint8_t> tableId;
	SerializeElement<uint16_t> addr;
	SerializeElement<uint16_t> length;
	SerializeElement<SerialBufferAdapter<uint8_t>> payload;
};


/**
 * @brief	This class helps to unpack information from an action messages
 * 			to set a parameter in gomspace devices. The action message can be
 * 			for example received from the PUS Service 8.
 */
class SetParamMessageUnpacker: public SerialLinkedListAdapter<SerializeIF> {
public:

	SetParamMessageUnpacker(const uint8_t* commandData, size_t commandDataLen) {
		SerializeAdapter::deSerialize(&tableId, &commandData, &commandDataLen,
		        SerializeIF::Endianness::BIG);
		SerializeAdapter::deSerialize(&address, &commandData, &commandDataLen,
		        SerializeIF::Endianness::BIG);
		parameterBuffer = commandData;
		parameterCount = commandDataLen;
	}

	uint8_t getTableId() const {
		return tableId;
	}

	uint16_t getAddress() const {
		return address;
	}

	const uint8_t*  getParameters() {
		return parameterBuffer;
	}

	uint8_t getParameterCount(){
		return parameterCount;
	}


private:
	SetParamMessageUnpacker(const SetParamMessageUnpacker &message);
	uint8_t tableId;
	uint16_t address;
	/* Parameter buffer holds the values of the parameters to set while the
	 * address points to the location of a parameter. */
	const uint8_t * parameterBuffer;
	uint8_t parameterCount;
};


/**
 * @brief	This class helps to unpack information from an action message
 * 			to get a parameter from gomspace devices. The action message can be
 * 			for example received from the PUS Service 8.
 */
class GetParamMessageUnpacker: public SerialLinkedListAdapter<SerializeIF> {
public:

	GetParamMessageUnpacker(const uint8_t* commandData, size_t commandDataLen) {
		SerializeAdapter::deSerialize(&tableId, &commandData, &commandDataLen,
		        SerializeIF::Endianness::BIG);
		SerializeAdapter::deSerialize(&address, &commandData, &commandDataLen,
		        SerializeIF::Endianness::BIG);
		SerializeAdapter::deSerialize(&querySize, &commandData, &commandDataLen,
		        SerializeIF::Endianness::BIG);
	}

	uint8_t getTableId() const {
		return tableId;
	}

	uint16_t getAddress() const {
		return address;
	}

	uint8_t getQuerySize(){
		return querySize;
	}


private:
	GetParamMessageUnpacker(const GetParamMessageUnpacker &message);
	uint8_t tableId;
	uint16_t address; //The memory address offset within the table
	uint8_t querySize; //defines number of bytes to query
};


#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */