/*
 * Publisher.h
 *
 *  Created on: Nov 16, 2015
 *      Author: sune
 */

#ifndef PUBLISHER_HPP_
#define PUBLISHER_HPP_

#include <string>
#include <exception>

#include "ndds/ndds_cpp.h"

#include "ParticipantWrapper.h"
#include "Exception.hpp"

namespace cobraid {

template<typename T>
class Publisher {
public:
	Publisher(ParticipantWrapper& participant, std::string topicName);
	virtual ~Publisher();
	void publish(T& message);

private:
	void createPublisher();
	void createTopic(const char* topicName);
	void createDataWriter();
	void publisher_shutdown();

	DDSDomainParticipant* participant;
	DDSPublisher* publisher;
	DDSTopic* topic;
	typename T::DataWriter* dataWriter;
	T* instance;
};

} /* namespace cobraid */

//Implementation

template<typename T>
inline cobraid::Publisher<T>::Publisher(ParticipantWrapper& participant,
		std::string topicName) {
	this->participant = participant.getDomainParticipant();
	createPublisher();
	createTopic(topicName.c_str());
	createDataWriter();

	instance = T::TypeSupport::create_data();

	if (instance == NULL) {
		publisher_shutdown();
		throw cobraid::exceptions::NullReferenceError("Failed to create data");
	}
}

template<typename T>
inline cobraid::Publisher<T>::~Publisher() {
	publisher_shutdown();
	T::TypeSupport::delete_data(instance);
}

template<typename T>
inline void cobraid::Publisher<T>::publish(T& message) {
	T::TypeSupport::copy_data(instance, &message);

	dataWriter->write(*instance, DDS_HANDLE_NIL);
}

template<typename T>
inline void cobraid::Publisher<T>::createPublisher() {
	publisher = participant->create_publisher(DDS_PUBLISHER_QOS_DEFAULT, NULL,
	DDS_STATUS_MASK_NONE);

	if (publisher == NULL) {
		publisher_shutdown();
		throw cobraid::exceptions::NullReferenceError("Failed to create publisher");
	}
}

template<typename T>
inline void cobraid::Publisher<T>::createTopic(const char* topicName) {
	const char* TTypeName = T::TypeSupport::get_type_name();
	T::TypeSupport::register_type(participant, TTypeName);

	topic = participant->create_topic(topicName, TTypeName,
			DDS_TOPIC_QOS_DEFAULT, NULL, DDS_STATUS_MASK_ALL);

	if (topic == NULL) {
		publisher_shutdown();
		throw cobraid::exceptions::NullReferenceError("Failed to create topic");
	}
}

template<typename T>
inline void cobraid::Publisher<T>::createDataWriter() {

	DDS_DataWriterQos qos = DDS_DATAWRITER_QOS_DEFAULT;
	qos.publish_mode.kind = DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS;
	qos.publish_mode.flow_controller_name = DDS_String_dup("MyFlowController");
	qos.reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;

	DDSDataWriter* writer = participant->create_datawriter(topic,
			qos,
			NULL,
			DDS_STATUS_MASK_NONE);
	if (writer == NULL) {
		publisher_shutdown();
		throw cobraid::exceptions::NullReferenceError("Failed to create DataWriter");
	}

	dataWriter = T::DataWriter::narrow(writer);

	if (dataWriter == NULL) {
		publisher_shutdown();
		throw std::bad_cast();
	}
}

template<typename T>
inline void cobraid::Publisher<T>::publisher_shutdown() {
	participant->delete_datawriter(dataWriter);

	if (publisher != NULL) {
		participant->delete_publisher(publisher);
	}
}

#endif /* PUBLISHER_HPP_ */