qt5-legatus-legacy/Lts/Plugins/AreaEffectSimulation/Gui/FunctionalArea/aes_functional_area_edit.cpp

/**
  * @RDE_HEADER@
  * AreaEffectSimulation - Functional Area Edit Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Malte Diers, SLSE, 2017-04-06
  */


#include "aes_functional_area_edit.h"
#include "ui_aes_functional_area_edit.h"

#include <LtsSession/lts_session_data.h>
#include <LtsUtilsSettings/settings.h>
#include <ParticipantManagement/ppm_translation.h>
#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
#include <Plugins/SituationMapPlugin/situation_map_gui_plugin_interface.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include "../AesInfo/aes_danger_area_aes_item_info.h"

#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>
#include <Plugins/ParticipantManagement/Gui/ParticipantSelection/participant_selection.h>
#include <Symbology/sidc_codec.h>
#include <SymbologyGui/base_symbol_lookup_dialog.h>
#include <SymbologyGui/symbol_modification_dialog.h>
#include <AreaEffectSimulation/Utils/polygons.h>
#include <AreaEffectSimulation/aes_translation.h>




// #include <QDebug>




namespace AreaEffectSimulation
{

double FunctionalAreaEdit::s_minWidth;
double FunctionalAreaEdit::s_maxWidth;
double FunctionalAreaEdit::s_stepWidth;
double FunctionalAreaEdit::s_minHeight;
double FunctionalAreaEdit::s_maxHeight;
double FunctionalAreaEdit::s_stepHeight;
int    FunctionalAreaEdit::s_minDurationMinutes;
int    FunctionalAreaEdit::s_maxDurationMinutes;
int    FunctionalAreaEdit::s_stepDurationMinutes;
int    FunctionalAreaEdit::s_minEffectMinutes;
int    FunctionalAreaEdit::s_maxEffectMinutes;
int    FunctionalAreaEdit::s_stepEffectMinutes;
int    FunctionalAreaEdit::s_stepSupplyMinutes;


// Todo: Höhe und Radius in Abhängigkeit der Munitionsart berechnen

FunctionalAreaEdit::FunctionalAreaEdit(const QString &menuGroup, QWidget *parent)
  : BaseEdit(menuGroup, QLatin1String("FunctionalAreaEdit"), parent)
  , m_symbolConfig(nullptr)
  , m_symbolWatcher(nullptr)
  , m_ui(new Ui::FunctionalAreaEdit)
{
  m_ui->setupUi(this);

  s_minWidth            =     5;
  s_maxWidth            =  1275;
  s_stepWidth           =     5;
  s_minHeight           =     5;
  s_maxHeight           =  1275;
  s_stepHeight          =     5;
  s_minDurationMinutes  =     1;
  s_maxDurationMinutes  = 14400;
  s_stepDurationMinutes =     1;

  s_minEffectMinutes  =     0;
  s_maxEffectMinutes  =  2550;
  s_stepEffectMinutes =    10;
  s_stepSupplyMinutes =    1;

  m_ui->sbWidth->setMinimum(s_minWidth);
  m_ui->sbWidth->setMaximum(s_maxWidth);
  m_ui->sbWidth->setSingleStep(s_stepWidth);
  m_ui->sbHeight->setMinimum(s_minHeight);
  m_ui->sbHeight->setMaximum(s_maxHeight);
  m_ui->sbHeight->setSingleStep(s_stepHeight);
  m_ui->sbDurationMinutes->setMinimum(s_minDurationMinutes);
  m_ui->sbDurationMinutes->setMaximum(s_maxDurationMinutes);
  m_ui->sbDurationMinutes->setSingleStep(s_stepDurationMinutes);

  m_ui->sbDecontaminationMinutes->setMinimum(s_minEffectMinutes);
  m_ui->sbDecontaminationMinutes->setMaximum(s_maxEffectMinutes);
  m_ui->sbDecontaminationMinutes->setSingleStep(s_stepEffectMinutes);
  m_ui->sbMaintanenceMinutes->setMinimum(s_minEffectMinutes);
  m_ui->sbMaintanenceMinutes->setMaximum(s_maxEffectMinutes);
  m_ui->sbMaintanenceMinutes->setSingleStep(s_stepEffectMinutes);
  m_ui->sbMedicalMinutes->setMinimum(s_minEffectMinutes);
  m_ui->sbMedicalMinutes->setMaximum(s_maxEffectMinutes);
  m_ui->sbMedicalMinutes->setSingleStep(s_stepEffectMinutes);
  m_ui->sbSupplyMinutes->setMinimum(s_minEffectMinutes);
  m_ui->sbSupplyMinutes->setMaximum(s_maxEffectMinutes);
  m_ui->sbSupplyMinutes->setSingleStep(s_stepSupplyMinutes);

  m_uiRequirements->addRequirement({m_ui->lblPosition,    [this]() { return (!m_ui->positionEdit->coordinate().isNull()); }});
  m_uiRequirements->addRequirement({m_ui->lblIdentifier,  [this]() { return (!m_ui->leIdentifier->text().isEmpty()); }});
  m_uiRequirements->addRequirement({m_ui->lblEffectStart, [this]() { return hasValidEffectStart(m_ui->dteEffectStart); }});
  m_uiRequirements->addRequirement({m_ui->lblParticipant,  [this]() { return (!m_ui->lblHierarchy->text().isEmpty()); }});
//  m_uiRequirements->addRequirement({m_ui->chbDecon,       [this]() { return (m_ui->chbDecon->isChecked() || m_ui->chbMaint->isChecked() || m_ui->chbMedic->isChecked()); }});

//  party is (currently) not user-visible
//  m_ui->lblParty->setVisible(false);
//  m_ui->cbParty->setVisible(false);

  connect(m_ui->cbDecontamination, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &FunctionalAreaEdit::onCbxIdxDeconChanged);
  connect(m_ui->cbMaintenance,     static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &FunctionalAreaEdit::onCbxIdxMaintChanged);
  connect(m_ui->cbMedical,         static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &FunctionalAreaEdit::onCbxIdxMedicChanged);
  connect(m_ui->cbSupply,          static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &FunctionalAreaEdit::onCbxIdxSupplyChanged);

  connect(m_ui->sbDecontaminationMinutes, &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbMaintanenceMinutes,     &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbMedicalMinutes,         &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbSupplyMinutes,          &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbWidth,                  &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbHeight,                 &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->sbDurationMinutes,        &QSpinBox::editingFinished, this, &FunctionalAreaEdit::correctSpinBoxValue);
  connect(m_ui->pbClear,                  &QPushButton::clicked,      m_ui->positionEdit, &LtsCoordWidget::LtsCoordWidget::clear);

  connect(m_ui->pbParticipant, &QPushButton::clicked, this, &FunctionalAreaEdit::onParticipantClicked);


  m_ui->sbDecontaminationMinutes->setEnabled(false);
  m_ui->sbMaintanenceMinutes->setEnabled(false);
  m_ui->sbMedicalMinutes->setEnabled(false);
  m_ui->sbSupplyMinutes->setEnabled(false);

  // Symbol:
  m_symbolWatcher = new AdvancedSymbology::SymbolResultWatcherQWidget<QToolButton>(m_ui->pbIcon);

  connect(m_ui->pbIcon, &QToolButton::clicked,         this, &FunctionalAreaEdit::onSymbolSelection);
  connect(m_ui->pbSymbolConfig, &QToolButton::clicked, this, &FunctionalAreaEdit::onSymbolConfig);
  connect(m_ui->pbClearPointSymbol, &QPushButton::clicked, this, &FunctionalAreaEdit::onClearPointSymbol);

  m_ui->cbFunctionalAreaType->setCurrentIndex(m_ui->cbFunctionalAreaType->findData(0)); // 0 is always functional area general
  connect(m_ui->cbFunctionalAreaType, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &FunctionalAreaEdit::onCbxIdxFunctionalAreaTypeChanged);
  // Initially do it:
  const bool showPvSan = LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("ParticipantInformation"),
                                                                      QStringLiteral("HasPvSan"));
  m_ui->cbFunctionalAreaType->setVisible(showPvSan);
  m_ui->lblType->setVisible(showPvSan);
  setOnlineHelpFilename(QStringLiteral("Situation-Add_Functional_Area"));

