/**
  * @RDE_HEADER@
  * Routing Test - main object
  * $Id$
  * $HeadURL$
  * $Author$
  */


#include "session_handler.h"
#include <LtsPluginManager/lts_plugin_loader.h>
#include <DDS/Generic/topic_type_plugin.h>
#include <QVector>

namespace RoutingService
{

SessionHandler::SessionHandler(IDL::PartitionType partitionType,
                               const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnectorSv,
                               const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnectorWs)
  : m_partitionType(partitionType)
  , m_ddsConnectorSv(ddsConnectorSv)
  , m_ddsConnectorWs(ddsConnectorWs)
  , m_logger(getLogger("SessionHandler"))
{
}

SessionHandler::~SessionHandler()
{
  shutdown();
  LtsPluginManager::LtsPluginLoader::getInstance()->unloadAllPlugins();
  m_topicTypePlugins.clear();
}

bool SessionHandler::init()
{
  return loadPlugins();
}

void SessionHandler::shutdown()
{
  qDeleteAll(m_sessionMap);
  m_sessionMap.clear();
  m_ddsConnectorWs = nullptr;
  m_ddsConnectorSv = nullptr;
}

void SessionHandler::onCreateSession(const QString &partitionNameSv, const QString &partitionNameWs)
{
  const QString partitionName = partitionNameSv + QLatin1Char('-') + partitionNameWs;
  if (m_sessionMap.contains(partitionName))
  {
    WARNING_LOG(m_logger) << "Got create session for " << partitionName << ", but is already created";
    return;
  }
  Session *session = new Session(partitionNameSv, partitionNameWs);
  if (!session->init(m_ddsConnectorSv->getDomainParticipant(),
                     m_ddsConnectorWs->getDomainParticipant(),
                     topicsToRouteToWs(),
                     topicsToRouteToSv()))
  {
    WARNING_LOG(m_logger) << "Can not initialize session for " << partitionName << ", routing will not work...!";
    delete session;
    return;
  }
  m_sessionMap[partitionName] = session;
  INFO_LOG(m_logger) << "Successfully created session for " << partitionName;
}

void SessionHandler::onDestroySession(const QString &partitionNameSv, const QString &partitionNameWs)
{
  const QString partitionName = partitionNameSv + QLatin1Char('-') + partitionNameWs;
  auto it = m_sessionMap.find(partitionName);
  if (it == m_sessionMap.end())
  {
    WARNING_LOG(m_logger) << "Got destroy session for " << partitionName << ", but is not created (already destroyed?)";
    return;
  }
  Session *session = it.value();
  session->shutdown();
  delete session;
  m_sessionMap.erase(it);
  INFO_LOG(m_logger) << "Successfully destroyed session for " << partitionName;
}

bool SessionHandler::loadPlugins()
{
  auto cb = [this](const LtsPluginManager::PluginInstance & pi)
  {
    return loadPlugin(pi);
  };
  return LtsPluginManager::LtsPluginLoader::getInstance()->loadPlugins(LtsPluginManager::PluginType::TOPIC_TYPE, cb);
}

bool SessionHandler::loadPlugin(const LtsPluginManager::PluginInstance &pi)
{
  DDSGeneric::TopicTypePlugin *typePlugin = dynamic_cast<DDSGeneric::TopicTypePlugin *>(pi.plugin);
  if (!typePlugin)
    return false;

  // We don't load some plugins which are global since they are not needed since r49652ff
  static const QVector<QString> skipList({QStringLiteral("ASM"),
                                          QStringLiteral("AVM"),
                                          QStringLiteral("FLM"),
                                          QStringLiteral("ISM"),
                                          QStringLiteral("MSG"),
                                          QStringLiteral("OPM"),
                                          QStringLiteral("PDM"),
                                         });
  if (skipList.contains(pi.pluginName.toUpper()))
      DEBUG_LOG(m_logger) << "Skipping plugin " << pi.pluginName.toUpper() << " - is global";

  m_topicTypePlugins.push_back(typePlugin);

  return true;
}

std::vector<TopicDispatcherInterface *> SessionHandler::topicsToRouteToWs() const
{
  std::vector<TopicDispatcherInterface *> ret;
  for (const auto typePlugin : m_topicTypePlugins)
  {
    const auto topicsToRouteToWs = typePlugin->topicsToRouteToWs(m_partitionType);
    ret.insert(ret.end(), topicsToRouteToWs.begin(), topicsToRouteToWs.end());
  }
  return ret;
}

std::vector<TopicDispatcherInterface *> SessionHandler::topicsToRouteToSv() const
{
  std::vector<TopicDispatcherInterface *> ret;
  for (const auto typePlugin : m_topicTypePlugins)
  {
    const auto topicsToRouteToSv = typePlugin->topicsToRouteToSv(m_partitionType);
    ret.insert(ret.end(), topicsToRouteToSv.begin(), topicsToRouteToSv.end());
  }
  return ret;
}

} // namespace RoutingService