#include "DDS_DefaultQos.h"

#include <QUrl>

#include <ngltools/ngltools_filesystem.h>
#include <NGLLogger/NGLLoggerBootstrap.h>

namespace DDS
{
namespace QosProfile
{

static void printPolicyMap(const std::map<std::string, std::string> &policyMap, NGL::INGLLogger &logger);

QString defaultProfileXml()
{
  return NGL::findFile(NGL::FileType::ConfigFile, QStringLiteral("default_profile.xml"));
}

bool setDefault(const QStringList &qosFileList)
{
  NGL::INGLLogger &logger = NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("DDS.DefaultQos");
  const QStringList qosStr =  qosFileList.isEmpty() ?
        QStringList(defaultProfileXml()) :
        qosFileList;

  if (logger.isDebugEnabled())
  {
    DEBUG_LOG(logger) << "findFile - m_qosFileList = ";
    for (const QString &file : qosStr)
      DEBUG_LOG(logger) <<  "# profile: " << file;
  }

  try
  {
    
    dds::core::StringSeq urls;
    urls.reserve(qosStr.size());
    for (const QString &file : qosStr)
    {
      const QString url = QUrl::fromLocalFile(file).toString();
      DEBUG_LOG(logger) << "Using qosFile: " << file << " - " << url;
      urls.emplace_back(url.toStdString());
    }
    dds::core::QosProvider defaultProvider = dds::core::QosProvider::Default();
    rti::core::QosProviderParams qosProviderParams = defaultProvider->default_provider_params();
    qosProviderParams.url_profile(urls);
    defaultProvider->default_provider_params(qosProviderParams);

    print(defaultProvider, logger);

  }
  catch (const dds::core::Exception &ex)
  {
    ERROR_LOG(logger) << ex.what();
    return false;
  }
  return true;
}

static QString fixupSchemeName(const QUrl &url)
{
  
  QString str = url.toString();
  str = str.replace(QLatin1String("tcpv4lan"), QLatin1String("tcpv4_lan"));
  return QStringLiteral("0@") + str;
}

dds::domain::qos::DomainParticipantQos domainParticipantShmUdp()
{
  return domainParticipantDefault(ConnectionType::ShmUdp, QUrl());
}

dds::domain::qos::DomainParticipantQos domainParticipantShmUdpLocalhost()
{
  return domainParticipantDefault(ConnectionType::ShmUdpLocalhost, QUrl());
}

dds::domain::qos::DomainParticipantQos domainParticipantShm()
{
  return domainParticipantDefault(ConnectionType::Shm, QUrl());
}

dds::domain::qos::DomainParticipantQos domainParticipantShmTcp(const QUrl &tcpConnectionUrl)
{
  return domainParticipantDefault(ConnectionType::Tcp, tcpConnectionUrl);
}

dds::domain::qos::DomainParticipantQos domainParticipantDefault(ConnectionType type, const QUrl &tcpConnectionUrl)
{
  dds::core::QosProvider defaultProvider = dds::core::QosProvider::Default();
  dds::domain::qos::DomainParticipantQos dpQos = defaultProvider.participant_qos();
  switch (type)
  {
  case ConnectionType::Tcp:
  {
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.Tcp");
    if (tcpConnectionUrl.scheme() == QLatin1String("tcpv4lan"))
    {
      
      rti::core::policy::Discovery discovery;
      dpQos >> discovery;
      const dds::core::StringSeq seq({fixupSchemeName(tcpConnectionUrl).toStdString()});
      discovery.initial_peers(seq);
      dpQos << discovery;
    }
    else
    {
      
      rti::core::policy::Property props;
      dpQos >> props;
      props.set({"dds.transport.TCPv4.tcp1.server_bind_port", std::to_string(tcpConnectionUrl.port(7400))});
      dpQos << props;
    }
    break;
  }
  case ConnectionType::Shm:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.Shm");
    break;
  case ConnectionType::ShmUdp:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.ShmUdp");
    break;
  case ConnectionType::ShmUdpLocalhost:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.ShmUdpLocalhost");
    break;
  case ConnectionType::Server:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.Server");
    break;
  case ConnectionType::Client:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.Client");
    break;
  case ConnectionType::Tablet:
    dpQos = defaultProvider.participant_qos("LtsProfiles::DomainParticipant.Tablet");
    break;
  }
  return dpQos;
}

dds::pub::qos::DataWriterQos dataWriterDefault(TopicType type)
{
  dds::core::QosProvider defaultProvider = dds::core::QosProvider::Default();
  dds::pub::qos::DataWriterQos dwQos = defaultProvider.datawriter_qos();
  switch (type)
  {
  case TopicType::DataTopic:
    break;  
  case TopicType::FunctionTopic:
    dwQos = defaultProvider.datawriter_qos("LtsProfiles::DataReaderWriter.FT");
    break;
  }
  return dwQos;
}

dds::sub::qos::DataReaderQos dataReaderDefault(TopicType type)
{
  dds::core::QosProvider defaultProvider = dds::core::QosProvider::Default();
  dds::sub::qos::DataReaderQos drQos = defaultProvider.datareader_qos();
  switch (type)
  {
  case TopicType::DataTopic:
    break;  
  case TopicType::FunctionTopic:
    drQos = defaultProvider.datareader_qos("LtsProfiles::DataReaderWriter.FT");
    break;
  }
  return drQos;
}

dds::sub::qos::DataReaderQos dataReaderDefault( ConnectionType conType)
{
  dds::core::QosProvider defaultProvider = dds::core::QosProvider::Default();
  dds::sub::qos::DataReaderQos drQos = defaultProvider.datareader_qos();
   switch (conType)
    {
    case ConnectionType::Shm:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.Shm");
      break;
    case ConnectionType::ShmUdp:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.ShmUdp");
      break;
    case ConnectionType::ShmUdpLocalhost:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.ShmUdpLocalhost");
      break;
    case ConnectionType::Server:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.Server");
      break;
    case ConnectionType::Client:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.Client");
      break;
    case ConnectionType::Tablet:
      drQos = defaultProvider.datareader_qos("LtsProfiles::DomainParticipant.Tablet");
      break;
    default:
      break;
    }


  return drQos;
}


void print(dds::core::QosProvider provider, NGL::INGLLogger &logger)
{
  

  
  print(provider.participant_qos(), logger);

  
  print(provider.datawriter_qos(), logger);

  
  print(provider.datareader_qos(), logger);
}

void print(const dds::domain::qos::DomainParticipantQos &qos, NGL::INGLLogger &logger)
{
  
  DEBUG_LOG(logger) << "Qos for DomainParticipant: ";
  printPolicyMap(qos->property.get_all(), logger);
}

void print(const dds::sub::qos::DataReaderQos &readerQos, NGL::INGLLogger &logger)
{
  
  DEBUG_LOG(logger) << "Qos for dataReader: ";
  DEBUG_LOG(logger) << "resourceLimit.max_samples " << readerQos->resource_limits.max_samples();
  printPolicyMap(readerQos->property.get_all(), logger);
}

void print(const dds::pub::qos::DataWriterQos &writerQos, NGL::INGLLogger &logger)
{
  
  DEBUG_LOG(logger) << "Default Qos for dataWriter: ";
  DEBUG_LOG(logger) << "ReliabilityKind: " << writerQos->reliability->kind();
  DEBUG_LOG(logger) << "Publish mode: " << writerQos->publish_mode.kind();
  printPolicyMap(writerQos->property.get_all(), logger);
}

void printPolicyMap(const std::map<std::string, std::string> &policyMap, NGL::INGLLogger &logger)
{
  for (const auto &it : policyMap)
  {
    const std::string &policyName = it.first;
    const std::string &policyContent = it.second;

    DEBUG_LOG(logger) << "policy " << policyName << ":  " << policyContent ;
  }
}
} 
}