  enaDisa();
}

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

void FunctionalAreaEdit::retranslate()
{
  translate(m_ui, m_aesItem, tr("Functional Area"));
}

void FunctionalAreaEdit::enableUiElements(bool enable)
{
  m_ui->leIdentifier->setMaxLength(30);

  const FunctionalAreaType type = m_functionalAreaTypes.value(m_ui->cbFunctionalAreaType->currentData().toInt());
  //if (type.id() == 7) Supply Truck
  if (type.supplyMode() == AesOperatingMode_def::OmWaitingTime)
  {
    DEBUG_LOG(m_logger) << "SUPPLY-MODE";
    m_ui->sbDecontaminationMinutes->setEnabled(false);
    m_ui->cbDecontamination->setEnabled(false);
    m_ui->sbMaintanenceMinutes->setEnabled(false);
    m_ui->cbMaintenance->setEnabled(false);
    m_ui->sbMedicalMinutes->setEnabled(false);
    m_ui->cbMedical->setEnabled(false);
    m_ui->sbSupplyMinutes->setEnabled(true);
    m_ui->cbSupply->setEnabled(true);
    m_ui->pbParticipant->setEnabled(true);
    m_ui->cbParty->setEnabled(false);

    m_ui->sbDecontaminationMinutes->setValue(0);
    m_ui->cbDecontamination->setCurrentIndex(0);
    m_ui->sbMaintanenceMinutes->setValue(0);
    m_ui->cbMaintenance->setCurrentIndex(0);
    m_ui->sbMedicalMinutes->setValue(0);
    m_ui->cbMedical->setCurrentIndex(0);

    setVisableFaButtons();

  }
  else
  {

    m_ui->sbDecontaminationMinutes->setEnabled(true);
    m_ui->cbDecontamination->setEnabled(true);
    m_ui->sbMaintanenceMinutes->setEnabled(true);
    m_ui->cbMaintenance->setEnabled(true);
    m_ui->sbMedicalMinutes->setEnabled(true);
    m_ui->cbMedical->setEnabled(true);
    m_ui->sbSupplyMinutes->setEnabled(false);
    m_ui->cbSupply->setEnabled(false);

    m_ui->sbDurationMinutes->setEnabled(enable);
    m_ui->cbParty->setEnabled(enable);
    setEffectStartEnabled(m_ui->dteEffectStart, enable);

    m_ui->pbPosition->setEnabled(m_sitMapGuiIfc && enable);
    m_ui->positionEdit->setEnabled(enable);
    m_ui->sbHeight->setEnabled(enable);
    m_ui->sbWidth->setEnabled(enable);


    const bool deconAvailable = type.deconMode() != AesOperatingMode_def::OmNotAvailable;
    const bool maintAvailable = type.maintMode() != AesOperatingMode_def::OmNotAvailable;
    const bool medicAvailable = type.medicMode() != AesOperatingMode_def::OmNotAvailable;

    m_ui->cbDecontamination->setEnabled(enable && deconAvailable);
    m_ui->cbMaintenance->setEnabled(enable && maintAvailable);
    m_ui->cbMedical->setEnabled(enable && medicAvailable);

    m_ui->sbDecontaminationMinutes->setEnabled((m_ui->cbDecontamination->currentIndex() == AesOperatingMode_def::OmWaitingTime) && enable && deconAvailable);
    m_ui->sbMaintanenceMinutes->setEnabled((m_ui->cbMaintenance->currentIndex() == AesOperatingMode_def::OmWaitingTime) && enable && maintAvailable);
    m_ui->sbMedicalMinutes->setEnabled((m_ui->cbMedical->currentIndex() == AesOperatingMode_def::OmWaitingTime) && enable && medicAvailable);
    m_ui->sbSupplyMinutes->setEnabled(false);
    m_ui->sbSupplyMinutes->setValue(0);
    m_ui->cbSupply->setCurrentIndex(0);
    setVisableFaButtons();
  }
  const bool isGenericFunctionalArea = type.id() == 0;
  const bool symbolAvailable = type.pointSymbol().empty();
  m_ui->pbClear->setEnabled(enable);
  m_ui->leIdentifier->setEnabled(enable || isOnlyNameModifiable());

  m_ui->pbIcon->setEnabled(enable && isGenericFunctionalArea);

  if (AdvancedSymbology::SidcCodec::isEncoded(m_sidc))
  {
    //was is mit ETS Symbolen?
    const QString rawSidc = AdvancedSymbology::SidcCodec::decodeRawSidc(m_sidc);
    m_ui->pbSymbolConfig->setEnabled(rawSidc.size() && !AdvancedSymbology::SidcCodec::isCivil(m_sidc) && enable && symbolAvailable && isGenericFunctionalArea);
  }
  else
    m_ui->pbSymbolConfig->setEnabled(false);

  m_ui->pbClearPointSymbol->setEnabled(isGenericFunctionalArea);


  if (m_aesItem.effectStateId() == AesEffectState_def::EsExpired)
  {
    m_ui->leIdentifier->setText(QString::fromStdString(m_aesItem.name()));
    __unchange__();
    DEBUG_LOG(m_logger) << "setUnchangeable()";
    setUnchangeable();
    disableButtons(true);
  }
  if (m_aesItem.effectStateId() == AesEffectState_def::EsActivated)
  {
    QString name = m_ui->leIdentifier->text();
    auto baseData = m_dtc->functionalArea(m_aesItem.id());
    DEBUG_LOG(m_logger) << "init: setData";
    setData(baseData, false);
    __unchange__();
    if (name != m_ui->leIdentifier->text())
      m_ui->leIdentifier->setText(name);
    DEBUG_LOG(m_logger) << "setUnchangeable()";
    setUnchangeable();
    disableButtons(true);
  }
}

