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

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

#include "esc_order_edit.h"
#include "esc_safety_confirmation_widget.h"
#include "ui_esc_firing_explosion.h"

namespace EffectShowClient
{

FiringExplosion::FiringExplosion(QWidget* parent)
    : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_timer(new QTimer(this)),
      m_dtc(nullptr), m_ftc(nullptr), m_session(nullptr), m_safetyConfirmationWidget(nullptr),
      m_ui(new Ui::FiringExplosion), m_requestHelper(new LtsUtils::RequestHelper(this)), m_idOrder(0),
      m_idEffectShow(0), m_shotsAvail(0), m_isClearance(true), m_firingClearanceCountDown(0),
      m_endOfFiringClearanceCountDown(0)
, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
{
    m_ui->setupUi(this);
    m_ui->pbFire->setEnabled(false);
    connect(m_ui->pbApply, &QPushButton::clicked, this, &FiringExplosion::onApply);
    connect(m_ui->pbFire, &QPushButton::clicked, this, &FiringExplosion::onFire);
    connect(m_ui->pbInterrupt, &QPushButton::clicked, this, &FiringExplosion::onInterrupt);
    connect(m_timer, &QTimer::timeout, this, &FiringExplosion::onFiringClearanceCountDown);

    QFont pbFont = m_ui->pbApply->font();
#ifdef TABLET_MODE
    pbFont.setPointSizeF(pbFont.pointSizeF() * 1.5);
#endif
    m_ui->pbApply->setFont(pbFont);
    m_ui->pbFire->setFont(pbFont);
    m_ui->pbInterrupt->setFont(pbFont);

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

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

bool FiringExplosion::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) << "FiringExplosion::init()";

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

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

    m_safetyConfirmationWidget = new SafetyConfirmationWidget(this);
    if (!m_safetyConfirmationWidget->init(m_ftc))
    {
        ERROR_LOG(m_logger) << "Can't create SafetiConfirmationWidget";
        return false;
    }
    m_ui->mainVertLayout->insertWidget(3, m_safetyConfirmationWidget);

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

    if (!freeForm)
        onFiringExplosionEntityChanged(m_dtc->firingExplosionEntity(), DataModification::eAdded);

    m_buttonBox->connectButton(LtsWidgets::DialogButton::No, this, &FiringExplosion::onAbort);
    m_buttonBox->getButton(LtsWidgets::DialogButton::No)->setText(tr("Abort"));

    m_buttonBox->connectButton(LtsWidgets::DialogButton::Yes, this, &FiringExplosion::onCarriedOut);
    m_buttonBox->getButton(LtsWidgets::DialogButton::Yes)->setText(tr("Carried Out"));

    m_ui->sbDuration->setMinimum(5);
    return true;
}

void FiringExplosion::retranslate()
{
    translate(m_ui, tr("Firing Explosive"));
}

void FiringExplosion::onFiringExplosionEntityChanged(const EffectShowClient::FiringExplosionEntity& data,
                                                     DataModification modType)
{
    if (modType == DataModification::eRemoved)
        return;

    m_idOrder = data.idOrder;
    m_idEffectShow = data.idEffectShow;

    m_ui->pbApply->setEnabled(!data.isActive);

    OperatingConditionEntity opcon = m_dtc->operatingConditionEntity();
    bool fireUnitsActive = opcon.firingUnitReadyAftLh || opcon.firingUnitReadyAftRh ||
                           opcon.firingUnitReadyFwdLh || opcon.firingUnitReadyFwdRh;
    bool pbActiv =
        (data.fireEnabled && data.safetyConfirmation != EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed);

    if (!fireUnitsActive && m_safetyConfirmationWidget)
        m_safetyConfirmationWidget->setMessage(tr("Waiting for ready firing unit"));
    else
        m_safetyConfirmationWidget->setMessage(QString());

    m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Yes, data.carriedOutEnabled);

    if (m_oldEntity.numberOfVolley != data.numberOfVolley)
        m_ui->sbNumberOfVolley->setValue(data.numberOfVolley);
    if (m_oldEntity.numberOfShot != data.numberOfShot)
        m_ui->sbNumberOfShot->setValue(data.numberOfShot);
    if (m_oldEntity.duration != data.duration)
        m_ui->sbDuration->setValue(data.duration / 1000);

    if (m_idEffectShow > 0)
    {
        QString textStr = QString::fromStdString(m_dtc->order(m_idEffectShow).info);
        m_ui->leEffectShow->setText(textStr);
    }
    else
        m_ui->leEffectShow->setText(QString());

    m_timer->stop();

    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;

    onFiringClearanceCountDown();
    if (data.idOrder == 0 || (!data.firingClearanceTime.has_value() && data.duration == 0))
        m_isClearance = true;
    else
        m_isClearance = (m_firingClearanceCountDown <= 0 && m_endOfFiringClearanceCountDown > 0);

    m_ui->pbFire->setEnabled(pbActiv && fireUnitsActive && m_isClearance);

    bool isInterruptEnabled =
        !data.carriedOutEnabled && !m_ui->pbFire->isEnabled() && data.isActive && m_isClearance;
    m_ui->pbInterrupt->setEnabled(isInterruptEnabled);

    m_ui->leRemainingShots->setText(data.remainingShots > 0 ? QString::number(data.remainingShots)
                                                              : QString::number(0));
    m_ui->leRemainingTime->setText(QString::number(data.remainingTime / 1000));
    m_ui->leRemainingVolley->setText(data.remainingVolleys > 0 ? QString::number(data.remainingVolleys)
                                                                 : QString::number(0));
    m_safetyConfirmation = data.safetyConfirmation;
    onSafetyConfirmationDisplay();

    m_oldEntity = data;
}

