/**
  * DdsHandler for DDS
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2015-09-02
  */
#pragma once

#include "logger.h"
#include <dds/domain/DomainParticipant.hpp>
#include <Core/topic_lock_master.h>
#include <QStringList>

#include <DDS/DDSConnector/dds_connector.h>
#include <Core/core_dts_types.h>

#include <AudioVideoManagement/avm_dts.h>
#include <AudioVideoManagement/avm_fts.h>

#include <boost/optional.hpp>

namespace Core
{
class Pacemaker;
}

namespace DDSConnector
{
class DdsConnector;
}

namespace ExerciseManagement { namespace Interface
{
class Dtc;
}}

namespace InfrastructureManagement { namespace Interface
{
class Dtc;
}}

namespace AssetManagement { namespace Interface
{
class Dtc;
}}


namespace AudioVideoManagement
{
template<class T>
boost::optional<T> toBoost(const dds::core::optional<T> &optionalValue)
{
  if (!optionalValue.is_set())
    return boost::none;
  return optionalValue.get();
}

class DdsHandler final
{
public:
  explicit DdsHandler(int domainId);
  ~DdsHandler() = default;

  bool init(const QStringList &qosFileList = QStringList());

  /**
   * Must be called *after* init and *after* all DTC-consuming instances
   * have been setup. This is to avoid data races that otherwise could arise
   * when
   * - connecting to the onFooChanged() signal and
   * - shortly after that calling foo() to get all received entities so far.
   */
  bool enableDtcClients();

  dds::domain::DomainParticipant   domainParticipant() const;

  std::shared_ptr<Core::Pacemaker>          pacemaker()       const { return m_pacemaker; }
  std::shared_ptr<Core::TopicLockMaster>    topicLockMaster() const { return m_topicLockMaster; }

  Interface::Dts                           *dts() const       { return m_dts.get(); }
  Interface::Fts                           *fts() const       { return m_fts.get(); }

  ExerciseManagement::Interface::Dtc       *exmDtc() const    { return m_exmDtc.get(); }
  InfrastructureManagement::Interface::Dtc *ismDtc() const    { return m_ismDtc.get(); }
  AssetManagement::Interface::Dtc          *asmDtc() const    { return m_asmDtc.get(); }
  std::shared_ptr<DDSConnector::DdsConnector> ddsConnector() const { return m_ddsConnector; }

private:
  std::shared_ptr<DDSConnector::DdsConnector>               m_ddsConnector;
  std::shared_ptr<Core::Pacemaker>                          m_pacemaker;
  std::shared_ptr<Core::TopicLockMaster>                    m_topicLockMaster;
  std::shared_ptr<Interface::Dts>                           m_dts;
  std::shared_ptr<ExerciseManagement::Interface::Dtc>       m_exmDtc;
  std::shared_ptr<InfrastructureManagement::Interface::Dtc> m_ismDtc;
  std::shared_ptr<AssetManagement::Interface::Dtc>          m_asmDtc;
  std::shared_ptr<Interface::Fts>                           m_fts;

  NGL::INGLLogger          &m_logger;
};

}