bool FunctionalAreaEdit::init(int areaId, bool copy,
                              LtsSession::LtsSession *session)
{
  if (!BaseEdit::init(areaId, session))
    return false;

  if (!session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
    return false;

  m_ui->cbFunctionalAreaType->clear();
  m_functionalAreaTypes = m_dtc->functionalAreaTypes();
  for (const auto &type : qAsConst(m_functionalAreaTypes))
    m_ui->cbFunctionalAreaType->addItem(AreaEffectSimulation::trFunctionalAreaTypeName(type.name()), type.id());

  bool editable = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FunctionalAreasEdit) ||
                  m_session->app() == LtsAppDescriptor::App::OC;
  bool readable = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FunctionalAreasShow);

  if (!readable && !editable)
    return false;

  m_ui->dteEffectStart->setMinimumTimeMSec(m_session->partitionTime());
  m_ui->dteEffectStart->setRetrieveCurrentTimeCallback([this]() { return m_session->partitionTime(); });

  if (m_sitMapGuiIfc)
    connect(m_ui->pbPosition, &QPushButton::clicked, this, &FunctionalAreaEdit::getPosition);
  else
    m_ui->pbPosition->setEnabled(false);

  // get access to AdvancedSymbology::SymbolDictionary:
  m_session->getForeignDataInterface<AdvancedSymbology::DataInterface>(m_asbfc);

  fillCbx();

  if (areaId > 0)
  {
    auto baseData = m_dtc->functionalArea(areaId);
    DEBUG_LOG(m_logger) << "init: setData";
    setData(baseData, copy);
  }

  connect(m_ui->cbParty, QOverload<int>::of(&LtsWidgets::LtsComboBox::currentIndexChanged), this, [this]()
  {
    onChangeSymbol(m_sidc);
  });

  enableUiElements(editable && isModifiable() && !isOnlyNameModifiable());

  connect(m_dtc.get(), &AreaEffectSimulation::Interface::Dtc::functionalAreaChanged,
          this, &BaseEdit::onAreaChanged);

  return true;
}

