/**
  * @RDE_HEADER@
  * template-Editor
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "participant_template_edit.h"
#include "ui_participant_template_edit.h"

#include <Plugins/ParticipantManagement/Gui/Common/participant_template_edit_item.h>
#include <Plugins/ParticipantManagement/Gui/Common/participant_edit_model.h>
#include "participant_template_chooser_frameless.h"
#include <ParticipantManagement/Gui/Common/participant_firing_unit_validator.h>

#include <QMenu>

#include <nglwidgets/ngltreeitem.h>
#include <LtsPrinting/printing.h>
#include <QTreeView>

namespace ParticipantManagement
{
ParticipantTemplateEdit::ParticipantTemplateEdit(LtsSession::LtsSession *session,
                                                 int rootId,
                                                 bool asSupportService,
                                                 QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_rootId(rootId)
  , m_asSupportService(asSupportService)
  , m_bNeedCommitModifedData(true)
  , m_model(nullptr)
  , m_actionInsertTemplate(nullptr)
  , m_actionSaveAsNewTemplate(nullptr)
  , m_actionRemove(nullptr)
  , m_actionEdit(nullptr)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_ppmGuiCbxIfc(nullptr)
  , m_session(session)
  , m_ui(new Ui::ParticipantTemplateEdit)
  , m_logger(getLogger("ParticipantTemplateEdit"))
{
  m_ui->setupUi(this);

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ParticipantTemplateEdit::onAddItem);
  m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ParticipantTemplateEdit::onEditItem);
  m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &ParticipantTemplateEdit::onRemoveItem);
  m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &ParticipantTemplateEdit::onPrint);

  // ein Apply führt zu aufwendigen Update im Template-Baum - erst einmal hide da Ok ausreichen sollte
  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();

  if (m_asSupportService)
    setOnlineHelpFilename(QStringLiteral("Administrator-Support_Templates"));
  else
    setOnlineHelpFilename(QStringLiteral("Administrator-Participant_Templates"));
}

//----------------------------------------------------------------------------
ParticipantTemplateEdit::~ParticipantTemplateEdit()
{
  delete m_ui;
}

void ParticipantTemplateEdit::retranslate()
{
  translate(m_ui, m_asSupportService ? tr("Support Template Editor") : tr("Participant Template Editor"));
}

bool ParticipantTemplateEdit::init(const std::shared_ptr<ParticipantManagement::Interface::Dtc> &dtc,
                                   const std::shared_ptr<ParticipantManagement::Interface::Ftc> &ftc,
                                   const std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                   const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asbIfc)
{
  if (!dtc || !ftc || !ppmGuiCbxIfc)
    return false;
  m_dtc = dtc;
  m_ftc = ftc;
  m_ppmGuiCbxIfc = ppmGuiCbxIfc;
  m_asbIfc = asbIfc;

  m_model = new ParticipantTemplateEditModel(this, m_dtc, asbIfc, m_rootId);

  // View treeView :
  m_ui->treeViewEdit->setModel(m_model);
  m_ui->treeViewEdit->hideColumn(ParticipantTemplateEditModel::ColTypeClass);
  m_ui->treeViewEdit->expandAll();
  for (int i = 0; i < m_model->columnCount(QModelIndex()); ++i)
    m_ui->treeViewEdit->resizeColumnToContents(i);
  m_ui->treeViewEdit->header()->resizeSection(0, m_ui->treeViewEdit->columnWidth(0) + m_ui->treeViewEdit->iconSize().width() + 10);

  QPushButton *pbInsert = m_buttonBox->getButton(LtsWidgets::DialogButton::Import);
  pbInsert->setText(tr("Insert Template"));
  pbInsert->setVisible(true);
  connect(pbInsert, &QPushButton::clicked,
          this, &ParticipantTemplateEdit::onInsertTemplate);

  QPushButton *pbSaveAs = m_buttonBox->getButton(LtsWidgets::DialogButton::Export);
  pbSaveAs->setText(tr("Save as Template"));
  pbSaveAs->setVisible(true);
  connect(pbSaveAs, &QPushButton::clicked,
          this, &ParticipantTemplateEdit::onSaveAsNewTemplate);

  // ContextMenu :
  m_ui->treeViewEdit->setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ui->treeViewEdit, &QTreeView::customContextMenuRequested,
          this, &ParticipantTemplateEdit::slotCustomContextMenuRequested);
  connect(m_ui->treeViewEdit, &QTreeView::doubleClicked,
          this, &ParticipantTemplateEdit::onDoubleClicked);

  // ContextMenu actions :
  m_actionInsertTemplate = new QAction(pbInsert->icon(), pbInsert->text(), this);
  connect(m_actionInsertTemplate, &QAction::triggered,
          this, &ParticipantTemplateEdit::onInsertTemplate);

  m_actionSaveAsNewTemplate = new QAction(pbSaveAs->icon(), pbSaveAs->text(), this);
  connect(m_actionSaveAsNewTemplate, &QAction::triggered,
          this, &ParticipantTemplateEdit::onSaveAsNewTemplate);

  QPushButton *pbRemove = m_buttonBox->getButton(LtsWidgets::DialogButton::Remove);
  m_actionRemove = new QAction(pbRemove->icon(), pbRemove->text(), this);
  connect(m_actionRemove, &QAction::triggered,
          this, &ParticipantTemplateEdit::onRemoveItem);

  QPushButton *pbEdit = m_buttonBox->getButton(LtsWidgets::DialogButton::Edit);
  m_actionEdit = new QAction(pbEdit->icon(), pbEdit->text(), this);
  connect(m_actionEdit, &QAction::triggered, this,
          &ParticipantTemplateEdit::onEditItem);

  // SelectionModel :
  QItemSelectionModel *selectionModel = m_ui->treeViewEdit->selectionModel();
  connect(selectionModel, &QItemSelectionModel::selectionChanged,
          this, &ParticipantTemplateEdit::onSelectionChanged);
  selectionModel->clearSelection();
  enaDisa();


  connect(m_model, &ParticipantTemplateEditModel::internalDataChanged, this, &ParticipantTemplateEdit::slotChangesMade);

  if (m_firingUnitValidator)
    delete m_firingUnitValidator;
  m_firingUnitValidator = new FiringUnitValidator(m_dtc, this);

  return true;
}

void ParticipantTemplateEdit::onModifyTemplateDataReply(const Core::FunctionReplyObject &replyObject)
{
  enaDisa();
  if (m_bNeedCommitModifedData && !replyObject.error())
    m_model->dataCommitted();
  m_requestHelper->requestReply(replyObject);
}

QModelIndex ParticipantTemplateEdit::selectedIndexView() const
{
  QItemSelectionModel *selectionModel =  m_ui->treeViewEdit->selectionModel();
  QModelIndexList indexL = selectionModel->selectedRows(0);
  if (indexL.size() == 0)
    return QModelIndex();

  return indexL.at(0);
}

bool ParticipantTemplateEdit::isContainer(const QModelIndex &index)
{
  Q_UNUSED(index);
  if (!selectedIndexView().isValid())
    return false;
  int typeId = m_model->privateData(selectedIndexView())->data().value<ParticipantManagement::TemplateData>().typeId();
  if (typeId <= 0)
    return false;

  if (m_asSupportService)
    return m_dtc->type(typeId).typeClass() == ParticipantManagement::TypeClass_def::SupportUnit;
  else
    return m_dtc->type(typeId).typeClass() == ParticipantManagement::TypeClass_def::Unit;

}

void ParticipantTemplateEdit::enaDisa()
{
  QModelIndex selIndex = selectedIndexView();
  bool enableAdd = false;
  bool enableEdit = false;
  bool enableRemove = false;
  bool enableSaveAsTemplate = false;

  if (selIndex.isValid())
  {
    if (isContainer(selIndex)) //only add to units
    {
      enableSaveAsTemplate = true;
      enableAdd = true;

      if (m_firingUnitValidator)
        enableAdd &= m_firingUnitValidator->hasUnitCapacities(m_model, selIndex);
    }
    enableEdit = true;
    enableRemove = selIndex.parent().isValid();
  }

  m_actionInsertTemplate->setEnabled(enableAdd);
  m_actionSaveAsNewTemplate->setEnabled(enableSaveAsTemplate);
  m_actionRemove->setEnabled(enableRemove);
  m_actionEdit->setEnabled(enableEdit);

  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, enableAdd);
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, m_actionEdit->isEnabled());
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, m_actionRemove->isEnabled());
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Import, m_actionInsertTemplate->isEnabled());
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Export, m_actionSaveAsNewTemplate->isEnabled());
}


void ParticipantTemplateEdit::removeCurrentRow()
{
  QModelIndex selIndex = selectedIndexView();
  NGLTreeItem *item = m_model->privateData(selIndex);
  ParticipantManagement::TemplateData tmpl = item->data().value<ParticipantManagement::TemplateData>();

  const bool isRootTemplate = (tmpl.templateId() == m_rootId);
  if (!selIndex.isValid() || isRootTemplate)
    return;
  /** with or without question :
  if(m_model->hasChildren(selIndex)) {
    if(QMessageBox::No == QMessageBox::question(this,
        tr ("Einheit loeschen"),
        tr("Moechten Sie das Element mit allen Untereinheiten wirklich loeschen?"),
        QMessageBox::Yes|QMessageBox::No)) {
      return;
    }
  } else { // no childs :
    if(QMessageBox::No == QMessageBox::question(this,
        tr("Einheit loeschen"),
        tr("Moechten Sie das Element wirklich loeschen?"),
        QMessageBox::Yes|QMessageBox::No)) {
      return;
    }
  }
  */
  m_model->onDeleteRow(selIndex, true);
}


