/**
  * DbWriter for RecordingManagement
  * $Id$
  * $HeadURL$
  * $Author$
  */
#include "db_writer.h"

#include "db_writer_snapshot.h"
#include "rec_db.h"
#include "logger.h"
#include "settings.h"
#include <DDS/DDSConnector/dds_connector.h>

#include <QThread>

#include <ngldb/dbtransaction.h>

#include <LtsPluginManager/lts_plugin_loader.h>
#include <RecordingManagement/rec_db_impl.h>

namespace RecordingManagement
{

DbWriter::DbWriter(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
  : m_query(nullptr)
  , m_recordTimer(new QTimer(this))
  , m_ddsConnector(ddsConnector)
  , m_dbWriterSnapshot(nullptr)
  , m_dbWriterSnapshotThread(nullptr)
  , m_logger(getLogger("DbWriter"))
{}

DbWriter::~DbWriter()
{
  if (m_dbWriterSnapshotThread)
  {
    m_dbWriterSnapshotThread->quit();
    m_dbWriterSnapshotThread->wait(30 * 1000);
    delete m_dbWriterSnapshotThread;
  }
  LtsPluginManager::LtsPluginLoader::getInstance()->unloadAllPlugins();
  m_plugins.clear();

  delete m_dbWriterSnapshot;
  delete m_recordTimer;
  delete m_query;
}

bool DbWriter::loadPlugin(const LtsPluginManager::PluginInstance &pi)
{
  RecordReplay::RecordReplayPlugin *recPlugin = qobject_cast<RecordReplay::RecordReplayPlugin *>(pi.plugin);
  if (!recPlugin)
  {
    ERROR_LOG(m_logger) << "Cannot load RecordReplayPlugin " << pi.fileName;
    return false;
  }
  INFO_LOG(m_logger) << "Loading RecordReplayPlugin " << pi.fileName;
  // exId == partId da wir hier in IDL::PartitionType::Exercise arbeiten
  if (!recPlugin->initDtc(m_ddsConnector, m_ddsConnector->getPartitionId()))
  {
    ERROR_LOG(m_logger) << "Initialisation for RecordReplayPlugin " << pi.fileName << " failed ";
    return false;
  }

  INFO_LOG(m_logger) << "Loaded record replay plugin " << recPlugin->pluginName();
  m_plugins += recPlugin;

  return true;
}

bool DbWriter::init(const std::shared_ptr<DatabaseInterface> &db)
{
  m_db = db;

  auto cb = [this](const LtsPluginManager::PluginInstance &pi) { return loadPlugin(pi);};
  LtsPluginManager::LtsPluginLoader::getInstance()->loadPlugins(LtsPluginManager::PluginType::SPECIAL,
                                                                cb,
                                                                QStringList(),
                                                                QStringLiteral("recordreplay"));

  // Start recording data
  qint64 msecs = Settings::updateFrequency();
  INFO_LOG(m_logger) << "Updating recording tables every " << msecs << " milliseconds.";
  connect(m_recordTimer, &QTimer::timeout, this, &DbWriter::ddsTopicsToDatabase);
  m_recordTimer->start(msecs);

  delete m_query;
  m_query = new NSqlQuery(m_db->database());

  return initSnapshot();
}

bool DbWriter::initSnapshot()
{
  if (m_dbWriterSnapshotThread)
  {
    m_dbWriterSnapshotThread->quit();
    m_dbWriterSnapshotThread->wait(30 * 1000);
    delete m_dbWriterSnapshotThread;
  }
  delete m_dbWriterSnapshot;

  m_dbWriterSnapshot = new DbWriterSnapshot(m_plugins,
                                            m_ddsConnector->getPartitionId(),
                                            Settings::settings());
  m_dbWriterSnapshotThread = new DbWriterSnapshotThread(m_dbWriterSnapshot, this);
  m_dbWriterSnapshot->moveToThread(m_dbWriterSnapshotThread);
  m_dbWriterSnapshotThread->start();

  return true;
}

void DbWriter::ddsTopicsToDatabase()
{
  DEBUG_LOG(m_logger) << "IN ddsTopicsToDatabase";
  DBTransaction trans(m_db->database());

  QHash<QString, qint64> minRecordSampleTimes;

  // for each plugin
  for (RecordReplay::RecordReplayPlugin *recPlugin : qAsConst(m_plugins))
  {
    if (!recPlugin->ddsTopicsToDatabase(*m_query, minRecordSampleTimes))
    {
      // should never happen but who knows
      ERROR_LOG(m_logger) << "Error recording dds topics - aborting recording data";
      return;
    }
  }
  trans.commit();

  m_dbWriterSnapshot->setMinRecordedSampleTimes(minRecordSampleTimes);
}

}  // RecordingManagement