/**
  * @RDE_HEADER@
  * SetSanitationDialog - Send a Sanitation telegram in TAB
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Patric Karwat - 2020-06-20
*/

#include "participant_set_sanitation_dialog.h"
#include "ui_participant_set_sanitation_dialog.h"
#include <ProjectDataManagement/pdm_translation.h>
#include <ParticipantManagement/ppm_translation.h>
#include <ngltranslator/ngltranslator.h>
#include <QSpacerItem>
#include <LtsUtilsCore/dds_vector.h>

namespace ParticipantManagement
{

ParticipantSetSanitationDialog::ParticipantSetSanitationDialog(int participantId, QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_participantId(participantId)
  , m_ui(new Ui::ParticipantSetSanitationDialog)
  , m_logger(getLogger("ParticipantSetSanitationDialog"))
{
  m_ui->setupUi(this);
  m_uiRequirements->addRequirement({ m_ui->lbl, [this]()
                                     {
                                       bool k = false;
                                       int val = m_ui->cbQualification->currentData().toInt(&k);
                                       if (!val)
                                         return false;
                                       return (val > 0);
                                     }
                                   });
}

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

void ParticipantSetSanitationDialog::retranslate()
{
  QString id;
  if (m_eqId > 0)
    id = QString::number(m_eqId);

  translate(m_ui, tr("Medic Treatment: %1").arg((id)));
}


bool ParticipantSetSanitationDialog::init(LtsSession::LtsSession *session, const std::shared_ptr<Interface::Dtc> &dtc, const std::shared_ptr<Interface::Ftc> &ftc,
                                          const std::shared_ptr<ProjectDataManagement::Interface::Dtc> &dtcPdm)
{
  if (!session || !dtc || !ftc)
    return false;

  m_session = session;
  m_dtc = dtc;
  m_ftc = ftc;
  m_dtcPdm = dtcPdm;
  dtcPdm->enableSanitationProcedure(true);
  dtcPdm->waitForHistoricalDataSanitationProcedure(2000);

  const Participant participant = m_dtc->participant(m_participantId);
  if (participant.equipmentNumber().is_set())
    m_eqId = participant.equipmentNumber().get();

  fillCb();
  connect(m_ui->cbQualification, qOverload<int>(&QComboBox::currentIndexChanged), this, &ParticipantSetSanitationDialog::onQualificationChanged);
  return true;
}

void ParticipantSetSanitationDialog::onQualificationChanged()
{
  int qualification = m_ui->cbQualification->currentData().toInt();
  for  (auto *cbx : m_procedures)
  {
    cbx->setEnabled((cbx->property("qualification").toInt() <= qualification));
    if (!cbx->isEnabled() && cbx->isChecked())
      cbx->setChecked(false);
  }
}

void ParticipantSetSanitationDialog::fillCb()
{
  m_ui->cbQualification->blockSignals(true);

  m_ui->cbQualification->clear();
  //m_ui->cbQualification->addItem(ParticipantManagement::toString(Qualification::NotAssigned), -1);
  m_ui->cbQualification->addItem(ParticipantManagement::toString(Qualification::FAA), 1);
  m_ui->cbQualification->addItem(ParticipantManagement::toString(Qualification::FAB), 2);
  m_ui->cbQualification->addItem(ParticipantManagement::toString(Qualification::SANPers), 3);

  m_procedures.clear();
  //now get data from Dtc
  const auto procs = m_dtcPdm->sanitationProcedures();

  for (const auto &proc : procs)
  {
    QGroupBox *box = getGroupBox(proc.type());
    if (!box)
      continue;
    QCheckBox *cbx = new QCheckBox(this);
    //cbx->setText(isGerman ? QString::fromStdString(proc.shortDE()) : QString::fromStdString(proc.shortEN()));
    cbx->setText(ProjectDataManagement::trSanitationProcedureName(proc.name()));
    cbx->setProperty("dataCode",proc.dataCode());
    cbx->setProperty("qualification",proc.minimumQualification());
    box->layout()->addWidget(cbx);
    m_procedures.append(cbx);
  }

  QSpacerItem *item ;
  if(m_ui->gbA && m_ui->gbA->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbA->layout()->addItem(item);
  }
  if(m_ui->gbB && m_ui->gbB->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbB->layout()->addItem(item);
  }
  if(m_ui->gbC && m_ui->gbC->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbC->layout()->addItem(item);
  }
  if(m_ui->gbD && m_ui->gbD->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbD->layout()->addItem(item);
  }
  if(m_ui->gbE && m_ui->gbE->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbE->layout()->addItem(item);
  }
  if(m_ui->gbM && m_ui->gbM->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbM->layout()->addItem(item);
  }
  if(m_ui->gbX && m_ui->gbX->layout())
  {
    item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
    m_ui->gbX->layout()->addItem(item);
  }

  onQualificationChanged();
  m_ui->cbQualification->blockSignals(false);
}

qint64 ParticipantSetSanitationDialog::getProcedures()
{
  qint64 ret = 0;
  for (const auto &cbx : qAsConst(m_procedures))
  {
    if (cbx->isChecked())
      ret += cbx->property("dataCode").toULongLong();
  }

  return ret;
}


QGroupBox *ParticipantSetSanitationDialog::getGroupBox(std::string boxName)
{
  if (boxName.size() == 0)
    return nullptr;
  switch (boxName.at(0))
  {
  case 'x':
    return m_ui->gbX;
  case 'A':
    return m_ui->gbA;
  case 'B':
    return m_ui->gbB;
  case 'C':
    return m_ui->gbC;
  case 'D':
    return m_ui->gbD;
  case 'E':
    return m_ui->gbE;
  case 'M':
    return m_ui->gbM;
  default:
    return nullptr;
  }

}
bool ParticipantSetSanitationDialog::apply()
{

  SetSanitationRequest req;
  req.id(m_participantId);
  SanitationData sanDat;
  sanDat.sanitationProceduresTaken(getProcedures());
  sanDat.qualification(static_cast<Qualification::inner_enum>(m_ui->cbQualification->currentData().toInt()));
  sanDat.originatorEquipmentNumber(0);
  req.data(sanDat);

  DEBUG_LOG(m_logger) << "Medic treatment: qualification = " << sanDat.qualification();
  DEBUG_LOG(m_logger) << "Medic treatment: procedures = " << sanDat.sanitationProceduresTaken();

  return m_requestHelper->startSingleRequest([req, this]()
  {
    return m_ftc->setSanitationRequest(req, this);
  });
}

}