void FunctionalAreaEdit::setData(const FunctionalArea &area, bool copy)
{
  m_aesItem = area;
  if (copy)
  {
    m_aesItem.id(0);
    m_aesItem.effectStateId(AreaEffectSimulation::AesEffectState_def::get_default());
  }

  m_ui->leIdentifier->setText(QString::fromStdString(area.name()));
  m_ui->dteEffectStart->setMsecsSinceEpoch(area.effectStart().is_set() ? area.effectStart().get() : 0);
  m_ui->sbDurationMinutes->setValue(area.effectDuration() / 1000 / 60); // msecs -> mins
  m_ui->sbWidth->setValue(area.area().width());
  m_ui->sbHeight->setValue(area.area().height());
  m_ui->cbParty->setCurrentIndex(m_ui->cbParty->findData(area.partyId().is_set() ? area.partyId().get() : 0));

  const QPointF bottomLeft(area.area().cornerBottomLeft().lon(), area.area().cornerBottomLeft().lat());
  const QPointF centerpoint = Polygons::bottomLeft2CenterPoint(bottomLeft, area.area().width(), area.area().height(), 0.0);
  if (!bottomLeft.isNull())
    m_ui->positionEdit->setCoordinate(centerpoint);

  m_ui->cbDecontamination->setCurrentIndex(m_ui->cbDecontamination->findData(area.deconMode().underlying()));
  m_ui->cbMaintenance->setCurrentIndex(m_ui->cbMaintenance->findData(area.maintMode().underlying()));
  m_ui->cbMedical->setCurrentIndex(m_ui->cbMedical->findData(area.medicMode().underlying()));

  m_ui->sbDecontaminationMinutes->setValue(area.deconTime() / (1000 * 60));
  m_ui->sbMaintanenceMinutes->setValue(area.maintTime() / (1000 * 60));
  m_ui->sbMedicalMinutes->setValue(area.medicTime() / (1000 * 60));
  m_ui->sbSupplyMinutes->setValue(area.supplyTime() / (1000 * 60));

  m_ui->cbFunctionalAreaType->setCurrentIndex(m_ui->cbFunctionalAreaType->findData(area.functionalAreaTypeId()));

  if (m_aesItem.participantId().is_set())
  {
     int participantId = m_aesItem.participantId().get();
     DEBUG_LOG(m_logger) << "ParticipantId = " << participantId;
     QVector<int> participants;
     participants.append(participantId);
     onParticipant(participants);
  }

  // Symbol:
  if (area.pointSymbol().is_set())
  {
    m_sidc = QString::fromStdString(area.pointSymbol().get());
    onChangeSymbol(m_sidc);
  }
  if ((m_aesItem.effectStateId() == AesEffectState::EsActivated)
      || (m_aesItem.effectStateId() == AesEffectState::EsExpired))
  {
    DEBUG_LOG(m_logger) << "setUnchangeable";
    disableButtons(true);
    setUnchangeable();
  }
}

void FunctionalAreaEdit::fillCbx()
{
  int curIdxDeconCbx = m_ui->cbDecontamination->currentIndex();
  int curIdxMaintCbx = m_ui->cbMaintenance->currentIndex();
  int curIdxMedicCbx = m_ui->cbMedical->currentIndex();

  // clear cbx
  m_ui->cbDecontamination->clear();
  m_ui->cbMaintenance->clear();
  m_ui->cbMedical->clear();
  m_ui->cbSupply->clear();

  // fill with text
  QString unused = tr("unused");
  QString byOperator = tr("by operator");
  QString bytimeout = tr("by wait time");

  m_ui->cbDecontamination->addItem(unused, AesOperatingMode_def::OmNotUsed);
  m_ui->cbDecontamination->addItem(byOperator, AesOperatingMode_def::OmObserver);
  m_ui->cbDecontamination->addItem(bytimeout, AesOperatingMode_def::OmWaitingTime);

  m_ui->cbMaintenance->addItem(unused, AesOperatingMode_def::OmNotUsed);
  m_ui->cbMaintenance->addItem(byOperator, AesOperatingMode_def::OmObserver);
  m_ui->cbMaintenance->addItem(bytimeout, AesOperatingMode_def::OmWaitingTime);

  m_ui->cbMedical->addItem(unused, AesOperatingMode_def::OmNotUsed);
  m_ui->cbMedical->addItem(byOperator, AesOperatingMode_def::OmObserver);
  m_ui->cbMedical->addItem(bytimeout, AesOperatingMode_def::OmWaitingTime);

  m_ui->cbSupply->addItem(bytimeout, AesOperatingMode_def::OmWaitingTime);

  // reset Idx
  if (curIdxDeconCbx >= 0)
    m_ui->cbDecontamination->setCurrentIndex(curIdxDeconCbx);
  if (curIdxMaintCbx >= 0)
    m_ui->cbDecontamination->setCurrentIndex(curIdxMaintCbx);
  if (curIdxMedicCbx >= 0)
    m_ui->cbDecontamination->setCurrentIndex(curIdxMedicCbx);
  m_ui->cbSupply->setCurrentIndex(0);

  m_ppmGuiCbxIfc->fillPartyComboBox(m_ui->cbParty);
}

