/**
  * @RDE_HEADER@
  * HMI Plugin for MeteoDataManagement - Meteo Data Overview Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Patric Karwat, SLSE, 2016-10-05
  */

#include "participant_template_edit_item.h"
#include "ui_participant_edit_item_widget_base.h"
#include <Plugins/ParticipantManagement/ppm_gui_combobox_plugin_interface.h>
#include <ParticipantManagement/ppm_translation.h>
#include <QStandardItemModel>

#include <LtsSession/lts_session_manager.h>

namespace ParticipantManagement
{

//
// ParticipantTemplateEditItemWidget
//
ParticipantTemplateEditItemWidget::ParticipantTemplateEditItemWidget(bool asSupportService,
                                                                     LtsSession::LtsSession *session,
                                                                     QWidget *parent)
  : ParticipantEditItemWidgetBase(asSupportService, session, parent)
{
  m_ui->lbInfo->hide();
  m_ui->leInfo->hide();
  m_ui->lbSign->hide();
  m_ui->leSign->hide();
  m_ui->tbAssignment->hide();
}

bool ParticipantTemplateEditItemWidget::init(const QModelIndex &workingIndex,
                                             const std::shared_ptr<ParticipantManagement::Interface::Dtc> &dtc,
                                             const std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                             const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                                             const ParticipantManagement::TemplateData &data,
                                             const bool addItem)
{
  m_workingIndex = workingIndex;
  m_editData = data;
  m_bEditMode = m_editData.typeId() > 0;

  return ParticipantEditItemWidgetBase::init(dtc, ppmGuiCbxIfc, asb, addItem);
}

void ParticipantTemplateEditItemWidget::setFiringUnitRestrictions(ParticipantTemplateEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int &unitGearClassType)
{
  if (!firingUnitValidator || !model)
    return;

  if (restrictions.testFlag(FiringUnitValidator::NO_TYPE_CHANGE_ALLOWED))
  {
    m_ui->cbTypeClass->setDisabled(true);
    m_ui->cbType->setDisabled(true);

    if (isEdit) // if we are in edit mode (and not add), type and typeclass are already set where as want them to be
      return;

    const Type allowedType = firingUnitValidator->getAllowedType(model, m_workingIndex);

    if (allowedType == Type())
      return;

    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedType.typeClass().underlying()));
    m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(allowedType.id()));

    return;
  }

  if (restrictions.testFlag(FiringUnitValidator::ONLY_SAME_GEAR_CLASS_ARTILLERY_ALLOWED))
  {
    if (isEdit)
      return;

    const QVector<Type> allowedTypes = firingUnitValidator->artilleryParticipantTypes();

    m_ui->cbTypeClass->setDisabled(true);
    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedTypes.at(0).typeClass().underlying()));

    QSignalBlocker typeSignalBlocker(m_ui->cbType);


    m_ui->cbType->clear();

    std::function<bool(Type)> funcIsSameGearType = [=](const Type &t)
    {
      if (m_isAdler)
        return m_dtc->isAdlerType(t.id()) && (firingUnitValidator->getGearClassType(t.id()) == unitGearClassType);
      return firingUnitValidator->getGearClassType(t.id()) == unitGearClassType;
    };
    QVector<Type>::ConstIterator typeIterator = std::find_if(allowedTypes.begin(), allowedTypes.end(), funcIsSameGearType);

    if(typeIterator != allowedTypes.end())
    {
      m_ui->cbType->setDisabled(true);
      m_ui->cbType->addItem(ParticipantManagement::trTypeName(typeIterator->name()), typeIterator->id());
    }
    else
    {
      for (const Type &currentType : allowedTypes)
        m_ui->cbType->addItem(ParticipantManagement::trTypeName(currentType.name()), currentType.id());
      m_ui->cbType->model()->sort(0);
    }

    m_ui->cbType->setCurrentIndex(0);
    return;
  }

  if (isEdit && restrictions.testFlag(FiringUnitValidator::NO_FIRING_UNIT_TYPE_ALLOWED))
  {
    m_disabledTypeIds.unite(firingUnitValidator->firingUnitTypeIds());

    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());

    if (cbTypeModel == nullptr)
      return;

    for (int row = 0; row < m_ui->cbType->count(); ++row)
    {
      QStandardItem *item = cbTypeModel->item(row);
      int typeId = item->data(Qt::UserRole).toInt();

      if (!m_disabledTypeIds.contains(typeId))
        continue;

      item->setFlags(Qt::NoItemFlags);
    }
  }

  if (restrictions.testFlag(FiringUnitValidator::NO_ARTILLERY_PARTICIPANTS_ALLOWED))
  {
    m_disabledTypeIds.unite(firingUnitValidator->artilleryParticipantTypeIds());

    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());

    if (cbTypeModel == nullptr)
      return;

    for (int row = 0; row < m_ui->cbType->count(); ++row)
    {
      QStandardItem *item = cbTypeModel->item(row);
      int typeId = item->data(Qt::UserRole).toInt();

      if (!m_disabledTypeIds.contains(typeId))
        continue;

      item->setFlags(Qt::NoItemFlags);
    }
  }
}