//slots

void ParticipantTemplateEdit::onAddItem()
{
  ParticipantTemplateEditItem *newItemDlg = new ParticipantTemplateEditItem(m_asSupportService,
                                                                            m_session,
                                                                            this);
  const bool addItem = true;
  ParticipantManagement::TemplateData data = ParticipantManagement::TemplateData();
  QModelIndex selIndex = selectedIndexView();
  if (selIndex.isValid())
  {
    ParticipantManagement::TemplateData dataAll = m_model->privateData(selIndex)->data().value<ParticipantManagement::TemplateData>();
    data.designator(dataAll.designator());
    data.tacticalIdentifier(dataAll.tacticalIdentifier());
  }

  if (!newItemDlg->init(selIndex, m_dtc, m_ppmGuiCbxIfc, m_asbIfc, data, addItem))
  {
    delete newItemDlg;
    return;
  }
  newItemDlg->setUsedEquipmentNumbers(m_model->usedEquipmentNumbers());
  newItemDlg->setAttribute(Qt::WA_DeleteOnClose);

  connect(newItemDlg, &ParticipantTemplateEditItem::rejected, newItemDlg, &ParticipantTemplateEditItem::deleteLater);
  connect(newItemDlg, &ParticipantTemplateEditItem::addItem, this, &ParticipantTemplateEdit::onAddItemToModel);
  connect(this, &ParticipantTemplateEdit::usedEquipmentNumbersChanged, newItemDlg, &ParticipantTemplateEditItem::setUsedEquipmentNumbers);

  if (m_firingUnitValidator)
  {
    newItemDlg->setIsAdler(m_firingUnitValidator->isAdler(m_model, selIndex));
    const int unitGearClassType = m_firingUnitValidator->getGearClassType(m_model, selIndex);

    newItemDlg->setFiringUnitRestrictions(m_model, false, m_firingUnitValidator->getRestrictions(m_model, selIndex), m_firingUnitValidator, unitGearClassType);

    connect(newItemDlg, &ParticipantTemplateEditItem::addItem, this, [this, newItemDlg, unitGearClassType] (const QModelIndex &parent, const TemplateData &newData)
    {
      Q_UNUSED(newData)

      if (!newItemDlg || !m_firingUnitValidator)
        return;

      newItemDlg->setFiringUnitRestrictions(m_model, false, m_firingUnitValidator->getRestrictions(m_model, parent), m_firingUnitValidator, unitGearClassType);
    });
  }

  newItemDlg->show();
}

