#pragma once

#include "ddkit/access/DdsWrap.hpp"
#include "ddkit/access/ITopic.hpp"
#include "ddkit/access/Participant.hpp"
#include "ddkit/access/Listener.hpp"

#include "ddkit/utils/Logger.hpp"

namespace ddkit {
namespace access {

template <typename T>
class Reader;
template <typename T>
using ReaderPtr = std::shared_ptr<Reader<T>>;

template <typename T>
class Writer;
template <typename T>
using WriterPtr = std::shared_ptr<Writer<T>>;

template <typename T>
class Topic final : public ITopic {

public:
    dds::domain::DomainParticipant& domainParticipant() { return m_domainParticipant; }
    dds::topic::Topic<T> ddsTopic() { return m_ddsTopic; }
    std::string typeName() { return dds::topic::topic_type_name<T>::value(); }
    std::string topicNameModule() { return m_topicNameModule; }
    std::string topicNameTopic() { return m_topicNameTopic; }

    // ITopic
    std::string topicName() override { return m_topicName; }

    bool hasReader() override {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        return m_reader != nullptr;
    }

    void unloadReader() override {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        DDKIT_LOG_TRACE << typeName();
        if (hasReader()) {
            m_reader->unload();
        }        
    }

    void closeReader() override {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        ddkit::log::debug() << "closeReader (" << typeName() << ")";
        if (hasReader()) {
            m_reader = nullptr;
        }
    }

    bool hasWriter() override {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        return m_writer != nullptr;
    }

    void closeWriter() override {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        ddkit::log::debug() << "closeWriter (" << typeName() << ")";
        if (hasWriter()) {
            m_writer = nullptr;
        }
    }

    Topic(
        dds::domain::DomainParticipant& domainParticipant,
        const std::string& topicName,
        const std::string& topicNameModule,
        const std::string& topicNameTopic,
        dds::topic::qos::TopicQos topicQos) try
        : m_domainParticipant(domainParticipant)
        , m_topicName(topicName)
        , m_topicNameModule(topicNameModule)
        , m_topicNameTopic(topicNameTopic)
        , m_listener(std::make_shared<ListenerTopic<T> >())
        , m_ddsTopic(dds::core::null)
        , m_reader(nullptr)
        , m_writer(nullptr) {

#if defined(DDS_VENDOR_CONNEXT)
        m_ddsTopic = dds::topic::find<dds::topic::Topic<T>>(domainParticipant, topicName);
#endif
        if (m_ddsTopic == dds::core::null) {
            m_ddsTopic = dds::topic::Topic<T>(
                m_domainParticipant,
                m_topicName,
                topicQos,
                m_listener.get(), // has to be set in constructor of topic
                dds::core::status::StatusMask::all()
            );
        }

        ddkit::log::info() << "Created topic: " << m_topicName;

    } catch (dds::core::Exception& e) {
        // happens once in a while on connext (if the same topic is ctored twice in same participant)
        ddkit::log::fatal() << "construction Topic " << topicName << " failed: " << e.what();
        throw std::runtime_error(e.what());
    }

    void setReader(ReaderPtr<T> reader) {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        m_reader = reader;
    }

    std::shared_ptr<Writer<T>> writer() {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        return m_writer;
    }

    void setWriter(WriterPtr<T> writer) {
        std::unique_lock<std::recursive_mutex> lock(m_mutex);
        m_writer = writer;
    }

private:
    bool m_isRead;
    dds::domain::DomainParticipant& m_domainParticipant;
    std::string m_topicName;
    std::string m_topicNameModule;
    std::string m_topicNameTopic;
    std::shared_ptr<ListenerTopic<T>> m_listener;
    dds::topic::Topic<T> m_ddsTopic;

    std::recursive_mutex m_mutex;
    std::shared_ptr<Reader<T>> m_reader;
    std::shared_ptr<Writer<T>> m_writer;

    // no copying
    Topic(Topic const&) = delete;
    Topic(Topic&&) = delete;
    void operator=(Topic const&) = delete;
};

} // namespace access
} // namespace ddkit