/**
 * @RDE_HEADER@
 * AreaEffectManangement - N Contamination Overview Dialog Model
 * $Id$
 * $HeadURL$
 * $Author$
 *
 * Created by Malte Diers, SLSE, 2017-02-21
 */

#include "aes_charge_administration_model.h"
#include <LtsSession/lts_session.h>
#include <LtsSession/lts_session_data.h>
#include <LtsUtilsCore/json_object.h>
#include <LtsUtilsSettings/settings.h>
#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
#include <ProjectDataManagement/pdm_translation.h>
#include <ngltools/ngltools_dtg.h>

namespace AreaEffectSimulation
{

//
// ChargeAdministrationSortFilterProxyModel
//

void ChargeAdministrationSortFilterProxyModel::setSourceModel(QAbstractItemModel *model)
{
  m_sourceModel = qobject_cast<ChargeAdministrationModel *>(model);
  LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(model);
}

bool ChargeAdministrationSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
{
  if (!m_sourceModel || source_parent.isValid() || source_row < 0 || source_row >= m_sourceModel->rowCount())
    return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);

  const ChargeAdministration &item = m_sourceModel->m_vecData.at(source_row);
  if (item.partyId() != m_party)
    return false;
  return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}

int ChargeAdministrationSortFilterProxyModel::party() const { return m_party; }

void ChargeAdministrationSortFilterProxyModel::setParty(int party)
{
  m_party = party;
  invalidateFilter();
}

//
// ChargeAdministrationModel
//
ChargeAdministrationModel::ChargeAdministrationModel(QObject *parent)
    : LtsWidgets::LtsAbstractTableModel<ChargeAdministration>({tr("Id"),
                                                               tr("Charge Type Id"),
                                                               tr("Changed"),
                                                               tr("Charge Type Name"),
                                                               tr("Total Stock"),
                                                               tr("Planned"),
                                                               tr("Available"),
                                                               tr("Used"),
                                                               tr("Gear Class")},
                                                              parent)
    , m_logger(getLogger("ChargeAdministration"))
{
}

bool ChargeAdministrationModel::initModel(LtsSession::LtsSession *session, QVector<ChargeAdministrationModifyRequest> &reqs)
{
  if (m_aesDtc)
  {
    ERROR_LOG(m_logger) << "double init()!";
    return false;
  }

  if (!session->getDtc<AreaEffectSimulation::DataInterface>(m_aesDtc))
    return false;

  std::shared_ptr<ParticipantManagement::Interface::Dtc> ppmDtc;

  if (!session->getDtc<ProjectDataManagement::DataInterface>(m_pdmDtc))
    return false;

  if (!session->getDtc<ParticipantManagement::DataInterface>(ppmDtc))
    return false;

  m_chargeTypeMap = m_pdmDtc->chargeTypes();

  connect(m_aesDtc.get(), &Interface::Dtc::chargeAdministrationChanged, this, &ChargeAdministrationModel::onChargeAdministrationChanged);

  QVector<QPair<int, int>> chargesInserted;
  auto cb = [this, &chargesInserted](const ChargeAdministration &item)
  {
    // skip ADLER charges
    const int chargeTypeId = item.chargeTypeId();
    if (m_pdmDtc->isAdlerChargeType(chargeTypeId))
      return;

    insertRow(item);
    chargesInserted.append(qMakePair<int, int>(item.chargeTypeId(), item.partyId()));
  };
  m_aesDtc->chargeAdministrations(cb);

  QMap<qint32, ParticipantManagement::Party> parties;
  if (!ppmDtc->visibleParties(parties, LtsSessionData::LtsSessionData::getInstance()->getVisibleParties(session->exerciseId())))
  {
    ERROR_LOG(m_logger) << "Could not retrieve visible Parties!";
    return false;
  }

  QVector<ProjectDataManagement::ChargeType> chargesForGearClass
      = m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Artillery) + m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Mortar);

  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
  const bool enableRocket = ps->value(QStringLiteral("aes"), QStringLiteral("enableRocket"), false).toBool();
  if (enableRocket)
    chargesForGearClass += m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Rocket);
  for (const ParticipantManagement::Party &p : qAsConst(parties))
  {
    for (const ProjectDataManagement::ChargeType &ct : qAsConst(chargesForGearClass))
    {
      if (chargesInserted.contains(qMakePair(ct.id(), p.id())) || isDummy(ct) || m_pdmDtc->isAdlerChargeType(ct.id()))
        continue;

      reqs << ChargeAdministrationModifyRequest(0, ct.id(), p.id(), ProjectDataManagement::EffectSource::ES_Internal, 0, true); // amountChangedByOperator=true
    }
  }
  return true;
}

bool ChargeAdministrationModel::isDummy(const ProjectDataManagement::ChargeType &ct)
{
  return LtsUtils::JsonObject::fromJson(ct.properties()).valueOr<bool>("isDummy", false);
}

QVariant ChargeAdministrationModel::data(const QModelIndex &index, int role) const
{
  if (role != Qt::DisplayRole || !indexIsValid(index))
    return QVariant();

  const ChargeAdministration &item = m_vecData.at(index.row());

  switch (index.column())
  {
    case ColId:
      return item.id();
    case ColTypeId:
      return item.chargeTypeId();
    case ColChanged:
      return QDateTime::fromMSecsSinceEpoch(item.sampleTime());
    case ColTypeName:
      return m_pdmDtc->trChargeTypeShortName(item.chargeTypeId(), true);
    case ColStock:
      return item.amount();
    case ColAvailable:
      return item.amount() - item.planned();
    case ColPlanned:
      return item.planned();
    case ColUsed:
      return item.used();
    case ColGearClass:
      return ProjectDataManagement::toString(m_pdmDtc->gearClassFromChargeTypeId(item.chargeTypeId()));
  }
  return QVariant();
}

void ChargeAdministrationModel::onChargeAdministrationChanged(const ChargeAdministration &data, DataModification modType)
{
  // skip ADLER charges
  if (m_pdmDtc->isAdlerChargeType(data.chargeTypeId()))
    return;
  onDataChanged(data, modType);
}

} // namespace AreaEffectSimulation