/**
  * Initialization for MessageDataManagement
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-09-21
  */

#include "initialization.h"
#include "handler_configure_alarms.h"
#include "handler_emergency_call.h"
#include "handler_participant.h"

#include <ngldb/db_service_handler.h>
#include <DDS/DDSConnector/dds_connector.h>

using namespace AlarmManagement;

Initialization::Initialization()
  : m_logger(getLogger("Initialization"))
{
  INFO_LOG(m_logger) << "Initialization::Initialization";
} // end of ctor()
//-----------------------------------------------------------------------------

Initialization::~Initialization()
{
  m_handlerConfigureAlarms = nullptr;
  m_handlerParticipant = nullptr;
  m_handlerEmergencyCall = nullptr;

  m_dbHandler = nullptr;
  m_ddsHandler = nullptr;

  INFO_LOG(m_logger) << "Initialization::~Initialization";
} // end of dtor()
//-----------------------------------------------------------------------------

bool Initialization::initialize(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector, const QSqlDatabase &sqlDb)
{
  INFO_LOG(m_logger) << "Start AlarmManagement Initialization. domainId =" << ddsConnector->getDomainId()
                     << " exerciseId=" << ddsConnector->getPartitionId();

  // initialize DDS
  m_ddsHandler = std::make_shared<DdsHandler>(ddsConnector);
  if (!m_ddsHandler->init())
  {
    ERROR_LOG(m_logger) << "Initialisation DdsHandler failed.";
    return false;
  }
  INFO_LOG(m_logger) << "m_ddsHandler initialized. ";

  // initialize database
  m_dbHandler = std::make_shared<DbHandler>();
  if (!m_dbHandler->init(ddsConnector->getPartitionId(), sqlDb))
  {
    ERROR_LOG(m_logger) << "Initialisation DbHandler failed.";
    return false;
  }
  INFO_LOG(m_logger) << "DbHandler initialized. ";


  // create handlers
  m_handlerParticipant = std::make_shared<HandlerParticipant>(m_ddsHandler);
  m_handlerConfigureAlarms = std::make_shared<HandlerConfigureAlarms>(this);
  m_handlerEmergencyCall = std::make_shared<HandlerEmergencyCall>(m_handlerConfigureAlarms, this);

  DEBUG_LOG(m_logger) << "initialize successfully finished";

  return true;
} // end of init()
//-----------------------------------------------------------------------------

bool Initialization::loadFromDatabase()
{
  // initialize handlers
  if (!m_handlerParticipant || !m_handlerParticipant->init())
  {
    ERROR_LOG(m_logger) << "Can not initialize Participant handler";
    return false;
  }
  if (!m_handlerConfigureAlarms || !m_handlerConfigureAlarms->init())
  {
    ERROR_LOG(m_logger) << "Can not initialize Alarm handler";
    return false;
  }
  if (!m_handlerEmergencyCall || !m_handlerEmergencyCall->init())
  {
    ERROR_LOG(m_logger) << "Can not initialize EmergencyCall handler";
    return false;
  }
  DEBUG_LOG(m_logger) << "loadFromDatabase successfully finished";
  return true;
}

std::shared_ptr<DatabaseInterface> Initialization::db() const
{
  return m_dbHandler->db();
}