void FunctionalAreaEdit::getPosition()
{
  if (!has2DMap())
    return;

  m_sitMapGuiIfc->getRectangleNorth(this,
                                    SLOT(onRectData(QPointF,double,double,QPolygonF)),
                                    nullptr,
                                    s_minWidth,
                                    s_maxWidth,
                                    s_minHeight,
                                    s_maxHeight,
                                    m_ui->positionEdit->coordinate(),
                                    m_ui->sbWidth->value(),
                                    m_ui->sbHeight->value());
}

void FunctionalAreaEdit::onRectData(const QPointF &centerPoint, double width, double height, const QPolygonF &coordinates)
{
  m_previewPolygon = coordinates;
  m_ui->positionEdit->setCoordinate(centerPoint);
  m_ui->sbWidth->setValue(width);
  m_ui->sbHeight->setValue(height);
  DEBUG_LOG(m_logger) << "Pos X: " << centerPoint.x() << " Y: " << centerPoint.y() << " W: " << width << " H: " << height;

  showPreviewObject();
}

void FunctionalAreaEdit::onCbxIdxDeconChanged()
{
  m_ui->sbDecontaminationMinutes->setEnabled(AesOperatingMode_def::OmWaitingTime == m_ui->cbDecontamination->currentData().toInt());
}

void FunctionalAreaEdit::onCbxIdxMaintChanged()
{
  m_ui->sbMaintanenceMinutes->setEnabled(AesOperatingMode_def::OmWaitingTime == m_ui->cbMaintenance->currentData().toInt());
}

void FunctionalAreaEdit::onCbxIdxMedicChanged()
{
  m_ui->sbMedicalMinutes->setEnabled(AesOperatingMode_def::OmWaitingTime == m_ui->cbMedical->currentData().toInt());
}

void FunctionalAreaEdit::onCbxIdxSupplyChanged()
{
  m_ui->sbSupplyMinutes->setEnabled(AesOperatingMode_def::OmWaitingTime == m_ui->cbSupply->currentData().toInt());
}

void FunctionalAreaEdit::onCbxIdxFunctionalAreaTypeChanged()
{
  const FunctionalAreaType type = m_functionalAreaTypes.value(m_ui->cbFunctionalAreaType->currentData().toInt());
  DEBUG_LOG(m_logger) << "onCbxIdxFunctionalAreaTypeChanged"
                      << " type.id=" << type.id()
                      << " name=" << type.name();
  if (type.id() != 0)
  {
    if (type.id() == 7)
    {
      m_ui->sbSupplyMinutes->setValue(type.supplyTime());
      m_ui->cbSupply->setCurrentIndex(0);
    }
    else
    {
      m_sidc = QString::fromStdString(type.pointSymbol());
      onChangeSymbol(m_sidc);
      m_ui->sbDecontaminationMinutes->setValue(type.deconTime());
      m_ui->sbMaintanenceMinutes->setValue(type.maintTime());
      m_ui->sbMedicalMinutes->setValue(type.medicTime());
      m_ui->cbDecontamination->setCurrentIndex(m_ui->cbDecontamination->findData(type.deconMode() == AesOperatingMode_def::OmNotAvailable ? AesOperatingMode_def::OmNotUsed : type.deconMode().underlying()));
      m_ui->cbMaintenance->setCurrentIndex(m_ui->cbMaintenance->findData(type.maintMode() == AesOperatingMode_def::OmNotAvailable ? AesOperatingMode_def::OmNotUsed : type.maintMode().underlying()));
      m_ui->cbMedical->setCurrentIndex(m_ui->cbMedical->findData(type.medicMode() == AesOperatingMode_def::OmNotAvailable ? AesOperatingMode_def::OmNotUsed : type.medicMode().underlying()));
    }
  }
  enableUiElements(true);
}