void ParticipantTemplateEdit::onEditItem()
{
  QModelIndex selIndex = selectedIndexView();
  if (!selIndex.isValid())
    return;
  ParticipantManagement::TemplateData data = m_model->privateData(selIndex)->data().value<ParticipantManagement::TemplateData>();

  ParticipantTemplateEditItem *newItemDlg = new ParticipantTemplateEditItem(m_asSupportService,
                                                                            m_session,
                                                                            this);
  if (!newItemDlg->init(selIndex, m_dtc, m_ppmGuiCbxIfc, m_asbIfc, data))
  {
    delete newItemDlg;
    return;
  }
  newItemDlg->setUsedEquipmentNumbers(m_model->usedEquipmentNumbers());
  newItemDlg->setAttribute(Qt::WA_DeleteOnClose);

  connect(newItemDlg, &ParticipantTemplateEditItem::updateItem, this, &ParticipantTemplateEdit::onModifyItemInModel);
  connect(this, &ParticipantTemplateEdit::usedEquipmentNumbersChanged, newItemDlg, &ParticipantTemplateEditItem::setUsedEquipmentNumbers);

  if (m_firingUnitValidator)
  {
    const int unitGearClassType = m_firingUnitValidator->getGearClassType(m_model, selIndex);
    newItemDlg->setFiringUnitRestrictions(m_model, true, m_firingUnitValidator->getRestrictions(m_model, selIndex), m_firingUnitValidator, unitGearClassType);
  }
  newItemDlg->show();
}

