/**
* @RDE_HEADER@
* ParticipantManagement - ParticipantSetInjury
* $Id$
* $HeadURL$
* $Author$
* Created by Patric Karwat, SLSE, 2020-05-13
*/

#include "participant_set_injury_dialog.h"
#include "ui_participant_set_injury_dialog.h"

#include <LtsSession/lts_session_data.h>


#include <ParticipantManagement/Gui/Common/participant_vulnerability_types.h>
#include <ProjectDataManagement/pdm_to_string.h>

namespace ParticipantManagement
{

ParticipantSetInjuryDialog::ParticipantSetInjuryDialog(int participantId, QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_participantId(participantId)
  , m_eqId(-1)
  , m_session(nullptr)
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_ppmCbxIfc(nullptr)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_bgInjury(nullptr)
  , m_bgBodypart(nullptr)
  , m_bgSide(nullptr)
  , m_ui(new Ui::ParticipantSetInjuryDialog)
  , m_logger(getLogger("ParticipantSetInjuryDialog"))
{
  m_ui->setupUi(this);
}

bool ParticipantSetInjuryDialog::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 || !dtcPdm)
    return false;

  if (!session->getForeignGuiInterface<ParticipantManagement::ForeignGuiComboboxInterface>(m_ppmCbxIfc))
    return false;

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

  if(!m_dtcPdm->enableSanitationInjury() || !m_dtcPdm->enableSanitationInjuryKind()
     || !m_dtcPdm->enableSanitationInjuryPlace1() || !m_dtcPdm->enableSanitationInjuryPlace2())
    return false;

  m_dtcPdm->waitForHistoricalDataSanitationInjury(1000);
  m_dtcPdm->waitForHistoricalDataSanitationInjuryKind(1000);
  m_dtcPdm->waitForHistoricalDataSanitationInjuryPlace1(1000);
  m_dtcPdm->waitForHistoricalDataSanitationInjuryPlace2(1000);

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

  if (m_dtc->type(participant.typeId()).typeClass() != TypeClass::Human)
    return false;
  auto vec = vulnerabilityStatesForTypeClass(TypeClass::Human);
  if (!vec.contains(ProjectDataManagement::VulnerabilityState::LightDamage)
      || !vec.contains(ProjectDataManagement::VulnerabilityState::MediumDamage)
      || !vec.contains(ProjectDataManagement::VulnerabilityState::HeavyDamage))
    return false;

  m_injuries = m_dtcPdm->sanitationInjurys();
  m_injuryKind = m_dtcPdm->sanitationInjuryKinds();
  m_injuryPlace1 = m_dtcPdm->sanitationInjuryPlace1s();
  m_injuryPlace2 = m_dtcPdm->sanitationInjuryPlace2s();

  if (m_injuries.count() == 0 || m_injuryKind.count() == 0 || m_injuryPlace1.count() == 0 || m_injuryPlace2.count() == 0)
    return false;

  createButtonGroups();
  resetRadioStates();
  checkRadioStatesBody();

  // I dant want to use mininum size here so I add one first and remove it later
  //const QString &mediumDamage = toString(ProjectDataManagement::VulnerabilityState::MediumDamage, ProjectDataManagement::VulnerabilityClass::SoldierInjuries);
  checkState();
  //m_ui->cbState->addItem(mediumDamage, 0);

  //m_uiRequirements->addRequirement({ m_ui->lblBodypart, [this]() { return (m_bgBodypart->checkedId() > 0); }});
  //m_uiRequirements->addRequirement({ m_ui->lblInjury, [this]() { return (m_bgInjury->checkedId() > 0); }});
  //m_uiRequirements->addRequirement({ m_ui->lblSide, [this]() { return ((m_ui->sideLeft->isEnabled() && m_bgSide->checkedId() > 0) || (!m_ui->sideLeft->isEnabled())); }});
  //m_uiRequirements->addRequirement({ m_ui->lblState, [this]() { return (m_ui->cbState->currentData().toInt() > 0); }});

  //set old data in combo box cbState
  const DynamicParticipantData &dynData = m_dtc->dynamicParticipantData(m_participantId);
  setOldData(dynData);

  return true;
}

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

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

  translate(m_ui, tr("Set Injury: %1").arg((id)));
}