void FunctionalAreaEdit::onSymbolSelection()
{
  if (!m_asbfc)
  {
    ERROR_LOG(m_logger) << " m_asbfc";
    return;
  }

  AdvancedSymbology::Gui::BaseSymbolLookupDialog *bslDlg =
    AdvancedSymbology::Gui::BaseSymbolLookupDialog::showInstance();

  connect(bslDlg, &AdvancedSymbology::Gui::BaseSymbolLookupDialog::finished, this, [this, bslDlg]()
  {
    // qCritical() << " finished";
    bslDlg->disconnect(this); // !!! disconnect my slots from bslDlg !!!
  });
  connect(bslDlg, &AdvancedSymbology::Gui::BaseSymbolLookupDialog::lookupAppliedCompleteSidc, this, &FunctionalAreaEdit::onChangeSymbol);

  bslDlg->setParticipantMode(false);
  bslDlg->setCurrentSidc(m_sidc);
  bslDlg->show();
}

void FunctionalAreaEdit::onSymbolConfig()
{
  if (!m_asbfc)
  {
    ERROR_LOG(m_logger) << " no m_asbfc";
    return;
  }
  AdvancedSymbology::SymbologyType symbologyType = AdvancedSymbology::SymbolDictionary::defaultSymbologyType();
  m_symbolConfig = new AdvancedSymbology::Gui::SymbolModificationDialogFrameless(m_asbfc->getSymbolDictionary(symbologyType), false /* isParticipant */, this);
  m_symbolConfig->setSidc(m_sidc);
  connect(m_symbolConfig, &AdvancedSymbology::Gui::SymbolModificationDialogFrameless::sidcOnClose, this, &FunctionalAreaEdit::onChangeSymbol);
  connect(m_symbolConfig, &AdvancedSymbology::Gui::SymbolModificationDialogFrameless::rejected, this, [this]()
  {
    m_symbolConfig->deleteLater();
    m_symbolConfig = nullptr;
  });
  m_symbolConfig->show();
}

void FunctionalAreaEdit::onChangeSymbol(const QString &sidc)
{
  TRACE_LOG(m_logger) << "Changing symbol to " << sidc;

  if (m_sidc != sidc)
    this->slotChangesMade();

  m_sidc = sidc;

  if (m_sidc.isEmpty())
  {
    m_ui->pbIcon->setIcon(QIcon());  // clear
    return;
  }

  if (!m_asbfc)
  {
    ERROR_LOG(m_logger) << " no m_asbfc";
    return;
  }

  AdvancedSymbology::SymbolDataToRender symDataToRender(sidc);
  symDataToRender.fillColor = AdvancedSymbology::SymbolDataToRender::unknownColor();
  symDataToRender.fillColorReplace = true;

  int partyId = m_ui->cbParty->currentData().toInt();
  if (partyId >= 0)
  {
    std::shared_ptr<ParticipantManagement::Interface::Dtc> ppmDtc;
    m_session->getDtc<ParticipantManagement::DataInterface>(ppmDtc);
    if (ppmDtc)
      symDataToRender.fillColor = ppmDtc->party(partyId).color();
    else
      WARNING_LOG(m_logger) << "no ppmDtc";
  }

  m_symbolWatcher->setSymbolResult(m_asbfc->findImage(symDataToRender));

  if (AdvancedSymbology::SidcCodec::isEncoded(m_sidc))
  {
    const bool isGenericFunctionalArea = m_ui->cbFunctionalAreaType->currentData().toInt() == 0;
    const QString rawSidc = AdvancedSymbology::SidcCodec::decodeRawSidc(m_sidc);
    m_ui->pbSymbolConfig->setEnabled(rawSidc.size() && (!AdvancedSymbology::SidcCodec::isCivil(m_sidc)) && isGenericFunctionalArea);
  }
  else
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " sidc is not encoded, sidc = '" << sidc << "'";
    m_ui->pbSymbolConfig->setEnabled(false);
  }

  if (m_symbolConfig)
  {
    m_symbolConfig->deleteLater();
    m_symbolConfig = nullptr;
  }

  DEBUG_LOG(m_logger) << "Changing symbol to " << sidc << " is in progress";
}

void FunctionalAreaEdit::onClearPointSymbol()
{
  onChangeSymbol(QString());
}

