/**
* @RDE_HEADER@
* OperatorManagement - Group Edit member of model
* $Id$
* $HeadURL$
* $Author$
* Created by Malte Diers, SLSE, 2017-10-10
*/

#include "exm_operator_model.h"
#include <ExerciseManagement/logger.h>
#include <ExerciseManagement/exm_dtc.h>
#include <LtsSession/lts_session_data.h>
#include <ParticipantManagement/ppm_translation.h>

namespace ExerciseManagement
{
static constexpr int s_OrganisatorId = 99;
ExerciseOperatorModel::ExerciseOperatorModel(LtsSession::LtsSessionDataDds *session,
                                             int exerciseId,
                                             QObject *parent)
  : LtsWidgets::LtsCheckableTableModel<QPair<bool, OperatorManagement::User>>( {tr("Name"),
                                                                                tr("Description"),
                                                                                tr("Visible Parties")}, 0, parent)
  , m_opmDtc(nullptr)
  , m_ppmDtc(nullptr)
  , m_exerciseId(exerciseId)
{
  if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
    return;
  if (!session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
    return;

  auto cb = [this](const OperatorManagement::User &user)
  {
    if (user.id() != s_OrganisatorId)
      insertRow(qMakePair(hasMembership(user), user));
  };
  m_opmDtc->users(cb);

  connect(m_opmDtc.get(), &OperatorManagement::Interface::Dtc::userChanged, this,
          &ExerciseOperatorModel::onOperatorChanged);
}

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

  const auto &entry = m_vecData.at(index.row()).second;
  std::vector<OperatorManagement::PartiesByExercise> vpbe = entry.visiblePartiesByExercise();

  switch (index.column())
  {
  case Name:
    return QString::fromStdString(entry.name());
  case Description:
    return QString::fromStdString(entry.description());
  case VisibleParties:
  {
    return hasVisibleParties(vpbe);
  }
  }
  return {};
}

QString ExerciseOperatorModel::hasVisibleParties(const std::vector<OperatorManagement::PartiesByExercise> vpbe) const
{
  int exerciseId = (m_exerciseId != -1) ? m_exerciseId
                                        : 0 /*new exercise*/;
  for (const auto &pbe : vpbe)
  {
    if (pbe.exerciseId() != exerciseId)
      continue;

    std::vector<int32_t> hiddenParties = {};
    if (pbe.hiddenParties().is_set()) //has_value not support on windows yet so we need depricated is_set
      hiddenParties = pbe.hiddenParties().get();

    if(pbe.visibleParties().is_set()) //has_value not support on windows yet so we need depricated is_set
    {
      return visibleParties(pbe.visibleParties().get(),
                            hiddenParties);
    }
  }
  return {};
}

QString ExerciseOperatorModel::visibleParties(const std::vector<int32_t> &visible,
                                              const std::vector<int32_t> &hidden) const
{
  QStringList result;

  result.reserve(visible.size());
  for (const int partyId : visible)
  {
    bool isHidden = false;
    for (const int hiddenId : hidden)
    {
      if (hiddenId != partyId)
        continue;
      isHidden = true;
    }
    if (!isHidden)
      result.append(ParticipantManagement::trPartyName(m_ppmDtc->party(partyId).name()));
  }

  return result.join(QStringLiteral(", "));
}

void ExerciseOperatorModel::onOperatorChanged(const OperatorManagement::User &data, DataModification mod)
{
  switch (mod)
  {
  case DataModification::eAdded:
  {
    insertRow(qMakePair(false, data));
    break;
  }
  case DataModification::eRemoved:
  {
    for (int i = 0; i < m_vecData.size(); ++i)
      if (m_vecData[i].second.id() == data.id())
      {
        removeRow(i);
        break;
      }
    break;
  }
  case DataModification::eModified:
  {
    for (int i = 0; i < m_vecData.size(); ++i)
      if (m_vecData[i].second.id() == data.id())
      {
        m_vecData[i].second = data;
        break;
      }
    break;
  }
  }
}

bool ExerciseOperatorModel::hasMembership(const OperatorManagement::User &user) const
{
  for (const auto exerciseId : user.exerciseIds())
    if (exerciseId == m_exerciseId)
      return true;
  return false;
}

}