/**
 * MainHandler for ParticipantManagement
 * $Id$
 * $HeadURL$
 * $Author$
 * Created by Hannes Baeuerle, SLSE, 19.05.2016
 */

#include "main_handler.h"
#include "TypeHandling/type_handler.h"
#include "UasHandling/mission_plan_handler.h"
#include "UasHandling/uas_handler.h"
#include "WebSocketInterface/websocket_interface_handler.h"
#include "settings.h"

#include <DDS/Core/pacemaker.h>
#include <ngldb/db_service_handler.h>

namespace ParticipantManagement
{

MainHandler::MainHandler() : m_logger(getLogger("MainHandler")) {}

MainHandler::~MainHandler()
{
  m_getParticipants = nullptr;
  m_partyHandler = nullptr;
  m_templateHandler = nullptr;
  m_biteHandler = nullptr;
  m_participantHandler = nullptr;
  m_tabFtc = nullptr;
  m_tabDtc = nullptr;
  m_aesFtc = nullptr;
  m_equipmentEventHandler = nullptr;
  m_typeHandler = nullptr;
  m_websocketHandler = nullptr;
  m_uasHandler = nullptr;
  m_dbHandlerEx0 = nullptr;
  m_dbHandler = nullptr;
  m_ddsHandler = nullptr;
}

bool MainHandler::init(int domainId, int exerciseId)
{
  m_ddsHandler = std::make_shared<DdsHandler>(domainId, exerciseId);
  if (!m_ddsHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init DdsHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DdsHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "DdsHandler initialized";

  m_dbHandler = std::make_shared<DbHandler>();
  if (!m_dbHandler->init(exerciseId, Settings::settings()))
  {
    ERROR_LOG(m_logger) << "Could not init DbHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DbHandler"));
    return false;
  }
  if (exerciseId > 0)
  {
    m_dbHandlerEx0 = std::make_shared<DbHandler>();
    if (!m_dbHandlerEx0->init(0, Settings::settings())) // need a second db connection due to username/password
    {
      ERROR_LOG(m_logger) << "Could not init DbHandler";
      m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DbHandler"));
      return false;
    }
  }
  else
  {
    m_dbHandlerEx0 = m_dbHandler;
  }
  DEBUG_LOG(m_logger) << "DbHandler initialized";

  m_typeHandler = TypeHandling::TypeHandler::createInstance(this, m_logger);
  if (!m_typeHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init TypeHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TypeHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "TypeHandler initialized";

  m_partyHandler = std::make_shared<PartyHandling::PartyHandler>(this);
  if (!m_partyHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init PartyHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init PartyHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "PartyHandler initialized";

  m_tabFtc = TrainingAreaBase::Interface::Ftc::create(m_ddsHandler->dds());
  if (!m_tabFtc->enableAll())
  {
    ERROR_LOG(m_logger) << "Could not init TrainingAreaBase FTC";
    return false;
  }
  DEBUG_LOG(m_logger) << "TrainingAreaBase FTC initialized";

  m_aesFtc = AreaEffectSimulation::Interface::Ftc::create(m_ddsHandler->dds());
  if (!m_aesFtc->enableChargeAdministrationModify())
  {
    ERROR_LOG(m_logger) << "Could not init AreaEffectSimulation FTC";
    return false;
  }

  m_participantHandler = std::make_shared<ParticipantHandling::ParticipantHandlerForExercise>(this);
  if (!m_participantHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init ParticipantHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init ParticipantHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "ParticipantHandler initialized";
  m_ddsHandler->pacemaker()->addPort(m_participantHandler->getWebSocketPort(), Core::PortType::WebSocketPositionServer);

  m_targetInformationHandler = std::make_shared<ParticipantManagement::HandlerTargetInformation>(this);
  if (!m_targetInformationHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init TargetInformationHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TargetInformationHandler"));
    return false;
  }
  NOTICE_LOG(m_logger) << "Enabled TargetInformationHandler for ex " << exerciseId << " do= " << domainId;

  m_biteHandler = std::make_shared<BiteHandling::BiteHandler>(this);
  if (!m_biteHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init BiteHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init BiteHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "BiteHandler initialized";

  // template handler is not needed in exercise dependent PPM
  if (m_ddsHandler->dds()->getPartitionId() <= 0)
  {
    m_templateHandler = std::make_shared<TemplateHandling::TemplateHandler>(this);
    if (!m_templateHandler->init())
    {
      ERROR_LOG(m_logger) << "Could not init TemplateHandler";
      m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TemplateHandler"));
      return false;
    }
    DEBUG_LOG(m_logger) << "TemplateHandler initialized";
  }

  m_getParticipants = std::make_shared<GetParticipants>(this);

  m_tabDtc = TrainingAreaBase::Interface::Dtc::create(m_ddsHandler->dds());
  m_equipmentEventHandler = std::make_shared<EquipmentEventHandling::EquipmentEventHandler>(this);
  if (!m_equipmentEventHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init EquipmentEventHandler";
    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init EquipmentEventHandler"));
    return false;
  }
  DEBUG_LOG(m_logger) << "EquipmentEventHandler initialized";

  // WebSocketServer
  m_websocketHandler = std::make_shared<WebSocketInterface::WebSocketInterfaceHandler>(this);
  if (!m_websocketHandler->init())
  {
    ERROR_LOG(m_logger) << "Could not init WebSocketInterfaceHandler";
    return false;
  }
  DEBUG_LOG(m_logger) << "WebSocketInterfaceHandler initialized";
  m_ddsHandler->pacemaker()->addPort(m_websocketHandler->webSocketPort(), Core::PortType::WebSocketServer);
  m_ddsHandler->pacemaker()->setNewState(Core::RunningState::Running);

  // UasHandler
  if (exerciseId == 0)
  {
    m_uasHandler = std::make_shared<UasHandling::UasHandler>(this);
    if (!m_uasHandler->init())
    {
      ERROR_LOG(m_logger) << "Could not init UasHandler";
      return false;
    }

    DEBUG_LOG(m_logger) << "UasHandler initialized";
  }

  if (exerciseId != 0)
  {
    // init missionPlan
    m_missionPlanHandler = std::make_shared<UasHandling::MissionPlanHandler>(this);
    if (!m_missionPlanHandler->init())
    {
      ERROR_LOG(m_logger) << "Couldn't init MissionPlanHandler";
      return false;
    }
  }
  return true;
}

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

std::shared_ptr<DatabaseInterface> MainHandler::dbEx0() const { return m_dbHandlerEx0->db(); }

qint64 MainHandler::currentTimeMSec() const { return QDateTime::currentMSecsSinceEpoch(); }

} // namespace ParticipantManagement