bool FunctionalAreaEdit::apply()
{
  DEBUG_LOG(m_logger) << "Apply";
  std::string name     = m_ui->leIdentifier->text().toStdString();
  qint64 effectStart   = m_ui->dteEffectStart->msecsSinceEpoch();
  int duration         = m_ui->sbDurationMinutes->value() * 60 * 1000; // mins -> msecs
  int chargeType       = 411; // Dummy Med area charge id Uleis
  int partyId          = m_ui->cbParty->currentData().toInt();
  int functionalAreaType = m_ui->cbFunctionalAreaType->currentData().toInt();
  int playerId         = 0;
  const auto pointSymbol = m_sidc.toStdString();
  AesOperatingMode deconMode = static_cast<AesOperatingMode_def::type>(m_ui->cbDecontamination->currentData().toInt());
  int              deconTime = (AesOperatingMode_def::OmWaitingTime == m_ui->cbDecontamination->currentData().toInt()) ? 1000 * 60 * m_ui->sbDecontaminationMinutes->value() : 0;
  AesOperatingMode maintMode = static_cast<AesOperatingMode_def::type>(m_ui->cbMaintenance->currentData().toInt());
  int              maintTime = (AesOperatingMode_def::OmWaitingTime == m_ui->cbMaintenance->currentData().toInt()) ? 1000 * 60 * m_ui->sbMaintanenceMinutes->value() : 0;
  AesOperatingMode medicMode = static_cast<AesOperatingMode_def::type>(m_ui->cbMedical->currentData().toInt());
  int              medicTime = (AesOperatingMode_def::OmWaitingTime == m_ui->cbMedical->currentData().toInt()) ? 1000 * 60 * m_ui->sbMedicalMinutes->value() : 0;
  AesOperatingMode supplyMode = static_cast<AesOperatingMode_def::type>(m_ui->cbSupply->currentData().toInt());
  if ( functionalAreaType != 7 )
    supplyMode = AesOperatingMode_def::OmNotUsed;
  int              supplyTime = (AesOperatingMode_def::OmWaitingTime == m_ui->cbSupply->currentData().toInt()) ? 1000 * 60 * m_ui->sbSupplyMinutes->value() : 0;
  AesOperatingMode notfightMode = static_cast<AesOperatingMode_def::type>(m_ui->cbMedical->currentData().toInt());
  int              notfightTime = (AesOperatingMode_def::OmWaitingTime == m_ui->cbMedical->currentData().toInt()) ? 1000 * 60 * m_ui->sbMedicalMinutes->value() : 0;
  if ( functionalAreaType == 7 )
  {
    deconMode = AesOperatingMode_def::OmNotUsed;
    maintMode = AesOperatingMode_def::OmNotUsed;
    medicMode = AesOperatingMode_def::OmNotUsed;
    notfightMode = AesOperatingMode_def::OmNotUsed;
  }
  if ( functionalAreaType == 8 )
  {
    deconMode = AesOperatingMode_def::OmNotUsed;
    maintMode = AesOperatingMode_def::OmNotUsed;
    medicMode = AesOperatingMode_def::OmNotUsed;
    supplyMode = AesOperatingMode_def::OmNotUsed;
    notfightMode = AesOperatingMode_def::OmObserver;
  }

  QPointF bottomLeft(Polygons::centerPoint2BottomLeft(m_ui->positionEdit->coordinate(),
                                                      m_ui->sbWidth->value(),
                                                      m_ui->sbHeight->value(),
                                                      0.0));
  const Core::GeoPosition2D bottomLeftGeo(bottomLeft.x(), bottomLeft.y());
  const Area                area(bottomLeftGeo, m_ui->sbWidth->value(), m_ui->sbHeight->value(), 0.0);

  const ::dds::core::optional< int32_t > participantIdOpt = LtsUtils::toOptional(playerId);
  if (supplyMode == AesOperatingMode_def::OmWaitingTime)
  {
    partyId = 0;
    playerId =  m_participant.id();
  }

  FunctionalAreaModifyRequest req(m_aesItem.id(),
                                  name,
                                  LtsUtils::toOptional(effectStart),
                                  duration,
                                  chargeType,
                                  area,
                                  LtsUtils::toOptional(partyId),
                                  LtsUtils::toOptional(playerId),
                                  LtsUtils::toOptional(pointSymbol),
                                  functionalAreaType, // Todo: Get from UI
                                  deconMode,
                                  deconTime,
                                  maintMode,
                                  maintTime,
                                  medicMode,
                                  medicTime,
                                  supplyMode,
                                  supplyTime,
                                  notfightMode,
                                  notfightTime
                                 );

  m_requestHelper->addRequest([this, req, functionalAreaType]()
  {
    DEBUG_LOG(m_logger) << "addRequest m_aesItem.id()=" << m_aesItem.id()
                         << " functionalAreaType=" << functionalAreaType
                         << " area=" << req;
    return m_ftc->functionalAreaModifyRequest(req, this);
  });

  DEBUG_LOG(m_logger) << "startRequest";
  return m_requestHelper->startRequests();
}

void FunctionalAreaEdit::showPreviewObject()
{
  if (!m_sitMapGuiIfc)
    return;

  if (m_previewPolygon.isEmpty())
    return;

  m_sitMapGuiIfc->displayPreviewObject(this, m_previewPolygon, true);
}

void FunctionalAreaEdit::disableButtons(bool state)
{
  m_ui->leIdentifier->setDisabled(state);
  m_ui->sbDurationMinutes->setDisabled(state);
  m_ui->positionEdit->setDisabled(state);
  m_ui->pbPosition->setDisabled(state);
  m_ui->pbClear->setDisabled(state);
  m_ui->sbWidth->setDisabled(state);
  m_ui->sbHeight->setDisabled(state);
  m_ui->cbFunctionalAreaType->setDisabled(state);
  m_ui->cbDecontamination->setDisabled(state);
  m_ui->cbMaintenance->setDisabled(state);
  m_ui->cbMedical->setDisabled(state);
  m_ui->cbSupply->setDisabled(state);
  m_ui->sbDecontaminationMinutes->setDisabled(state);
  m_ui->sbMaintanenceMinutes->setDisabled(state);
  m_ui->sbMedicalMinutes->setDisabled(state);
  m_ui->sbSupplyMinutes->setDisabled(state);
  m_ui->pbIcon->setDisabled(state);
  m_ui->pbSymbolConfig->setDisabled(state);
  m_ui->pbClear->setDisabled(state);
  m_ui->pbClearPointSymbol->setDisabled(state);
  m_ui->cbParty->setDisabled(state);
  m_ui->dteEffectStart->setDisabled(state);
  m_ui->pbParticipant->setDisabled(state);
  m_ui->pbParticipant->setDisabled(state);
}

