/**
  * @RDE_HEADER@
  * HMI Plugin for AlarmManagement (Interface for access from other Plugins)
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Steve Kemayou, SLSE, 2023-05-26
  */

#include "alm_emergency_call_dialog.h"
#include "ui_alm_emergency_call_dialog.h"
#include "AlarmManagement/Gui/EmergencyCalls/alm_emergency_call_model.h"
#include <Services/AlarmManagement/alm_operator_rights.h>
#include <LtsSession/lts_session_data.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <ExerciseManagement/exm_data_plugin_interface.h>

#include <QDateTime>
#include <QLabel>
#include <QLineEdit>


namespace AlarmManagement
{


EmergencyCallDialog::EmergencyCallDialog(QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_session(nullptr)
  , m_ui(new Ui::EmergencyCallDialog)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_logger(getLogger("EmergencyCallDialog"))
{
  m_ui->setupUi(this);
}


void EmergencyCallDialog::retranslate()
{
  translate(m_ui, tr("Emergency Call "));
}

bool EmergencyCallDialog::init(const std::shared_ptr<AlarmManagement::Interface::Ftc> &ftc,
                               const std::shared_ptr<AlarmManagement::Interface::Dtc> &dtc,
                               const std::shared_ptr<SituationMap::ForeignGuiInterface> &sitMapGuiIfc,
                               const std::shared_ptr<OperatorManagement::Interface::Dtc> &opmDtc,
                               LtsSession::LtsSession *session)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START ";
  if (!ftc || !dtc || !session){
    ERROR_LOG(m_logger)<<" init Emergency call dialog failed !!";
    return false;
  }

  m_ftc = ftc;
  m_dtc = dtc;
  m_opmDtc = opmDtc;
  m_session = session;
  m_dtc->enableAlmEmergencyCall();
  m_ftc->enableEmergencyCallAcknowledge();
  m_sitMapGuiIfc = sitMapGuiIfc;


  delete m_model;
  m_model = new AlarmManagement::EmergencyCallModel(this);
  m_model->initModel(m_dtc, opmDtc);

  m_proxyModel = new EmergencyCallProxyModel(this);
  m_proxyModel->setSourceModel(m_model);
  m_ui->emergencyCallView->setModel(m_proxyModel);
  m_proxyModel->hideByExerciseStopped(m_session->exerciseState()!=LtsWidgets::ExcState::eStarted &&
                                    m_session->exerciseState() != LtsWidgets::ExcState::ePaused);
  m_ui->emergencyCallView->setSortingEnabled(true);
  m_ui->emergencyCallView->resizeSection(EmergencyCallModel::Columns::SAMPLE_TIME, 300);
  m_ui->emergencyCallView->resizeSection(EmergencyCallModel::Columns::POSITION, 300);
  m_ui->emergencyCallView->resizeSection(EmergencyCallModel::Columns::DELETED_TIMESTAMP, 300);

  m_buttonBox->getButton(LtsWidgets::DialogButton::Edit)->setText(tr("Acknowledge"));
  m_buttonBox->getButton(LtsWidgets::DialogButton::Show)->setText(tr("Center"));
  m_buttonBox->getButton(LtsWidgets::DialogButton::Show)->setIcon(QIcon(QStringLiteral("icon:center_to_object.svg")));

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &EmergencyCallDialog::onEditBtCliked);

  const bool &hasOperatorRightEmergencyCall = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::EmergencyCall);
  m_buttonBox->getButton(LtsWidgets::DialogButton::Edit)->setVisible(hasOperatorRightEmergencyCall);

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Show, this, &EmergencyCallDialog::onFindEmergencyOnMap);


  //cbx show expired
  QCheckBox *cbExpired = new QCheckBox(tr("Show expired"), m_ui->emergencyCallView);
  cbExpired->setProperty("const", true);
  m_ui->emergencyCallView->setCustomWidget(cbExpired);
  connect(cbExpired, &QCheckBox::toggled, this, &EmergencyCallDialog::onSetShowExpired);

  connect(m_ui->emergencyCallView, &LtsDataView::LtsDataView::signalSelectionChanged, this, &EmergencyCallDialog::enaDisa);
  connect(m_ui->emergencyCallView, &LtsDataView::LtsDataView::doubleClicked, this, &EmergencyCallDialog::onEmergencyIndexDoubleClicked);
  enaDisa();

#ifndef LTS_DEBUG
  m_ui->emergencyCallView->hideColumn(EmergencyCallModel::ID);
  m_ui->emergencyCallView->hideColumn(EmergencyCallModel::SAMPLE_TIME);
  m_ui->emergencyCallView->hideColumn(EmergencyCallModel::NAME);
  m_ui->emergencyCallView->hideColumn(EmergencyCallModel::EXPIRED);
#endif

  INFO_LOG(m_logger) << "EmergencyCallDialog::init done";
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
  return true;
}

/*!
 * \brief EmergencyCallDialog::enaDisa
 * enable 'acknowledge' button when selected has expired= false
 */
void EmergencyCallDialog::enaDisa()
{
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, false);
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Show, false);

  const AlmEmergencyCall &sos = getSelectedSOS();
  if (sos.id() <= 0)
    return;

  if (!sos.expired())
    m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, true);

  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Show, true);
}

