/**
  * @RDE_HEADER@
  * Pairing of IED-objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Philipp Dassow, SLEA, 2017-07-28
  */

#include "gim_pairing_edit_dialog.h"
#include "ui_gim_pairing_edit_dialog.h"

#include <AdvancedSymbology/asb_data_plugin_interface.h>
#include <GuezIedManagement/gim_data_plugin_interface.h>
#include <ParticipantManagement/ppm_data_plugin_interface.h>
#include <ParticipantManagement/Gui/Common/participant_edit_model.h>
#include <PluginInterfaces/gui_plugin_interface.h>

#include <GuezIedManagement/gim_translation.h>

#include <LtsSession/lts_session.h>
#include <LtsPrinting/printing.h>
#include <QTreeView>

namespace GuezIedManagement
{

PairingEditDialog::PairingEditDialog(LtsSession::LtsSession *session, QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_session(session)
  , m_ui(new Ui::IedPairingEditDialog)
  , m_sessionData(nullptr)
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_ppmDtc(nullptr)
  , m_ppmGuiCbxIfc(nullptr)
  , m_participantModel(nullptr)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_logger(getLogger("GuezIedManangementPairingEditDialog"))
{
  m_ui->setupUi(this);
  m_uiRequirements->addRequirement({m_ui->lblPairingState,  [this]() { return applyPairingStateCheck(); }});
  m_uiRequirements->addRequirement({m_ui->lblParticipantsTree, [this]() { return applyParticipantSelectionCheck(); }});

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &PairingEditDialog::onPrint);

  setOnlineHelpFilename(QStringLiteral("Situation-IED"));
}

bool PairingEditDialog::init(LtsSession::LtsSessionDataDds *session)
{
  m_sessionData = session;

  m_sessionData->getDtc<GuezIedManagement::DataInterface>(m_dtc);
  if (!m_dtc || !m_dtc->enableIed())
  {
    ERROR_LOG(m_logger) << "could not enable Ied DDS-objects in GuezIedManagement DTC ";
    return false;
  }

  m_sessionData->getFtc<GuezIedManagement::DataInterface>(m_ftc);
  if (!m_ftc || !m_ftc->enablePairIed())
  {
    ERROR_LOG(m_logger) << "could not enable pair Ied DDS-Function in GuezIedManagement FTC ";
    return false;
  }

  m_sessionData->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc);
  if (!m_ppmDtc || !m_ppmDtc->enableParticipant())
  {
    ERROR_LOG(m_logger) << "could not enable Participant DDS-objects in ParticipantManagement DTC ";
    return false;
  }

  m_sessionData->getForeignGuiInterface<ParticipantManagement::ForeignGuiComboboxInterface>(m_ppmGuiCbxIfc);
  if (!m_ppmGuiCbxIfc)
    return false;

  connect(m_dtc.get(), &Interface::Dtc::iedChanged, this, &PairingEditDialog::onIedChanged);
  connect(m_ui->cbxIed, static_cast<void (LtsWidgets::LtsComboBox::*)(int)>(&LtsWidgets::LtsComboBox::currentIndexChanged), this, &PairingEditDialog::onIedSelected);
  connect(m_ui->cbxPairingState, static_cast<void (LtsWidgets::LtsComboBox::*)(int)>(&LtsWidgets::LtsComboBox::currentIndexChanged), this, &PairingEditDialog::onPairingStateSelected);

  std::shared_ptr<AdvancedSymbology::ForeignDataInterface> asb;
  session->getForeignDataInterface<AdvancedSymbology::DataInterface>(asb);
  m_participantModel = new ParticipantManagement::ParticipantEditModel(this, m_ppmDtc, asb);
  m_participantModel->setUnitsSelectable(false);
  m_ui->treeViewParticipants->setModel(m_participantModel);

  connect(m_ui->cbxParty,
          static_cast<void (LtsWidgets::LtsComboBox::*)(int)>(&LtsWidgets::LtsComboBox::currentIndexChanged),
          this, &PairingEditDialog::onReInitModel);

  connect(m_ui->treeViewParticipants, &QTreeView::clicked, this, &PairingEditDialog::onParticipantSelected);

  fillAllCbx();
  enDisableUiElements();

  return true;
}

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

void PairingEditDialog::onIedSelected(int idx)
{
  Q_UNUSED(idx);

  Ied ied = m_dtc->ied(m_ui->cbxIed->currentData().toInt());
  setUnchangeable(true);
  m_ui->cbxPairingState->setCurrentIndex(m_ui->cbxPairingState->findData(QVariant(ied.pairingState().underlying())));

  m_ui->treeViewParticipants->clearSelection();
  if (ied.pairingState().underlying() == IedPairingState_def::PairedToParticipant)
  {
    m_ui->cbxParty->setCurrentIndex(m_ui->cbxParty->findData(m_ppmDtc->participant(ied.pairedParticipantId().get()).partyId()));
    m_participantModel->selectItemByParticipantId(ied.pairedParticipantId().get(), [this](const QModelIndex &idx){m_ui->treeViewParticipants->setCurrentIndex(idx);});
  }
  setUnchangeable(false);
  enDisableUiElements();
}

void PairingEditDialog::onPairingStateSelected(int idx)
{
  Q_UNUSED(idx);
  enDisableUiElements();
}

void PairingEditDialog::onIedChanged(const Ied &data, DataModification modType)
{
  Q_UNUSED(data);
  Q_UNUSED(modType);

  fillIedCbx();
  enDisableUiElements();
}