void ParticipantTemplateEditItemWidget::setData()
{
  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));

  Type type = m_dtc->type(m_editData.typeId());
  m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(type.typeClass().underlying()));
  m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(type.id()));

  // set EqNr after all cbx change
  m_ui->sbEquipNr->setValue(m_editData.equipmentNumber());

  // Not templates for Externals.
  m_ui->cbExternal->hide();
  m_ui->cbExternal->setChecked(false);
  m_ui->lblExternal->hide();

  // nach den Setzen des Typs, sonst wird Default Typ-Symbol benutzt...
  onChangeSymbol(QString::fromStdString(m_editData.symbol()));
}

void ParticipantTemplateEditItemWidget::setDesignatorData()
{
  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));
}

void ParticipantTemplateEditItemWidget::onAddItem()
{
  ParticipantManagement::TemplateData newTemplateParticipant;
  newTemplateParticipant.designator() = m_ui->leDesignator->text().toStdString();
  newTemplateParticipant.tacticalIdentifier() = m_ui->leTactIdent->text().toStdString();
  newTemplateParticipant.symbol(m_sidc.toStdString());
  newTemplateParticipant.typeId(m_ui->cbType->currentData().toInt());

  const int equipNo = m_ui->sbEquipNr->value();
  if (!checkEquipNo(equipNo))
    return;
  newTemplateParticipant.equipmentNumber(equipNo);

  DEBUG_LOG(m_logger) << "adding item: " << newTemplateParticipant;
  emit addItem(m_workingIndex, newTemplateParticipant);

  if (equipNo > 0)
    m_ui->sbEquipNr->setValue(equipNo + 1);
}

bool ParticipantTemplateEditItemWidget::onEditItem()
{
  m_editData.designator() = m_ui->leDesignator->text().toStdString();
  m_editData.tacticalIdentifier() = m_ui->leTactIdent->text().toStdString();
  m_editData.symbol(m_sidc.toStdString());
  m_editData.typeId(m_ui->cbType->currentData().toInt());

  //eqNr is set
  const int equipNo = m_ui->sbEquipNr->value();
  if (!checkEquipNo(equipNo))
    return false;
  m_editData.equipmentNumber(equipNo);

  DEBUG_LOG(m_logger) << "edit item: " << m_editData;
  emit updateItem(m_workingIndex, m_editData);
  emit readyToClose();
  return true;
}