/*!
 * \brief EmergencyCallDialog::getSelectedSOS
 * \return
 */
AlmEmergencyCall EmergencyCallDialog::getSelectedSOS()
{
  QModelIndexList indexList = m_ui->emergencyCallView->selectedRows();
  if (indexList.isEmpty())
    return {};

  return m_model->getRowData(indexList.front().row());
}


/*!
 * \brief EmergencyCallDialog::setAcknowledgeUi
 */
void EmergencyCallDialog::setAcknowledgeUi()
{
  LtsWidgets::LtsFramelessDialog *popup = new LtsWidgets::LtsFramelessDialog(this, LtsWidgets::Behaviour::Popup);
  LtsWidgets::LtsDialogButtonBox *btnBox = new LtsWidgets::LtsDialogButtonBox(popup);
  btnBox->getButton(LtsWidgets::DialogButton::Ok)->setEnabled(false);
  QVBoxLayout *lay = new QVBoxLayout(popup);
  QLineEdit   *le  = new QLineEdit(popup);
  QLabel      *lblTxt = new QLabel(tr("Acknowledged by:"), popup);

  connect(btnBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, popup, &LtsWidgets::LtsFramelessDialog::accept);

  //check if total text count > than textMinSize
  connect(le, &QLineEdit::textChanged, this, [btnBox](const QString &text)
  {
    const int textMinSize = 5;
    btnBox->getButton(LtsWidgets::DialogButton::Ok)->setEnabled(text.trimmed().size() >= textMinSize);
  });
  // on ok clicked acknowledge emergency
  connect(btnBox->getButton(LtsWidgets::DialogButton::Ok), &QPushButton::clicked, this, [this, le, popup]()
  {
    sendAcknowledgeEmergency(le->text());
    popup->accept();
  });

  lay->addWidget(lblTxt);
  lay->addWidget(le);
  lay->addWidget(btnBox);
  popup->setLayout(lay);
  popup->setMinimumWidth(350);
  popup->show();
  le->setFocus();
}

/*!
 * \brief EmergencyCallDialog::onEditBtCliked
 */
void EmergencyCallDialog::onEditBtCliked()
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  const AlmEmergencyCall &sos = getSelectedSOS();
  if (sos.id() <= 0)
    return;
  setAcknowledgeUi();

  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}


/*!
 * \brief EmergencyCallDialog::setShowExpire
 */
void EmergencyCallDialog::onSetShowExpired(bool show)
{
  if (m_proxyModel)
    m_proxyModel->setShowExpired(show);

  // initialisation of class to display expired sos calls only if needed:
  if (!m_updateSOSGuard)
    m_updateSOSGuard = QSharedPointer<UpdateSOSGuard>(new UpdateSOSGuard(m_sitMapGuiIfc));
  m_updateSOSGuard->showExpiredSOS(show);
}

/*!
 * \brief EmergencyCallDialog::onFindEmergencyOnMap
 * \param position
 */
void EmergencyCallDialog::onFindEmergencyOnMap()
{
  if (!m_sitMapGuiIfc)
    return;

  const AlmEmergencyCall &sos = getSelectedSOS();
  if (sos.id() <= 0)
    return;

  m_sitMapGuiIfc->setCenterPoint(QPointF(sos.position().lon(), sos.position().lat()));
}

/*!
 * \brief EmergencyCallDialog::onEmergencyIndexDoubleClicked
 * \param index
 */
void EmergencyCallDialog::onEmergencyIndexDoubleClicked(const QModelIndex &index)
{
  Q_UNUSED(index)
  emit openInfoDlg(getSelectedSOS().id());
}

/*!
 * \brief EmergencyCallDialog::onRemove
 * this method is use to acknowledge/quit the emergency call request
 */
void EmergencyCallDialog::sendAcknowledgeEmergency(const QString &comment)
{
  TRACE_LOG(m_logger) << LOGFUNCTION << " START";

  const AlmEmergencyCall &sos = getSelectedSOS();
  if (sos.id() <= 0 || sos.expired())
    return;

  EmergencyCallAcknowledgeRequest request;
  request.id(sos.id());
  request.issi(sos.issi());
  request.name(sos.name());
  request.timestamp(QDateTime::currentMSecsSinceEpoch());
  request.incomingTime(sos.incomingTime());
  request.expired(true);
  request.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
  request.comment(comment.toStdString());
  m_requestHelper->startSingleRequest([this, request]()
  {
    return m_ftc->emergencyCallAcknowledgeRequest(request, this);
  });

  enaDisa();
  TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}

void EmergencyCallDialog::tableColumnOrganiserSetting()
{
  //LtsColumnOrganiser
  m_ui->emergencyCallView->setColumnsOrganiserEnabled(identifier(), true);
}

EmergencyCallDialog::~EmergencyCallDialog()
{
  // m_updateSOSGuard will be destroyed via QSharedPointer,
  // which hold it´s own shared_ptr/sitMapGuiIfc;
  // Therefore showExpiredEmergencyCalls(false) will be called
  delete m_ui;
}


}// namespace AlarmManagement