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

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

#include "esc_order_edit.h"
#include "esc_safety_confirmation_widget.h"
#include "esc_smoke_state.h"
#include "ui_esc_firing_smoke.h"

#include <QtCore/QString>

namespace EffectShowClient
{

FiringSmoke::FiringSmoke(QWidget* parent)
    : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_timer(new QTimer(this)),
      m_meteoTimer(new QTimer(this)), m_dtc(nullptr), m_ftc(nullptr), m_session(nullptr), m_smokeState(nullptr),
      m_safetyConfirmationWidget(nullptr), m_ui(new Ui::FiringSmoke),
      m_requestHelper(new LtsUtils::RequestHelper(this)), m_idOrder(0), m_firingClearanceCountDown(0),
      m_endOfFiringClearanceCountDown(0)
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
{
    DEBUG_LOG(m_logger) << "FiringSmoke::FiringSmoke()";

    m_ui->setupUi(this);
    m_smokeState = new SmokeState(this);
    m_ui->layoutSmokeState->addWidget(m_smokeState);

    m_meteoTimer->setInterval(15 * 60 * 1000);
    connect(m_timer, &QTimer::timeout, this, &FiringSmoke::onFiringClearanceCountDown);
    connect(m_meteoTimer, &QTimer::timeout, this, &FiringSmoke::onMeteoTimerTimeout);

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

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

bool FiringSmoke::init(const std::shared_ptr<EffectShowClient::Interface::Dtc>& dtc,
                       const std::shared_ptr<EffectShowClient::Interface::Ftc>& ftc, LtsSession::LtsSession* session,
                       bool freeForm)
{
    DEBUG_LOG(m_logger) << "FiringSmoke::init()";

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

    m_dtc = dtc;
    m_ftc = ftc;
    m_session = session;

    m_safetyConfirmationWidget = new EffectShowClient::SafetyConfirmationWidget(this);
    m_safetyConfirmationWidget->init(m_ftc);

    m_ui->hz->insertWidget(0, m_safetyConfirmationWidget);

    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::firingSmokeEntityChanged, this,
            &FiringSmoke::onFiringSmokeEntityChanged);
    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::operatingConditionEntityChanged, this,
            &FiringSmoke::onOperatingConditionEntityChanged);
    connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::meteoNearVehicleChanged, this,
            &FiringSmoke::onMeteoDataChanged);

    const EffectShowClient::MeteoNearVehicle dat = m_dtc.get()->meteoNearVehicle();
    if (dat.windDirection > 0)
        onMeteoDataChanged(dat, DataModification());
    else
        onMeteoTimerTimeout();

    if (!freeForm)
        onFiringSmokeEntityChanged(m_dtc->firingSmokeEntity(), DataModification::eAdded);

    m_buttonBox->connectButton(LtsWidgets::DialogButton::Yes, this, &FiringSmoke::onCarriedOut);
    m_buttonBox->setText(LtsWidgets::DialogButton::Yes, tr("Carried Out"));
    m_buttonBox->connectButton(LtsWidgets::DialogButton::No, this, &FiringSmoke::onAbort);
    m_buttonBox->setText(LtsWidgets::DialogButton::No, tr("Abort"));

    return true;
}

void FiringSmoke::retranslate()
{
    translate(m_ui, tr("Firing Smoke"));
}

void FiringSmoke::onFiringSmokeEntityChanged(const EffectShowClient::FiringSmokeEntity& data, DataModification modType)
{
    if (modType == DataModification::eRemoved)
        return;

    m_idOrder = data.idOrder;

    if (data.idEffectShow > 0)
    {
        const EffectShowClient::Order& order = m_dtc->order(data.idOrder);
        m_ui->leEffectShow->setText(QString::fromStdString(order.info));
        m_ui->lblLengthOfFogZone->setText(
            tr("%1m x %2m").arg(QString::number(order.areaWidth), QString::number(order.areaDepth)));
        m_ui->lblDirectionOfFogZone->setText(QString::number(order.areaRotation));
    }
    else
    {
        m_ui->leEffectShow->setText(QString());
        m_ui->lblLengthOfFogZone->setText(tr("0m x 0m"));
        m_ui->lblDirectionOfFogZone->setText(QString::number(0));
    }

    m_firingClearanceCountDown = data.firingClearanceTime.has_value()
                                     ? (1000 + data.firingClearanceTime.get() - m_session->partitionTime())
                                     : 0;
    m_endOfFiringClearanceCountDown = data.endOfFiringClearanceTime.has_value()
                                          ? (1000 + data.endOfFiringClearanceTime.get() - m_session->partitionTime())
                                          : 0;
    m_timer->stop();
    onFiringClearanceCountDown();

    m_safetyConfirmation = data.safetyConfirmation;
    onSafetyConfirmationDisplay();

    m_oldEntity = data;
}

