/**
  * @RDE_HEADER@
  * MeteoDataManagement - Static Meteo Data Edit Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-10-17
  */

#include "esc_firing_explosion.h"
#include "ui_esc_firing_explosion.h"
#include "esc_safety_confirmation_widget.h"
#include "esc_order_edit.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_logger(getLogger("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_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);

  // Set a consistent font size for the buttons
  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);

  // display data
  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")); // todo only "Firing"
}
//-----------------------------------------------------------------------------
void FiringExplosion::onFiringExplosionEntityChanged(const EffectShowClient::FiringExplosionEntity &data, DataModification modType)
{
  if (modType == DataModification::eRemoved)
    return; // freeze of indication

  m_idOrder = data.idOrder();
  m_idEffectShow = data.idEffectShow();
  //  if (m_idOrder > 0) \\keep for now
  //    m_ui->pbApply->setEnabled(data.fireEnabled() && data.safetyConfirmation() == EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed);

  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());

  // enable carried out
  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().is_set() ? (1000 + data.firingClearanceTime().get() - m_session->partitionTime()) : 0;
  m_endOfFiringClearanceCountDown = data.endOfFiringClearanceTime().is_set() ? (1000 + data.endOfFiringClearanceTime().get() - m_session->partitionTime()) : 0;

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

  //enable fire button if show is active, the fire untis are ready and in clearnca time
  m_ui->pbFire->setEnabled(pbActiv && fireUnitsActive && m_isClearance);
  // enale Interrupt
  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);
    // rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Abort);
    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; // not all inputs done

  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; // not all inputs done

  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_def::Execution;
      break;
    case EffectShowStatus_e::CarriedOut:
      oc = EffectShowManagement::OrderConfirmation_e_def::OrderCarriedOut;
      break;
    case EffectShowStatus_e::Interrupt:
      oc = EffectShowManagement::OrderConfirmation_e_def::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