qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Plugins/EffectShowClient/Gui/esc_operating_condition.cpp

#include "esc_operating_condition.h"
#include <NGLLogger/NGLLoggerBootstrap.h>

#include "LtsWidgets/lts_message_dialog.h"
#include "esc_safety_confirmation_widget.h"
#include "esc_smoke_state.h"
#include "ui_esc_operating_condition.h"

#include <QtCore/QStringList>
#include <QtCore/QTimer>
#include <ngltools/ngltools_dtg.h>

namespace EffectShowClient
{

OperatingCondition::OperatingCondition(QWidget* parent)
    : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_dtc(nullptr), m_ftc(nullptr),
      m_lastState(EffectShowClient::OperatingConditionEntity()), m_meteoTimerTimeout(60 * 1000 * 15),
      m_meteoTimer(new QTimer(this)), m_smokeState(nullptr), m_safetyConfirmationWidget(nullptr),
      m_ui(new Ui::OperatingCondition), m_requestHelper(new LtsUtils::RequestHelper(this))
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
{
    m_ui->setupUi(this);
    m_smokeState = new EffectShowClient::SmokeState(this);
    m_ui->hz->insertWidget(1, m_smokeState);
    m_smokeState->setVisible(false);

    m_ui->lblStation->hide();
    m_ui->leStation->hide();

    m_ui->leLastUpdate->clear();
    m_ui->leLastUpdate->setEnabled(false);

    m_batteryVoltage.maximumValue = m_ui->frameGreenVoltage->width();

    connect(m_ui->pbSendAmmunition, &QPushButton::clicked, this, &OperatingCondition::onSendAmmunition);

    setOnlineHelpFilename(QLatin1String("OC-Operating_Condition"));
}

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

bool OperatingCondition::init(const std::shared_ptr<EffectShowClient::Interface::Dtc>& dtc,
                              const std::shared_ptr<EffectShowClient::Interface::Ftc>& ftc)
{
    DEBUG_LOG(m_logger) << "OperatingCondition::init()";

    if (!dtc || !ftc)
    {
        ERROR_LOG(m_logger) << "OperatingCondition::init() Invalid shared_ptr!";
        return false;
    }

    m_dtc = dtc;
    m_ftc = ftc;

    m_safetyConfirmationWidget = new EffectShowClient::SafetyConfirmationWidget(this);
    m_safetyConfirmationWidget->init(m_ftc);
    m_ui->safetyLayout->insertWidget(0, m_safetyConfirmationWidget);

    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::operatingConditionEntityChanged, this,
            &OperatingCondition::onOperatingConditionEntityChanged);
    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::meteoNearVehicleChanged, this,
            &OperatingCondition::onMeteoNearVehicleChanged);

    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::firingExplosionEntityChanged, this,
            &OperatingCondition::onFiringExplosionEntityChanged);

    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::firingSmokeEntityChanged, this,
            &OperatingCondition::onFiringSmokeEntityChanged);

    connect(m_meteoTimer, &QTimer::timeout, this, &OperatingCondition::onMeteoTimeout);

    m_meteoTimer->start(m_meteoTimerTimeout);

    onMeteoTimeout();

    setBatteryVoltageConstraints(21.0, 22.0, 36.0);

    onOperatingConditionEntityChanged(m_dtc->operatingConditionEntity(), DataModification::eAdded);

    const EffectShowClient::MeteoNearVehicle mdmv = m_dtc->meteoNearVehicle();
    if (mdmv.temperature > 0 && mdmv.windSpeed > 0)
        onMeteoNearVehicleChanged(m_dtc->meteoNearVehicle(), DataModification::eAdded);

    connect(m_ui->pbConfirmReadiness, &QPushButton::clicked, this, &OperatingCondition::onSendConfirmReadiness);
    connect(m_ui->pbRevokeReadiness, &QPushButton::clicked, this, &OperatingCondition::onSendRevokeReadiness);

    onSafetyConfirmationDisplay();

    return true;
}

void OperatingCondition::retranslate()
{
    translate(m_ui, tr("Operating Condition"));
}

int OperatingCondition::getSmokeCount()
{
    const OperatingConditionEntity& data = m_dtc->operatingConditionEntity();
    int currentSmokeLoad = 0;
    if (data.smokeCartridge1 == EffectShowClient::StatusSmokeCartridge_e::Ready)
        currentSmokeLoad++;
    if (data.smokeCartridge2 == EffectShowClient::StatusSmokeCartridge_e::Ready)
        currentSmokeLoad++;
    if (data.smokeCartridge3 == EffectShowClient::StatusSmokeCartridge_e::Ready)
        currentSmokeLoad++;
    if (data.smokeCartridge4 == EffectShowClient::StatusSmokeCartridge_e::Ready)
        currentSmokeLoad++;
    if (data.smokeCartridge5 == EffectShowClient::StatusSmokeCartridge_e::Ready)
        currentSmokeLoad++;

    return currentSmokeLoad;
}