void FunctionalAreaEdit::setVisableFaButtons()
{
  int functionalAreaType = m_ui->cbFunctionalAreaType->currentData().toInt();

  DEBUG_LOG(m_logger) << "setVisableFaButtons!!!!!!!!!!!!!!!!!!!!!!!! Type=" << functionalAreaType;
  const QList<QWidget *> children = findChildren<QWidget *>();
  for (QWidget *w : qAsConst(children))
  {
    //qWarning() << "MWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMWMW";

    const QVariant type(w->property("type"));
    //qWarning() << "widget" << w->objectName() << "- type is:" << type;
    if (type.isNull())
      continue;

    auto x1 = type.toStringList();
    //qWarning() << "x1" << x1;

    auto x2 = QString::number(functionalAreaType);
    //qWarning() << "x2" << x2;

    auto x3 = x1.contains(x2);
    //qWarning() << "x3" << x3;

    w->setVisible(x3);

    //qWarning() << "visible now?" << w->isVisible() << "parent?" << w->parentWidget();
  }

}

QStringList FunctionalAreaEdit::toStringList(const QList<QByteArray> &list)
{
  QStringList stringList;
  stringList.reserve(list.size());

  for (const QByteArray &ba : qAsConst(list))
    stringList.append(QString::fromLocal8Bit(ba)); // Assuming local 8-bit.

  return stringList;
}

void FunctionalAreaEdit::onParticipantClicked()
{
  ParticipantManagement::ParticipantSelection *ps = new ParticipantManagement::ParticipantSelection(m_session, this);
  ps->init();
  ps->setParticipantSelected(m_participant.partyId(), m_participant.id());

  connect(ps, &ParticipantManagement::ParticipantSelection::selectedParticipants, this, &FunctionalAreaEdit::onParticipant);
  ps->exec();
}

void FunctionalAreaEdit::onParticipant(const QVector<int> &participants)
{
  DEBUG_LOG(m_logger) << "onParticipant"
                       << " participants.size=" << participants.size();


  if (participants.isEmpty())
    return;

//  if (participants[0] == m_participant.id())
//    return;
  m_participant = m_ppmDtc->participant(participants[0]);
  QString lblHierarchy = m_ppmDtc->hierarchyFromParticipant(m_participant.id());
  QString lblParticipantType = ParticipantManagement::trTypeName(m_ppmDtc->type(m_participant.typeId()).name());
  int functionalAreaType = m_ui->cbFunctionalAreaType->currentData().toInt();
  DEBUG_LOG(m_logger) << "m_participant.id=" << m_participant.id()
                       << " designator=" << m_participant.designator()
                       << " tacticalIdentifier=" << m_participant.tacticalIdentifier()
                       << " lblHierarchy=" << lblHierarchy
                       << " lblHierarchy.isVisable=" << m_ui->lblHierarchy->isVisible()
                       << " lblParticipantType=" << lblParticipantType
                       << " lblParticipantType.isVisable=" << m_ui->lblParticipantType->isVisible()
                       << " functionalAreaType=" << functionalAreaType;
  QList<QByteArray> dynamicProperties = m_ui->lblHierarchy->dynamicPropertyNames();
  const QStringList propertyStrHierarchie = toStringList(dynamicProperties);

  DEBUG_LOG(m_logger) << "lblHierarchy.property=" << dynamicProperties.size()
                       << " property=" << propertyStrHierarchie.join(QStringLiteral("|"));

  QList<QByteArray> dynamicPropertiesType = m_ui->cbFunctionalAreaType->dynamicPropertyNames();
  const QStringList propertyStrType = toStringList(dynamicPropertiesType);

  DEBUG_LOG(m_logger) << "cbFunctionalAreaType.property=" << dynamicProperties.size()
                       << " property=" << propertyStrType.join(QStringLiteral("|"));

  m_ui->lblHierarchy->show();
  m_ui->lblHierarchy->setText(m_ppmDtc->hierarchyFromParticipant(m_participant.id()));
  m_ui->lblParticipantType->show();
  m_ui->lblParticipantType->setText(ParticipantManagement::trTypeName(m_ppmDtc->type(m_participant.typeId()).name()));
  m_ui->lblEquipmentNumber->show();

  dds::core::optional<int32_t> eqId = m_participant.equipmentNumber();

  if (eqId.is_set())
  {
    QString id = QString::number(eqId.get());
    m_ui->lblEquipmentNumber->setText(id);
  }
  else
    m_ui->lblEquipmentNumber->setText(QStringLiteral("-"));

}

} // namespace AreaEffectSimulation