void ParticipantTemplateEdit::onRemoveItem()
{
  removeCurrentRow();
}

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

bool ParticipantTemplateEdit::apply()
{
  ModifyTemplateDataRequest req;
  req.data(m_model->templateData());
  if (req.data().size() == 0)
    return true;

  m_bNeedCommitModifedData = true;

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

void ParticipantTemplateEdit::onInsertTemplate()
{
  QModelIndex selIndex = selectedIndexView();
  if (!selIndex.isValid())
    return;
  ParticipantTemplateChooserFrameless *templateChooser = new ParticipantTemplateChooserFrameless(m_session, this);
  if (!templateChooser->init(m_dtc))
  {
    delete templateChooser;
    return;
  }

  connect(templateChooser, &ParticipantTemplateChooserFrameless::selectedTemplate, this, &ParticipantTemplateEdit::onAddTemplateToModel);
  connect(templateChooser, &ParticipantTemplateChooserFrameless::rejected, templateChooser, &ParticipantTemplateChooserFrameless::deleteLater);

  templateChooser->show();
}

void ParticipantTemplateEdit::onAddTemplateToModel(int templateId)
{
  m_model->onInsertTemplate(templateId, selectedIndexView(), true);
}

void ParticipantTemplateEdit::onSaveAsNewTemplate()
{
  QModelIndex selIndex = selectedIndexView();
  if (!selIndex.isValid())
    return;

  ModifyTemplateDataRequest req;
  req.data(m_model->templateDataAsCopy(selIndex));
  if (req.data().size() == 0)
    return;

  m_bNeedCommitModifedData = false;
  m_requestHelper->startSingleRequest([this, req]()
  {
    return m_ftc->modifyTemplateDataRequest(req, this);
  });
}

void ParticipantTemplateEdit::onAddItemToModel(const QModelIndex &parent, const TemplateData &templateData)
{
  bool ret = m_model->onInsertRow(parent, templateData);
  int typeId = m_model->privateData(parent)->data().value<ParticipantManagement::TemplateData>().typeId();
  if (!ret && typeId <= 0)
    return;
  Type type = m_dtc->type(typeId);
  if (type.typeClass() == TypeClass::Unit ||
      type.typeClass() == TypeClass::SupportUnit)
  {
    m_ui->treeViewEdit->setExpanded(m_ui->treeViewEdit->selectionModel()->selectedIndexes().at(0), true);
  }

  emit usedEquipmentNumbersChanged(m_model->usedEquipmentNumbers());
}

void ParticipantTemplateEdit::onModifyItemInModel(const QModelIndex &index, const TemplateData &editData)
{
  m_model->onUpdateRow(index, editData);
  emit usedEquipmentNumbersChanged(m_model->usedEquipmentNumbers());
}

void ParticipantTemplateEdit::onDoubleClicked(const QModelIndex &selIndex)
{
  if (!selIndex.isValid())
    return;
  onEditItem();
}

void ParticipantTemplateEdit::onSelectionChanged(const QItemSelection & /*selected*/,
                                                 const QItemSelection & /*deselected*/)
{
  DEBUG_LOG(m_logger) << "onSelectionChanged";

  enaDisa();
}

void ParticipantTemplateEdit::slotCustomContextMenuRequested(const QPoint &position)
{
  QModelIndex selIndex = selectedIndexView();
  if (!selIndex.isValid())
    return;
  enaDisa();

  QMenu menu(m_ui->treeViewEdit);
  menu.addAction(m_actionInsertTemplate);
  menu.addAction(m_actionSaveAsNewTemplate);
  menu.addSeparator();
  menu.addAction(m_actionRemove);
  menu.addSeparator();
  menu.addAction(m_actionEdit);
  menu.exec(m_ui->treeViewEdit->viewport()->mapToGlobal(position));
}

} //namespace ParticipantManagement