void PairingEditDialog::onParticipantSelected(const QModelIndex &idx)
{
  DEBUG_LOG(m_logger) << "Index of Item: " << idx.row() << " " << idx.column();
  if (checkSelectedParticipantType())
  {
    Ied ied = m_dtc->ied(m_ui->cbxIed->currentData().toInt());
    if (ied.pairingState() == IedPairingState_def::PairedToParticipant)
    {
      // was paired, check if new participant selected
      if (m_participantModel->getParticipantData(idx).id() != ied.pairedParticipantId().get())
        slotChangesMade();
    }
    else
      slotChangesMade();
  }
}

void PairingEditDialog::retranslate()
{
  translate(m_ui, tr("IED Pairing"));
  fillAllCbx();
  enDisableUiElements();
}

bool PairingEditDialog::apply()
{
  if (m_ui->cbxIed->count() > 0)
  {
    PairIedRequest request;

    request.id(m_ui->cbxIed->currentData().toInt());
    request.pairingState(static_cast<IedPairingState::inner_enum>(m_ui->cbxPairingState->currentData().toInt()));
    if (request.pairingState().underlying() == IedPairingState_def::PairedToParticipant)
      request.pairedParticipantId(dds::core::optional<int32_t>(m_participantModel->getParticipantData(m_ui->treeViewParticipants->currentIndex()).id()));

    return m_requestHelper->startSingleRequest([=]()
    {
      return m_ftc->pairIedRequest(request, this);
    });
  }
  return false;
}

bool PairingEditDialog::applyPairingStateCheck()
{
  Ied ied = m_dtc->ied(m_ui->cbxIed->currentData().toInt());

  // was notPairedand and still notPaired selected?
  if (ied.pairingState() == IedPairingState_def::NotPaired && m_ui->cbxPairingState->currentData().toInt() == ied.pairingState().underlying())
      return false;

  return true;
}

bool PairingEditDialog::applyParticipantSelectionCheck()
{
  // is pairedToParticipant selected ?
  if (m_ui->cbxPairingState->currentData().toInt() == IedPairingState_def::PairedToParticipant)
  {
    Ied ied = m_dtc->ied(m_ui->cbxIed->currentData().toInt());
    if (ied.pairingState().underlying() == IedPairingState_def::PairedToParticipant)
    {
      if (checkSelectedParticipantType())
      {
        // ied was already paired, did the paired participant changend?
        if (ied.pairedParticipantId() == m_participantModel->getParticipantData(m_ui->treeViewParticipants->currentIndex()).id())
          return false;
        // check if selected item is a player not a unit
        return true;
      }
    }
    else // ied was not paired before, just check if is a player not a unit
      return checkSelectedParticipantType();
  }
  return true; // is not paired
}

bool PairingEditDialog::checkSelectedParticipantType()
{
  ParticipantManagement::Type type = m_ppmDtc->type(m_participantModel->getParticipantData(m_ui->treeViewParticipants->currentIndex()).typeId());
  return ((type.typeClass().underlying() != ParticipantManagement::TypeClass_def::SupportUnit) &&
          (type.typeClass().underlying() != ParticipantManagement::TypeClass_def::Unit));
}

void PairingEditDialog::fillIedCbx()
{
  // current Ied
  int curIdxIed = m_ui->cbxIed->currentIndex();
  m_ui->cbxIed->clear();
  const QMap <qint32, GuezIedManagement::Ied> mapIed = m_dtc->ieds();
  for (auto it = mapIed.begin(); it != mapIed.end(); ++it)
    m_ui->cbxIed->addItem(QString::number(it.value().equipmentNumber()), QVariant(it.value().id()));

  if (curIdxIed >= 0)
    m_ui->cbxIed->setCurrentIndex(curIdxIed);
  else
    m_ui->cbxIed->setCurrentIndex(0);
}

void PairingEditDialog::fillPairingState()
{
  m_ui->cbxPairingState->clear();
  m_ui->cbxPairingState->addItem(GuezIedManagement::toString(IedPairingState(IedPairingState_def::NotPaired).underlying()), IedPairingState_def::NotPaired);
  m_ui->cbxPairingState->addItem(GuezIedManagement::toString(IedPairingState(IedPairingState_def::PairedToParticipant).underlying()), IedPairingState_def::PairedToParticipant);
}

void PairingEditDialog::fillPartyCbx()
{
  m_ppmGuiCbxIfc->fillPartyComboBox(m_ui->cbxParty);
}

void PairingEditDialog::fillAllCbx()
{
  fillPairingState();
  fillPartyCbx();
  // initial init, as fillIedCbx() needs a filled model and onReInitModel needs fillPartyCbx()
  onReInitModel();
  fillIedCbx(); // has to be filled last (sets other ui-elements corresponding to IED-Object data)
}

void PairingEditDialog::enDisableUiElements()
{
  m_ui->cbxIed->setEnabled(m_ui->cbxIed->count() > 1);
  m_ui->cbxPairingState->setEnabled(m_ui->cbxIed->count() > 0 && m_participantModel->rowCount() > 0);

  if (m_ui->cbxPairingState->currentData().toInt() == IedPairingState_def::NotPaired)
  {
    m_ui->cbxParty->setEnabled(false);
    m_ui->treeViewParticipants->setEnabled(false);
  }
  else
  {
    m_ui->cbxParty->setEnabled((m_ui->cbxIed->count() > 0) && (m_ui->cbxParty->count() > 1));
    m_ui->treeViewParticipants->setEnabled(m_participantModel->rowCount());
  }
}

void PairingEditDialog::onReInitModel()
{
  m_participantModel->onReinitModel(m_ui->cbxParty->currentData().toInt());
  m_ui->treeViewParticipants->expandAll();
}

void PairingEditDialog::onPrint()
{
  LtsPrinting::printView(m_session, this, m_ui->treeViewParticipants );
}

} // namespace Test