void FiringSmoke::onOperatingConditionEntityChanged(const OperatingConditionEntity& data, DataModification modType)
{
    Q_UNUSED(modType)

    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_safetyConfirmationWidget->onOperatingConditionEntityChanged(data);
}

void FiringSmoke::onMeteoDataChanged(const MeteoNearVehicle& data, DataModification modType)
{

    Q_UNUSED(modType)
    m_meteoTimer->start(),
        m_ui->lblWeather->setText(
            tr("Speed [m/s]: %1 | Direction [°]: %2").arg(data.windSpeed).arg(data.windDirection));
}

void FiringSmoke::onMeteoTimerTimeout()
{
    m_ui->lblWeather->setText(tr("Speed [m/s]: --- | Direction [°]: ---"));
}

void FiringSmoke::onApply()
{
    if (!statusChangedForManuallyEffectShow(EffectShowStatus_e::Apply))
        ERROR_LOG(m_logger) << "Firing Smoke Apply failed";
}

void FiringSmoke::onAbort()
{
    if (m_idOrder > 0)
    {
        OrderEdit* edit = new OrderEdit(m_dtc->order(m_idOrder), false, this);
        edit->init(m_ftc, EffectShowManagement::OrderConfirmation_e::Abort);
        addDialog(edit, menuGroup(), QLatin1String("escOrder"), LtsWidgets::LayoutArea::eDialogTab);
        return;
    }
    else
        statusChangedForManuallyEffectShow(EffectShowStatus_e::Abort);
}

void FiringSmoke::onCarriedOut()
{
    if (m_idOrder > 0)
    {
        OrderEdit* edit = new OrderEdit(m_dtc->order(m_idOrder), false, this);
        edit->init(m_ftc, EffectShowManagement::OrderConfirmation_e::OrderCarriedOut);
        addDialog(edit, menuGroup(), QLatin1String("escOrder"), LtsWidgets::LayoutArea::eDialogTab);
        return;
    }
    else
        statusChangedForManuallyEffectShow(EffectShowStatus_e::CarriedOut);
}

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

void FiringSmoke::onFiringClearanceCountDown()
{
    if (m_timer->isActive())
    {
        m_firingClearanceCountDown -= 1000;
        m_endOfFiringClearanceCountDown -= 1000;
    }

    if (m_firingClearanceCountDown > 0)
        m_ui->leFiringClearanceIn->setText(OrderModel::timeOfDayString(m_firingClearanceCountDown / 1000));
    else
        m_ui->leFiringClearanceIn->setText(OrderModel::timeOfDayString(0));

    if (m_endOfFiringClearanceCountDown > 0)
        m_ui->leEndOfFiringClearanceIn->setText(OrderModel::timeOfDayString(m_endOfFiringClearanceCountDown / 1000));
    else
        m_ui->leEndOfFiringClearanceIn->setText(OrderModel::timeOfDayString(0));

    if ((m_firingClearanceCountDown > 0) || (m_endOfFiringClearanceCountDown > 0))
        m_timer->start(1000);
}

bool FiringSmoke::statusChangedForManuallyEffectShow(EffectShowStatus_e status)
{
    m_uiRequirements->clear();

    return m_requestHelper->startSingleRequest([this, status]() {
        EffectShowClient::ManuallySmokeRequest request;
        request.directionOfFogZone = 0;
        request.lengthOfFogZone = 0;
        request.pbAbort = status == EffectShowStatus_e::Abort;
        request.pbCarriedOut = status == EffectShowStatus_e::CarriedOut;
        return m_ftc->manuallySmokeRequest(request, this);
    });
}

bool FiringSmoke::statusChangedForOrderedEffectShow(EffectShowStatus_e status)
{
    m_uiRequirements->clear();

    if (!m_uiRequirements->checkRequirements(this))
        return true;

    return m_requestHelper->startSingleRequest([this, status]() {
        OrderModifyRequest orderModifyRequest;

        orderModifyRequest.id = m_idOrder;
        EffectShowManagement::OrderConfirmation_e oc;
        switch (status)
        {
            case EffectShowStatus_e::Abort:
                oc = EffectShowManagement::OrderConfirmation_e::Abort;
                break;
            case EffectShowStatus_e::CarriedOut:
                oc = EffectShowManagement::OrderConfirmation_e::OrderCarriedOut;
                break;
            default:
                DEBUG_LOG(m_logger) << "FiringSmoke::statusChangedForOrderedEffectShow switch is defaulting, should "
                                       "not happen I guess...";
                break;
        }
        orderModifyRequest.orderConfirmation = oc;
        orderModifyRequest.answerText = QString().toStdString();

        return m_ftc->orderModifyRequest(orderModifyRequest, this);
    });
}

} // namespace EffectShowClient