void FiringExplosion::onOperatingConditionEntityChanged(const OperatingConditionEntity& data, DataModification modType)
{
    Q_UNUSED(modType)
    if (m_safetyConfirmationWidget)
        m_safetyConfirmationWidget->onOperatingConditionEntityChanged(data);
    m_shotsAvail = data.ammunitionMagazine;
    m_ui->lblShotsAvail->setText(QString::number(m_shotsAvail));
}

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

void FiringExplosion::onFire()
{
    bool rc;
    if (m_idOrder > 0)
        rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Fire);
    else
        rc = statusChangedForManuallyEffectShow(EffectShowStatus_e::Fire);

    if (!rc)
        ERROR_LOG(m_logger) << "Firing Explosion Order Execution failed";
}

void FiringExplosion::onInterrupt()
{
    bool rc;
    if (m_idOrder > 0)
        rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Interrupt);
    else
        rc = statusChangedForManuallyEffectShow(EffectShowStatus_e::Interrupt);

    if (!rc)
        ERROR_LOG(m_logger) << "Firing Explosion Order Execution failed";
}

void FiringExplosion::onAbort()
{
    if (m_idOrder > 0)
    {
        OrderEdit* edit = new OrderEdit(m_dtc->order(m_idEffectShow), 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 FiringExplosion::onCarriedOut()
{
    if (m_idOrder > 0)
    {
        OrderEdit* edit = new OrderEdit(m_dtc->order(m_idEffectShow), false, this);
        edit->init(m_ftc, EffectShowManagement::OrderConfirmation_e::OrderCarriedOut);
        addDialog(edit, menuGroup(), QLatin1String("escOrder"), LtsWidgets::LayoutArea::eDialogTab);
    }
    else
        statusChangedForManuallyEffectShow(EffectShowStatus_e::CarriedOut);
}

void FiringExplosion::onSafetyConfirmationDisplay()
{
    if (m_safetyConfirmationWidget)
        m_safetyConfirmationWidget->setNewSafetyConfirmationDisplay(m_safetyConfirmation);
}

void FiringExplosion::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);

    m_isClearance = (m_firingClearanceCountDown <= 0 && m_endOfFiringClearanceCountDown > 0);
}

bool FiringExplosion::statusChangedForManuallyEffectShow(EffectShowStatus_e status)
{
    m_uiRequirements->clear();
    if (status == EffectShowStatus_e::Apply)
    {
        m_uiRequirements->addRequirement(
            {m_ui->lbShotsAvail, [this]() { return !(m_shotsAvail < m_ui->sbNumberOfShot->value()); }});
        m_uiRequirements->addRequirement({m_ui->lblNumberOfVolley, [this]() {
                                              return !(m_ui->sbNumberOfShot->value() < m_ui->sbNumberOfVolley->value());
                                          }});
        m_uiRequirements->addRequirement(
            {m_ui->lblDuration, [this]() {
                 return !(m_ui->sbDuration->value() * 1000 <
                          ((m_ui->sbNumberOfShot->value() * 1000) + (m_ui->sbNumberOfVolley->value() * 2000)));
             }});
    }

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

    return m_requestHelper->startSingleRequest([this, status]() {
        EffectShowClient::ManuallyExplosionRequest request;
        if (status == EffectShowStatus_e::Interrupt)
        {
            const EffectShowClient::FiringExplosionEntity manEx = m_dtc->firingExplosionEntity();

            request.numberOfVolley = manEx.remainingVolleys;
            request.numberOfShot = manEx.remainingShots;
            request.duration = manEx.remainingTime;
        }
        else
        {
            request.numberOfVolley = m_ui->sbNumberOfVolley->value();
            request.numberOfShot = m_ui->sbNumberOfShot->value();
            request.duration = m_ui->sbDuration->value() * 1000;
        }
        request.pbFire = status == EffectShowStatus_e::Fire;
        request.pbAbort = status == EffectShowStatus_e::Abort;
        request.pbInterrupt = status == EffectShowStatus_e::Interrupt;

        request.pbCarriedOut = status == EffectShowStatus_e::CarriedOut || status == EffectShowStatus_e::Abort;

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

bool FiringExplosion::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_idEffectShow;
        EffectShowManagement::OrderConfirmation_e oc;
        switch (status)
        {
            case EffectShowStatus_e::Fire:
                oc = EffectShowManagement::OrderConfirmation_e::Execution;
                break;
            case EffectShowStatus_e::CarriedOut:
                oc = EffectShowManagement::OrderConfirmation_e::OrderCarriedOut;
                break;
            case EffectShowStatus_e::Interrupt:
                oc = EffectShowManagement::OrderConfirmation_e::InterruptExecution;
                break;
            default:
                DEBUG_LOG(m_logger) << "FiringExplosion::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