/**
* @RDE_HEADER@
* HMI Plugin for OperatorManagement - Operator/User Overview Dialog
* $Id$
* $HeadURL$
* $Author$
* Created by Christian Ehrlicher, SLSE, 2016-02-29
*/


#include "charge_table.h"
#include "ui_charge_table.h"

#include "charge_table_model.h"
#include "charge_edit_dialog.h"

#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>

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

#include <PluginInterfaces/gui_plugin_interface.h>
#include <FileManagement/flm_translation.h>

#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>

/* This class serves two purposes:
 *
 * In Organiser Mode, you can Check/Uncheck the selectable charges throughout the system:
 * i.e. in filtering, reports etc. Charge display is not affected! This reduces the load in comboboxes etc.
 * Charges NOT to be shown are marked such - they are added  a "{"suppressVisibility": true}" in the pdm_charge_type DB
 *
 * In normal (selection) mode, the dialog is for checking those Charges that are taken into account e.g. for
 * filtering or crafting reports. In a detailed view, a charge variation such as top attack or burst of fire can be
 * selected per charge. The dialog then does not return the chargeIds but the ULEIS codes.
 *
*/

namespace ProjectDataManagement
{
ChargeTableDialog::ChargeTableDialog(QWidget *parent, bool organiser)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkCancel)
  , m_ui(new Ui::ChargeTableDialog)
  , m_ftc(nullptr)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_model(nullptr)
  , m_isOrganiser(organiser)
  , m_logger(getLogger("ChargeTableDialog"))
{
  m_ui->setupUi(this);

  m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Edit, m_isOrganiser);
  if (m_isOrganiser)
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ChargeTableDialog::onEditCharge);

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

  setOnlineHelpFilename(QStringLiteral("Administrator-ChargeTypes"));
}

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

void ChargeTableDialog::retranslate()
{
  translate(m_ui, tr("Charge Types"));
}

void ChargeTableDialog::onUpdateChargeTypeReply(const Core::FunctionReplyObject &replyObject)
{
  m_requestHelper->requestReply(replyObject);
}

void ChargeTableDialog::tableColumnOrganiserSetting()
{
  //LtsColumnOrganiser
  m_ui->widget->setColumnsOrganiserEnabled(identifier(), true);
}

bool ChargeTableDialog::init(LtsSession::LtsSession *session, bool details, const QSet<GearClass> &gearClasses)
{
  m_session = session;

  std::shared_ptr<ProjectDataManagement::Interface::Dtc> dtc;
  if (!m_session->getDtc<ProjectDataManagement::DataInterface>(dtc))
    return false;

  m_model = new ChargeTableDialogModel(m_isOrganiser, this);
  m_model->initModel(dtc, gearClasses);
  m_ui->widget->setModel(m_model);

  if (m_isOrganiser)
  {
    if (!m_session->getFtc<ProjectDataManagement::DataInterface>(m_ftc) ||
        !m_ftc->enableUpdateChargeType())
      return false;

    m_ui->cbDetails->hide();
    connect(m_ui->widget, &LtsDataView::LtsDataView::signalDoubleClicked,    this, &ChargeTableDialog::onEditCharge);
    connect(m_ui->widget, &LtsDataView::LtsDataView::signalSelectionChanged, this, &ChargeTableDialog::enaDisa);
    connect(m_model, &ChargeTableDialogModel::chargeVisibilityChanged,       this, &ChargeTableDialog::enaDisaOk);

    m_ui->rbBoth->hide();
    m_ui->rbDirect->hide();
    m_ui->rbIndirect->hide();

    enaDisa();
  }
  else
  {
    m_ui->widget->hideColumn(ChargeTableDialogModel::Columns::PredefinedName);
    //m_ui->widget->hideColumn(ChargeTableDialogModel::Columns::ShortName);
    m_ui->widget->hideColumn(ChargeTableDialogModel::Columns::DisEntity);
    m_ui->cbDetails->setChecked(details);
    connect(m_ui->cbDetails, &QCheckBox::toggled, this, &ChargeTableDialog::showDetails);
    // Enable "Ok":
    slotChangesMade();
  }
#ifndef LTS_DEBUG
  m_ui->widget->hideColumn(ChargeTableDialogModel::Columns::Id);
#endif

  showDetails(details);
  m_ui->widget->setSortIndicator(ChargeTableDialogModel::Columns::LongName, Qt::AscendingOrder);

  if (!m_session->getForeignGuiInterface<FileManagement::ForeignGuiInterface>(m_flmGui))
    m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Library, false);

  // Save/Load from Library Button
  m_buttonBox->connectLibraryButton(this,
                                    &ChargeTableDialog::onImportButtonClicked,
                                    &ChargeTableDialog::onExportButtonClicked);
  return true;
}