void ParticipantSetInjuryDialog::createButtonGroups()
{

  if (!m_ui->gbBodyPart || !m_ui->gbBodyPart->layout()
      || !m_ui->gbInjury || !m_ui->gbInjury->layout()
      || !m_ui->gbSide || !m_ui->gbSide->layout())
    return;

  //Add Injury Kinds
  QRadioButton *rb;
  QSpacerItem *item ;

  m_bgInjury = new QButtonGroup(this);
  for (const auto &injuryKind : qAsConst(m_injuryKind))
  {
    rb = new QRadioButton(ProjectDataManagement::trSanitationInjuryKindName(injuryKind.name()), this);
    m_bgInjury->addButton(rb, injuryKind.id());
    m_ui->gbInjury->layout()->addWidget(rb);
  }
  //Add Spacer at the end
  item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
  m_ui->gbInjury->layout()->addItem(item);

  //Now Add Body Parts
  m_bgBodypart = new QButtonGroup(this);
  for (const auto &injuryplace1 : qAsConst(m_injuryPlace1))
  {
    rb = new QRadioButton(ProjectDataManagement::trSanitationInjuryPlace1Name(injuryplace1.name()), this);
    m_bgBodypart->addButton(rb, injuryplace1.id());
    m_ui->gbBodyPart->layout()->addWidget(rb);
  }
  // Add Spacer at the end
  item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
  m_ui->gbBodyPart->layout()->addItem(item);

  //Now add Sides
  m_bgSide = new QButtonGroup(this);
  for (const auto &injuryplace2 : qAsConst(m_injuryPlace2))
  {
    rb = new QRadioButton(ProjectDataManagement::trSanitationInjuryPlace2Name(injuryplace2.name()), this);
    m_bgSide->addButton(rb, injuryplace2.id());
    m_ui->gbSide->layout()->addWidget(rb);
  }
  //Spacer at the end
  item = new QSpacerItem(2,2,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
  m_ui->gbSide->layout()->addItem(item);

  connect(m_bgInjury,  QOverload<int>::of(&QButtonGroup::buttonClicked), this, &ParticipantSetInjuryDialog::checkRadioStatesBody);
  connect(m_bgBodypart,  QOverload<int>::of(&QButtonGroup::buttonClicked), this, &ParticipantSetInjuryDialog::checkRadioStatesSides);
 // connect(m_bgSide,  QOverload<int>::of(&QButtonGroup::buttonClicked), this, &ParticipantSetInjuryDialog::checkState);
}

void ParticipantSetInjuryDialog::setOldData(const DynamicParticipantData &data)
{
  if (data.stateHistory().size() == 0)
    return;

  const StateInformation &lastState = m_dtc->youngestStateInformation(data.stateHistory());
  //Todo Set last Stuff
  //uint32_t bits = lastState.vulnerabilityBits();

  int index = m_ui->cbState->findData(lastState.vulnerabilityState().underlying());

  DEBUG_LOG(m_logger) << "Old vulnerability state = " << index;

  if (index > 0)
    m_ui->cbState->setCurrentIndex(index);

}

uint32_t ParticipantSetInjuryDialog::getInjuryBit()
{

  // VBA san = ((injury*16 + bodypart) * 4 + side) + 2048
  int side = m_bgSide->button(1)->isEnabled() ? m_bgSide->checkedId() : 0;

  DEBUG_LOG(m_logger) << "getInjuryBit() -------------- ";
  DEBUG_LOG(m_logger) << "Injury = " << m_bgInjury->checkedId();
  DEBUG_LOG(m_logger) << "Body = " << m_bgBodypart->checkedId();
  DEBUG_LOG(m_logger) << "Side = " << side;

  return (((((m_bgInjury->checkedId() * 16) + m_bgBodypart->checkedId()) * 4) + side) + 2048);

}

//slots

void ParticipantSetInjuryDialog::checkRadioStatesBody()
{

  resetRadioStates();
  bool firstAvailable = true;
  for (const ProjectDataManagement::SanitationInjury& injury : qAsConst(m_injuries))
  {
    if (injury.kind() ==  m_bgInjury->checkedId())
    {
      if (firstAvailable)
      {
        m_bgBodypart->button(injury.place1())->setChecked(true);
        firstAvailable = false;
      }
      m_bgBodypart->button(injury.place1())->setEnabled(true);
    }
  }



  checkRadioStatesSides();

}

void ParticipantSetInjuryDialog::checkRadioStatesSides()
{

  resetRadioStates(true);

  for (const ProjectDataManagement::SanitationInjury& injury : qAsConst(m_injuries))
  {
    if (injury.kind() ==  m_bgInjury->checkedId() && injury.place1() ==  m_bgBodypart->checkedId())
      m_bgSide->button(injury.place2())->setEnabled(true);
  }
  if(!m_bgSide->button(1)->isEnabled())
    m_bgSide->button(0)->setChecked(true);
  else
    m_bgSide->button(1)->setChecked(true);

  checkState();

}

void ParticipantSetInjuryDialog::checkState()
{
  QSignalBlocker(m_ui->cbState);
  m_ui->cbState->clear();
  //Vulnerability
  //m_ui->cbState->addItem(tr("No Change"), -1);

  if (m_bgBodypart->checkedId() == 0 || m_bgInjury->checkedId() == 0)
  {
    m_ui->cbState->setEnabled(false);
    return;
  }

  const QString &lightDamage = tr("Minor");   //toString(ProjectDataManagement::VulnerabilityState::LightDamage, ProjectDataManagement::VulnerabilityClass::SoldierInjuries);
  const QString &mediumDamage = tr("Middle"); //toString(ProjectDataManagement::VulnerabilityState::MediumDamage, ProjectDataManagement::VulnerabilityClass::SoldierInjuries);
  const QString &heavyDamage = tr("Serious"); //toString(ProjectDataManagement::VulnerabilityState::HeavyDamage, ProjectDataManagement::VulnerabilityClass::SoldierInjuries);

  for (const ProjectDataManagement::SanitationInjury& injury : qAsConst(m_injuries))
  {
    if (injury.kind() ==  m_bgInjury->checkedId() && injury.place1() ==  m_bgBodypart->checkedId() && injury.place2() == m_bgSide->checkedId())
    {

      switch (injury.vbg())
      {
      case 1:
      {
        if (m_ui->cbState->findData(ProjectDataManagement::VulnerabilityState_def::LightDamage) < 1)
          m_ui->cbState->addItem(lightDamage, ProjectDataManagement::VulnerabilityState_def::LightDamage);
        break;
      }
      case 2:
      {
        if (m_ui->cbState->findData(ProjectDataManagement::VulnerabilityState_def::MediumDamage) < 1)
          m_ui->cbState->addItem(mediumDamage, ProjectDataManagement::VulnerabilityState_def::MediumDamage);
        break;
      }
      case 3:
      {
        if (m_ui->cbState->findData(ProjectDataManagement::VulnerabilityState_def::HeavyDamage) < 1)
          m_ui->cbState->addItem(heavyDamage, ProjectDataManagement::VulnerabilityState_def::HeavyDamage);
        break;
      }
      }
    }
  }
}

void ParticipantSetInjuryDialog::resetRadioStates(bool onlySides)
{
  if (!onlySides)
  {
    QList<QAbstractButton *>  tList = m_bgBodypart->buttons();
    auto cb = tList.begin();
    while (cb != tList.end())
    {
      auto *cbBody = *cb;
      cbBody->setEnabled(false);
      cb++;
    }
    //m_ui->bodyNone->setChecked(true);
  }

  QList<QAbstractButton *> sList = m_bgSide->buttons();
  auto cbS = sList.begin();
  while( cbS != sList.end())
  {
    auto *cbSide = *cbS;
    cbSide->setEnabled(false);
    cbS++;
  }
  //m_ui->sideNone->setChecked(true);
}

bool ParticipantSetInjuryDialog::apply()
{
  if (m_ui->cbState->currentData().toInt() <= 0)
    return false;

  const ProjectDataManagement::VulnerabilityState state = static_cast<ProjectDataManagement::VulnerabilityState_def::type>(m_ui->cbState->currentData().toInt());

  ModifyStateRequest req;
  req.workstationId(LtsSessionData::LtsSessionData::getInstance()->getWorkstationId());
  req.vulnerabilityState(state);
  req.participantIds({m_participantId});
  req.vulnerabilityKind(getInjuryBit());

  DEBUG_LOG(m_logger) << "Saving vulnerability state = " << req.vulnerabilityState();
  DEBUG_LOG(m_logger) << "Saving vulnerability kind = " << req.vulnerabilityKind();

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

} //namespace ParticipantManagement