void OperatingCondition::onOperatingConditionEntityChanged(const EffectShowClient::OperatingConditionEntity& data,
                                                           DataModification modType)
{
    if (modType == DataModification::eRemoved)
        return;

    m_lastState = data;

    if (data.vehicleFeature ==
        EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Explosion24))
    {
        m_ui->ledAftLh->hide();
        m_ui->ledAftRh->hide();
    }
    else if (data.vehicleFeature ==
             EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Explosion48))
    {
        m_ui->ledAftLh->show();
        m_ui->ledAftRh->show();
    }
    bool isExp = data.vehicleFeature !=
                 EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Smoke);
    m_ui->frame->setHidden(!isExp);
    m_ui->lblMagazine->setHidden(!isExp);
    m_ui->lblMag->setHidden(!isExp);
    m_ui->sbMagazine->setHidden(!isExp);
    m_smokeState->setHidden(isExp);

    if (m_safetyConfirmationWidget)
    {
        bool hasNoWarnings = m_safetyConfirmationWidget->onOperatingConditionEntityChanged(data);
        m_ui->pbConfirmReadiness->setEnabled(hasNoWarnings);
    }

    setBatteryVoltage(data.batteryVoltage);

    if (data.vehicleFeature !=
        EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Smoke))
    {
        if (data.vehicleFeature ==
            EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::NotSpecified))
            return;

        int max = data.vehicleFeature ==
                          EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Explosion24)
                      ? 24
                      : 48;
        m_ui->sbMagazine->setMaximum(max);
        m_ui->sbAvailable->setMaximum(255);

        m_ui->ledFwdLh->setStatus(data.firingUnitReadyFwdLh);
        m_ui->ledAftLh->setStatus(data.firingUnitReadyAftLh);
        m_ui->ledFwdRh->setStatus(data.firingUnitReadyFwdRh);
        m_ui->ledAftRh->setStatus(data.firingUnitReadyAftRh);
    }
    else
    {

        m_ui->sbMagazine->setMaximum(5);
        m_ui->sbAvailable->setMaximum(12);
        QVector<QColor> onColor = {
            data.smokeCartridge1 <= EffectShowClient::StatusSmokeCartridge_e::Ready
                ? QColor(0, 255, 0)
                : QColor(255, 255, 0),
            data.smokeCartridge2 <= EffectShowClient::StatusSmokeCartridge_e::Ready
                ? QColor(0, 255, 0)
                : QColor(255, 255, 0),
            data.smokeCartridge3 <= EffectShowClient::StatusSmokeCartridge_e::Ready
                ? QColor(0, 255, 0)
                : QColor(255, 255, 0),
            data.smokeCartridge4 <= EffectShowClient::StatusSmokeCartridge_e::Ready
                ? QColor(0, 255, 0)
                : QColor(255, 255, 0),
            data.smokeCartridge5 <= EffectShowClient::StatusSmokeCartridge_e::Ready
                ? QColor(0, 255, 0)
                : QColor(255, 255, 0)};
        QVector<bool> status = {
            ((data.smokeCartridge1 == EffectShowClient::StatusSmokeCartridge_e::Ready) ||
             (data.smokeCartridge1 == EffectShowClient::StatusSmokeCartridge_e::Smoking)),
            ((data.smokeCartridge2 == EffectShowClient::StatusSmokeCartridge_e::Ready) ||
             (data.smokeCartridge2 == EffectShowClient::StatusSmokeCartridge_e::Smoking)),
            ((data.smokeCartridge3 == EffectShowClient::StatusSmokeCartridge_e::Ready) ||
             (data.smokeCartridge3 == EffectShowClient::StatusSmokeCartridge_e::Smoking)),
            ((data.smokeCartridge4 == EffectShowClient::StatusSmokeCartridge_e::Ready) ||
             (data.smokeCartridge4 == EffectShowClient::StatusSmokeCartridge_e::Smoking)),
            ((data.smokeCartridge5 == EffectShowClient::StatusSmokeCartridge_e::Ready) ||
             (data.smokeCartridge5 == EffectShowClient::StatusSmokeCartridge_e::Smoking))};

        m_smokeState->setSmokeState(status, onColor);
    }

    m_ui->ltsLedWidget->setColor(data.readiness ? QColor(0, 255, 0) : QColor(255, 0, 0));
    m_ui->ltsLedWidget->setStatus(true);
    if (m_ui->lblAva->text().toInt() != data.ammunitionAvailable)
        m_ui->sbAvailable->setValue(data.ammunitionAvailable);
    m_ui->lblAva->setText(QString::number(data.ammunitionAvailable));
    m_ui->lblMag->setText(QString::number(data.ammunitionMagazine));
}

void OperatingCondition::onFiringExplosionEntityChanged(const FiringExplosionEntity& data, DataModification modType)
{
    Q_UNUSED(modType)

    m_safetyConfirmation = data.safetyConfirmation;
    onSafetyConfirmationDisplay();
}

void OperatingCondition::onFiringSmokeEntityChanged(const FiringSmokeEntity& data, DataModification modType)
{
    Q_UNUSED(modType)
    m_safetyConfirmation = data.safetyConfirmation;
    onSafetyConfirmationDisplay();
}

