/**
  * @RDE_HEADER@
  * Beschreibung des Dialogs
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Mike Wille, SLSE, 2017-11-01
  */

#include "alm_dialog.h"
#include "ui_alm_dialog.h"
#include "alm_history.h"
#include <Plugins/AlarmManagement/Gui/Common/alm_config_alarm_model.h>
#include <Plugins/AlarmManagement/Gui/Common/alm_history_alarm_model.h>

#include <LtsSession/lts_session_data.h>
#include <LtsWidgets/lts_dialog.h>
#include <ProjectDataManagement/pdm_enums.hpp>
#include <LtsUtilsSettings/settings.h>

namespace AlarmManagement
{

AlarmDialog::AlarmDialog(QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_configAlarmModel(nullptr)
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_ui(new Ui::AlarmDialog)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_operatorId(-1)
  , m_logger(getLogger("AlarmDialog"))
{
  AlarmCheckBox alarmCheckBox;
  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();

  const bool enableNuclearContaminations = ps->value(QLatin1String("aes"),
                                        QLatin1String("enableNuclearContaminations")).toBool();
  const bool enableDangerAreas = ps->value(QLatin1String("aes"),
                                        QLatin1String("enableDangerAreas")).toBool();
  const bool enableMineAreas = ps->value(QLatin1String("aes"),
                                        QLatin1String("enableMineAreas")).toBool();

  m_ui->setupUi(this);

  if (!enableNuclearContaminations)
  {
    m_ui->lblNAgentEntry->hide();
    m_ui->cbxNMarker->hide();
    m_ui->cbxNMessage->hide();
  }

  if (!enableDangerAreas)
  {
    m_ui->lblDangerAreaEntry->hide();
    m_ui->cbxDanerAreaMarker->hide();
    m_ui->cbxDangerAreaMessage->hide();
  }
  if (!enableMineAreas)
  {
    m_ui->lblMineAreaEntry->hide();
    m_ui->cbxMineAreaEntryMarker->hide();
    m_ui->cbxMineAreaEntryMessage->hide();
    m_ui->lblMineAreaHit->hide();
    m_ui->cbxMineAreaHitMarker->hide();
    m_ui->cbxMineAreaHitMessage->hide();
  }

  alarmCheckBox.name = QLatin1String("NuclearAgentEntry");
  alarmCheckBox.checkboxMarker = m_ui->cbxNMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxNMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterNuclear;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("DangerAreasEntry");
  alarmCheckBox.checkboxMarker = m_ui->cbxDanerAreaMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxDangerAreaMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterDangerArea;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("MineAreaEntry");
  alarmCheckBox.checkboxMarker = m_ui->cbxMineAreaEntryMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxMineAreaEntryMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterMineArea;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("MineAreaHit");
  alarmCheckBox.checkboxMarker = m_ui->cbxMineAreaHitMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxMineAreaHitMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::HitMine;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("DirectFire");
  alarmCheckBox.checkboxMarker = m_ui->cbxDirectFireMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxDirectFireMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::Hit;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("IndirectFire");
  alarmCheckBox.checkboxMarker = m_ui->cbxIndirectFireMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxIndirectFireMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::HitEffectSimulation;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("CrossLocalBorderlines");
  alarmCheckBox.checkboxMarker = m_ui->cbxLocalBorderMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxLocalBorderMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::CrossLocalBorderline;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("CrossGlobalBorderlines");
  alarmCheckBox.checkboxMarker = m_ui->cbxGlobalBorderMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxGlobalBorderMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::CrossGlobalBorderline;
  m_checkBoxes.append(alarmCheckBox);

  alarmCheckBox.name = QLatin1String("AirSupport");
  alarmCheckBox.checkboxMarker = m_ui->cbxAirSupportMarker;
  alarmCheckBox.checkboxWindow = m_ui->cbxAirSupportMessage;
  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::AirSupport;
  m_checkBoxes.append(alarmCheckBox);

  setOnlineHelpFilename(QLatin1String("Situation-Configure_Global_Alarms"));
}

AlarmDialog::~AlarmDialog()
{
  delete m_ui;
}

bool AlarmDialog::init(const std::shared_ptr<AlarmManagement::Interface::Ftc> &ftc,
                       const std::shared_ptr<AlarmManagement::Interface::Dtc> &dtc,
                       const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
                       AlarmHistoryModel *alarmHistoryModel)
{
  if (!ftc)
    return false;
  if (!dtc)
    return false;
  if (!ppmDtc)
    return false;

  m_operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();

  m_ftc = ftc;
  m_dtc = dtc;

  connect(m_dtc.get(), &AlarmManagement::Interface::Dtc::alarmConfigChanged,
          this, &AlarmDialog::onAlarmConfigChanged);
  m_dtc->enableAlarmConfig();

  auto cbConfig = [this](const AlarmManagement::AlarmConfig & c)
  {
    onAlarmConfigChanged(c, DataModification::eAdded);
  };
  m_dtc->alarmConfigs(cbConfig);

  delete m_configAlarmModel;
  m_configAlarmModel = new AlarmManagement::ConfigAlarmModel(this);
  bool global = true;
  m_configAlarmModel->initModel(m_dtc, ppmDtc, alarmHistoryModel, global);

  INFO_LOG(m_logger) << "AlarmDialog::init";
  return true;
}

void AlarmDialog::retranslate()
{
  translate(m_ui, tr("Configure Global Alarms"));
}

void AlarmDialog::onAlarmConfigChanged(const AlarmManagement::AlarmConfig &data, DataModification modType)
{
  bool setMarker = data.setMarker();
  bool messageWindow = data.messageWindow();
  if (modType == DataModification::eRemoved)
    return;

  DEBUG_LOG(m_logger) << "************** onAlarmConfigChanged "
                      << " id=" << data.id()
                      << " operatorId=" << data.operatorId()
                      << " m_operatorId=" << m_operatorId
                      << " participantId=" << data.participantId()
                      << " eventTypeId=" << data.eventTypeId()
                      << " messageWindow=" << messageWindow
                      << " setMarker=" << setMarker;
  if (data.global() == false)
    return;

  if (data.operatorId() == m_operatorId)
  {
    DEBUG_LOG(m_logger) << "************** onAlarmConfig zuweisen ";
    switch (data.eventTypeId().underlying())
    {
    case ProjectDataManagement::EventType_def::EnterNuclear:
    {
      DEBUG_LOG(m_logger) << "EnterNuclear zuweisen ";
      m_ui->cbxNMarker->setChecked(setMarker);
      m_ui->cbxNMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::EnterDangerArea:
    {
      DEBUG_LOG(m_logger) << "EnterDangerArea zuweisen ";
      m_ui->cbxDanerAreaMarker->setChecked(setMarker);
      m_ui->cbxDangerAreaMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::EnterMineArea:
    {
      DEBUG_LOG(m_logger) << "EnterMineArea zuweisen ";
      m_ui->cbxMineAreaEntryMarker->setChecked(setMarker);
      m_ui->cbxMineAreaEntryMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::HitMine:
    {
      DEBUG_LOG(m_logger) << "HitMine zuweisen ";
      m_ui->cbxMineAreaHitMarker->setChecked(setMarker);
      m_ui->cbxMineAreaHitMessage->setChecked(messageWindow);
      break;
    }

    case ProjectDataManagement::EventType_def::Hit:
    {
      DEBUG_LOG(m_logger) << "Hit zuweisen ";
      m_ui->cbxDirectFireMarker->setChecked(setMarker);
      m_ui->cbxDirectFireMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::HitEffectSimulation:
    {
      DEBUG_LOG(m_logger) << "HitEffectSimulation zuweisen ";
      m_ui->cbxIndirectFireMarker->setChecked(setMarker);
      m_ui->cbxIndirectFireMessage->setChecked(messageWindow);
      break;
    }

    case ProjectDataManagement::EventType_def::CrossLocalBorderline:
    {
      DEBUG_LOG(m_logger) << "CrossLocalBorderline zuweisen ";
      m_ui->cbxLocalBorderMarker->setChecked(setMarker);
      m_ui->cbxLocalBorderMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::CrossGlobalBorderline:
    {
      DEBUG_LOG(m_logger) << "CrossGlobalBorderline zuweisen ";
      m_ui->cbxGlobalBorderMarker->setChecked(setMarker);
      m_ui->cbxGlobalBorderMessage->setChecked(messageWindow);
      break;
    }
    case ProjectDataManagement::EventType_def::AirSupport:
    {
      DEBUG_LOG(m_logger) << "AirSupport zuweisen ";
      m_ui->cbxAirSupportMarker->setChecked(setMarker);
      m_ui->cbxAirSupportMessage->setChecked(messageWindow);
      break;
    }
    default:
      ERROR_LOG(m_logger) << "Not possible to set with Operator App!!!";
      break;
    }
  }

} // end of onOperatorChanged


std::vector<AlarmManagement::AlarmAction> AlarmDialog::getCheckedValues() const
{
  AlarmManagement::AlarmAction alarmActionDds;
  std::vector<AlarmManagement::AlarmAction> ret;
  ret.clear();
  ret.reserve(m_checkBoxes.size());
  for (const AlarmCheckBox &item : qAsConst(m_checkBoxes))
  {
    alarmActionDds.eventTypeId(item.eventTypeId);
    if (item.checkboxMarker->isChecked())
    {
      alarmActionDds.setMarker(true);
      DEBUG_LOG(m_logger) << item.name << " setMarker = true";
    }
    else
    {
      alarmActionDds.setMarker(false);
      DEBUG_LOG(m_logger) << item.name << " setMarker = false";
    }
    if (item.checkboxWindow->isChecked())
    {
      alarmActionDds.messageWindow(true);
      DEBUG_LOG(m_logger) << item.name << " messageWindow = true";
    }
    else
    {
      alarmActionDds.messageWindow(false);
      DEBUG_LOG(m_logger) << item.name << " messageWindow = false";
    }
    if (alarmActionDds.setMarker() || alarmActionDds.messageWindow())
      ret.push_back(alarmActionDds);
  }
  return ret;
}

bool AlarmDialog::apply()
{
  std::vector<int32_t> participantIds;
  participantIds.push_back(0); // Global Event
  bool globalEvent = true;
  bool remove = false;
  const ConfigureAlarmsRequest req(getCheckedValues(), m_operatorId, participantIds, globalEvent, remove);

  return m_requestHelper->startSingleRequest([req, this]()
  {
    return m_ftc->configureAlarmsRequest(req, this);
  });
} // end of apply
} // namespace AlarmManagement