bool ParticipantTemplateEditItemWidget::checkEquipNo(int equipNo)
{
  if (equipNo > 0)
  {
    if (equipNo < m_typeMinimum)
    {
      //eqNr is below minimum!
      m_ui->lbMinMaxEquipNr->setText(QStringLiteral("<span style=\"color:#aa0000;\">%1</span>").arg(equipNo));
      return false;
    }
    if (m_editData.equipmentNumber() != equipNo)
    {
      //eqNr is in range (max is set in sp directly)
      if (m_usedEquipmentNumbers.contains(equipNo))
      {
        const QString msg = tr("The equipment number is already used by another participant in this template");
        LtsWidgets::LtsMessageDialog::showMessage(this,
                                                  msg,
                                                  tr("Equipment Number already in use"));
        return false;
      }
    }
  }
  return true;
}


//
// ParticipantTemplateEditItem
//
ParticipantTemplateEditItem::ParticipantTemplateEditItem(bool asSupportService,
                                                         LtsSession::LtsSession *session,
                                                         QWidget *parent)
  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
  , m_editItemWidget(new ParticipantTemplateEditItemWidget(asSupportService, session, parent))
  , m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))
{
  //HACK as close is not allowed directly

  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &ParticipantTemplateEditItem::close);
  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::readyToClose, this, &ParticipantTemplateEditItem::close);

  //connect to other signals
  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::addItem, this, &ParticipantTemplateEditItem::addItem);
  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::updateItem, this, &ParticipantTemplateEditItem::updateItem);

  //hide ok and aplly
  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
}

bool ParticipantTemplateEditItem::init(const QModelIndex &workingIndex,
                                       const std::shared_ptr<Interface::Dtc> &dtc,
                                       const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                       const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                                       const TemplateData &data,
                                       const bool addItem)
{
  if (!m_editItemWidget->init(workingIndex, dtc, ppmGuiCbxIfc, asb, data, addItem))
    return false;


  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(m_editItemWidget);
  layout->addWidget(m_buttonBox);
  setLayout(layout);

  if (data.typeId() > 0)
  {
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantTemplateEditItemWidget::onEditItem);
    m_buttonBox->getButton(LtsWidgets::DialogButton::Edit)->setText(tr("Apply"));
  }
  else
  {
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, m_editItemWidget, &ParticipantTemplateEditItemWidget::onAddItem);
  }

  return true;
}

void ParticipantTemplateEditItem::setFiringUnitRestrictions(ParticipantTemplateEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int unitGearClassType)
{
  if (restrictions == FiringUnitValidator::NO_RESTRICTION)
    return;

  if (restrictions.testFlag(FiringUnitValidator::IS_AT_MAX_CAPACITY))
    m_buttonBox->getButton(LtsWidgets::DialogButton::Add)->setDisabled(true);

  if (m_editItemWidget)
    m_editItemWidget->setFiringUnitRestrictions(model, isEdit, restrictions, firingUnitValidator, unitGearClassType);
}

//
// ParticipantTemplateEditItemTab
//
ParticipantTemplateEditItemTab::ParticipantTemplateEditItemTab(bool asSupportService,
                                                               LtsSession::LtsSession *session,
                                                               QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
  , m_editItemWidget(new ParticipantTemplateEditItemWidget(asSupportService, session, this))
{
  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::updateItem, this, &ParticipantTemplateEditItemTab::updateItem);
  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::readyToClose, this, [this]()
  {
    m_buttonBox->getButton(LtsWidgets::DialogButton::Close)->click();
  });
}

bool ParticipantTemplateEditItemTab::init(const QModelIndex &workingIndex,
                                          const std::shared_ptr<Interface::Dtc> &dtc,
                                          const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                          const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                                          const TemplateData &data)
{
  if (!m_editItemWidget->init(workingIndex, dtc, ppmGuiCbxIfc, asb, data))
    return false;

  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(m_editItemWidget);
  setLayout(layout);

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantTemplateEditItemWidget::onEditItem);
  return true;
}

void ParticipantTemplateEditItemTab::retranslate()
{
  // lupdate doesn't like translate(tr("foo")) ...
  const QString txt(tr("Participant Item Edit"));
  translate(txt);
}

bool ParticipantTemplateEditItemTab::apply()
{
  return m_editItemWidget->onEditItem();
}

} //namespace ParticipantManagement