bool ChargeTableDialog::apply()
{
  if (!m_isOrganiser)
  {
    if (m_ui->rbDirect->isChecked())
    {
      emit selectedUleisCodes(m_model->selectedCharges());
      return true;
    }

    QSet<int> additionalChargeIds;
    QSet<int> selectedChargeIds = m_model->selectedCharges();
    for(const auto &chargeId : qAsConst(selectedChargeIds))
    {
      if (chargeId >= 1000 && chargeId < 2000)
        additionalChargeIds << chargeId - 500;
      else
        additionalChargeIds << chargeId + 500;
    }
    if (m_ui->rbBoth->isChecked())
      additionalChargeIds += selectedChargeIds;

    emit selectedUleisCodes(additionalChargeIds);
    return true;
  }

  QVector<ChargeType> cts = m_model->getChargeTypesWithChangedVisibility();
  for (const ChargeType& req : qAsConst(cts))
  {
    m_requestHelper->addRequest([this,req]()
    {
      return m_ftc->updateChargeTypeRequest(req, this);
    });
  }
  return m_requestHelper->startRequests();
}

void ChargeTableDialog::setValues(const std::vector<int> &values, bool includeChildren)
{
  if (m_model)
    m_model->setValues(values, includeChildren);
}

void ChargeTableDialog::setValues(const QSet<int> &values, bool includeChildren)
{
  if (m_model)
    m_model->setValues(values, includeChildren);
}

void ChargeTableDialog::enaDisa()
{
  if (!m_isOrganiser)
    return;

  const int cntSelectedRows = m_ui->widget->selectedRows().size();
  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, cntSelectedRows == 1);
}

void ChargeTableDialog::showDetails(bool showThem)
{
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::AirBurst, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::TopAttack, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::ShortTime, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::ShortTimeScanning, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::FireAndForget, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::BurstOfFire, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::DirectImpact, !showThem);
  m_ui->widget->setColumnHidden(ChargeTableDialogModel::Columns::Unarmed, !showThem);
}

void ChargeTableDialog::enaDisaOk(bool hasChanges)
{
  if (!m_isOrganiser)
    return;

  if (hasChanges)
    slotChangesMade();
  else
    __unchange__();
}


void ChargeTableDialog::onPrint()
{
  LtsPrinting::printView(m_session, this, m_ui->widget->treeView());
}

void ChargeTableDialog::onEditCharge()
{
  const QModelIndex idx = m_ui->widget->currentIndex();
  const ProjectDataManagement::ChargeType ct = m_model->getRowData(idx.row());

  if (ct.id() <= 0)
    return;

  ChargeEditDialog *dialog = new ChargeEditDialog(ct.id(), m_session, this);
  const QString identifier = QLatin1String("EditCharge") + QString::number(ct.id());

  addDialog(dialog, menuGroup(), identifier, LtsWidgets::LayoutArea::eDialogTab);

  dialog->init();
}

void ChargeTableDialog::onImportButtonClicked()
{
  QByteArray content;

  int fileId = m_flmGui->loadFileContent(this,
                                         content,
                                         {FileManagement::FileType::Xml},
                                         m_session->exerciseId(),
                                         FileManagement::toString(m_isOrganiser ? FileManagement::XmlType::PDMChargeFilter : FileManagement::XmlType::PDMUleisCodeFilter));
  if (fileId <= 0)
    return;

  if (!m_flmGui->isXmlType(content, FileManagement::toString(m_isOrganiser ? FileManagement::XmlType::PDMChargeFilter : FileManagement::XmlType::PDMUleisCodeFilter)))
  {
    QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
    LtsWidgets::LtsMessageDialog::showMessage(this,
                                              tr("Invalid xml file content"),
                                              windowTitle(),
                                              LtsWidgets::Behaviour::Modal,
                                              LtsWidgets::Button::Yes,
                                              texts);
    return;
  }

  const QJsonDocument doc(QJsonDocument::fromJson(content));
  const QJsonObject obj(doc.object());
  const QJsonArray arr(obj.value(QLatin1String("selectedCharges")).toArray());
  QSet<int> result;
  result.reserve(arr.size());
  for (const auto &elem : arr)
    result << elem.toObject()[m_isOrganiser ? QLatin1String("chargeTypeId") : QLatin1String("uleisCode")].toInt();
  m_model->setValues(result);
}

void ChargeTableDialog::onExportButtonClicked()
{
  QJsonObject obj;
  QJsonArray arr;

  const auto charges = m_model->selectedCharges();
  for (int charge : charges)
  {
    QJsonObject inner;
    inner[m_isOrganiser ? QLatin1String("chargeTypeId") : QLatin1String("uleisCode")] = charge;
    arr += inner;
  }

  obj[QLatin1String("XmlType")] = FileManagement::toString(m_isOrganiser ? FileManagement::XmlType::PDMChargeFilter : FileManagement::XmlType::PDMUleisCodeFilter);
  obj[QLatin1String("selectedCharges")] = arr;
  QJsonDocument doc(obj);
  QByteArray byteArray = doc.toJson(QJsonDocument::Compact);
  m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
}

} // namespace ProjectDataManagement