void OperatingCondition::onSafetyConfirmationDisplay()
{
    if (!m_safetyConfirmationWidget)
        return;
    m_safetyConfirmationWidget->setNewSafetyConfirmationDisplay(m_safetyConfirmation);
}

bool OperatingCondition::onSendRevokeReadiness()
{
    bool ret = m_requestHelper->startSingleRequest([this]() {
        EffectShowClient::SendReadinessRequest request;
        request.readiness = false;
        return m_ftc->sendReadinessRequest(request, this);
    });

    return ret;
}

bool OperatingCondition::onSendConfirmReadiness()
{
    bool ret = m_requestHelper->startSingleRequest([this]() {
        EffectShowClient::SendReadinessRequest request;
        request.readiness = true;
        return m_ftc->sendReadinessRequest(request, this);
    });

    return ret;
}

void OperatingCondition::onMeteoNearVehicleChanged(const EffectShowClient::MeteoNearVehicle& data,
                                                   DataModification modType)
{
    if (modType == DataModification::eRemoved)
        return;

    m_meteoTimer->start(m_meteoTimerTimeout);
    m_ui->leTemperature->setText(QString::number(data.temperature, 'f', 2));
    m_ui->leHumidity->setText(QString::number(data.humidity, 'f', 2));
    m_ui->lePressure->setText(QString::number(data.pressure, 'f', 2));
    m_ui->leWindSpeed->setText(QString::number(data.windSpeed, 'f', 2));
    m_ui->leWindDirection->setText(QString::number(data.windDirection, 'f', 2));
    m_ui->leLastUpdate->setText(DTG::toString(QDateTime::currentDateTime()));
}

void OperatingCondition::onMeteoTimeout()
{
    const QLatin1String lit("---");
    m_ui->leTemperature->setText(lit);
    m_ui->leHumidity->setText(lit);
    m_ui->lePressure->setText(lit);
    m_ui->leWindSpeed->setText(lit);
    m_ui->leWindDirection->setText(lit);
    m_ui->leLastUpdate->clear();
}

bool OperatingCondition::onSendAmmunition()
{
    if (m_ui->sbMagazine->value() > m_ui->sbAvailable->value())
    {
        new LtsWidgets::LtsMessageDialogNew(
            this, tr("The value for Magazine must not be higher than the value for Available."));
        QPalette* palette = new QPalette();
        palette->setColor(QPalette::Window, Qt::red);
        m_ui->sbMagazine->setPalette(*palette);
        return false;
    }

    m_ui->sbMagazine->setPalette(QApplication::palette(m_ui->sbMagazine));

    return m_requestHelper->startSingleRequest([this]() {
        EffectShowClient::SendAmmunitionRequest request;
        const OperatingConditionEntity& condition = m_dtc->operatingConditionEntity();
        if (condition.vehicleFeature ==
            EffectShowManagement::Feature_e(EffectShowManagement::Feature_e::Smoke))
            request.ammunitionMagazine = getSmokeCount();
        else
            request.ammunitionMagazine = m_ui->sbMagazine->value();

        request.ammunitionAvailable = m_ui->sbAvailable->value();

        return m_ftc->sendAmmunitionRequest(request, this);
    });
}

void OperatingCondition::setBatteryVoltageConstraints(double redBoundary, double yellowBoundary, double greenMaximum)
{
    m_batteryVoltage.redBoundary = redBoundary;
    m_batteryVoltage.yellowBoundary = yellowBoundary;
    m_batteryVoltage.greenMaximum = greenMaximum;

    QRect greenRect = m_ui->frameGreenVoltage->geometry();
    double greenWidth = (double)greenRect.width();
    QRect setVal = greenRect;

    setVal.setWidth((int)(greenWidth * redBoundary / greenMaximum));
    m_ui->frameRedVoltage->setGeometry(setVal);

    setVal.setWidth((int)(greenWidth * yellowBoundary / greenMaximum));
    m_ui->frameYellowVoltage->setGeometry(setVal);
}

void OperatingCondition::setBatteryVoltage(double batteryVoltage)
{

    if (batteryVoltage < m_batteryVoltage.redBoundary)
        m_ui->leVoltage->setStyleSheet(QLatin1String("background-color: rgb(255, 0, 0)"));
    else if (batteryVoltage < m_batteryVoltage.yellowBoundary)
        m_ui->leVoltage->setStyleSheet(QLatin1String("background-color: rgb(255, 255, 0)"));
    else
        m_ui->leVoltage->setStyleSheet(QLatin1String("background-color: rgb(0, 255, 0)"));

    QRect barRect = m_ui->frameBarVoltage->geometry();
    barRect.setWidth((int)(m_batteryVoltage.maximumValue * batteryVoltage / m_batteryVoltage.greenMaximum));
    m_ui->frameBarVoltage->setGeometry(barRect);

    m_ui->leVoltage->setText(QString::number(batteryVoltage, 'f', 1));
}

} // namespace EffectShowClient