/**
  * Handler for all exercise objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2015-09-03
  */

#include "handler_group.h"
#include "object_group.h"
#include "handler_operator.h"
#include "opm_db.h"

namespace OperatorManagement
{

HandlerGroup::HandlerGroup(MainHandler *mainHandler)
  : Interface::Fts::GroupChangeMembershipsRequestHandler(mainHandler->fts())
  , Interface::Fts::GroupChangeNameRequestHandler(mainHandler->fts())
  , Interface::Fts::GroupCreateRequestHandler(mainHandler->fts())
  , Interface::Fts::GroupRemoveRequestHandler(mainHandler->fts())
  , m_mainHandler(mainHandler)
  , m_logger(getLogger("HandlerGroup"))
{}

HandlerGroup::~HandlerGroup()
{
  qDeleteAll(m_groupObjMap);
}

static inline std::vector<int> multiMapValuesToVector(const QMultiMap<int, int> &multiMap, int key)
{
  std::vector<int> res;
  auto it = multiMap.find(key);
  if (it != multiMap.cend())
  {
    do
    {
      res.push_back(it.value());
      ++it;
    }
    while (it != multiMap.constEnd() && it.key() == key);
  }
  return res;
}

bool HandlerGroup::init()
{
  // create group/group map
  auto cbGroupGroup = [this](const Database::OpmGroupGroup &groupGroup)
  {
    m_groupGroupMap.insert(groupGroup.groupId, groupGroup.isMemberOfGroupId);
  };
  if (!m_mainHandler->db()->select(cbGroupGroup))
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return true;
  }

  // create group/aclAllow map
  auto cbAclAllow = [this](const Database::OpmAclAllow &aclAllow)
  {
    m_aclAllowMap.insert(aclAllow.groupId, aclAllow.aclId);
  };
  if (!m_mainHandler->db()->select(cbAclAllow))
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return true;
  }

  // create group/aclDeny map
  auto cbAclDeny = [this](const Database::OpmAclDeny &aclDeny)
  {
    m_aclDenyMap.insert(aclDeny.groupId, aclDeny.aclId);
  };
  if (!m_mainHandler->db()->select(cbAclDeny))
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return true;
  }

  // create group objects
  bool bRet = true;
  auto cbGroup = [this, &bRet] (const Database::OpmGroup &group)
  {
    ObjectGroup *ifs(new ObjectGroup(m_mainHandler));
    Core::FunctionReplyObject ret = ifs->createObject(group,
                                                      multiMapValuesToVector(m_groupGroupMap, group.id),
                                                      multiMapValuesToVector(m_aclAllowMap, group.id),
                                                      multiMapValuesToVector(m_aclDenyMap, group.id)
                                                     );
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG(m_logger) << ret();
      bRet = false;
      return;
    }
    m_groupObjMap.insert(ifs->getId(), ifs);
  };
  if (!m_mainHandler->db()->select(cbGroup) || !bRet)
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return false;
  }

  DEBUG_LOG(m_logger) << "m_exeObjMap.size() = " << m_groupObjMap.size();
  INFO_LOG(m_logger) << "Handler Group initialized";

  return true;
}

void HandlerGroup::updateRolePresetId(const int operatorId, const int rolePresetId)
{
  DEBUG_LOG(m_logger) << "updateRolePresetId "
                      << " operatorId=" << operatorId
                      << " rolePresetId=" << rolePresetId;
  m_mainHandler->getHandlerOperator()->operatorModifyRolePresetId( operatorId, rolePresetId);
}

Core::FunctionReplyObject HandlerGroup::changeMembership(const OperatorManagement::GroupChangeMembersRequest &request)
{
  ObjectGroup *ifs = m_groupObjMap.value(request.id());
  if (!ifs)
    return Core::FunctionReplyObject(0, tr_lts("dds", "No valid group id for changing memberships."));

  Core::FunctionReplyObject fro;
  if (request.memberships().size() > 0)
    fro = ifs->updateMemberships(request.memberships());
  else
    fro = ifs->removeAllMemberships();

  // Use the sledgehammer to crack the nut. We don't know which operator is affected.
  // Finding out can be a hazzle...
  m_mainHandler->getHandlerOperator()->reloadAcls();
  return fro;
}

void HandlerGroup::onGroupChangeMembershipsRequest(const rti::core::SampleIdentity &cookie,
                                                   const GroupChangeMembersRequest &request)
{
  DEBUG_LOG(m_logger) << "onGroupChangeMembershipsRequest " << request;
  Core::FunctionReplyObject ret = changeMembership(request);
  if (request.operatorId().is_set() && request.rolePresetId().is_set())
    updateRolePresetId(request.operatorId().get(), request.rolePresetId().get());
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_mainHandler->fts()->groupChangeMembershipsReply(cookie, ret);
}

Core::FunctionReplyObject HandlerGroup::create(const GroupCreateRequest &request)
{
  Database::OpmGroup group;
  group.name = QString::fromStdString(request.name());
  for (const ObjectGroup *g : qAsConst(m_groupObjMap))
  {
    if (g->name().compare(group.name, Qt::CaseInsensitive) == 0)
      return Core::FunctionReplyObject(-1, tr_lts("dds", "Name '%1' already exists")).arg(group.name);
  }
  group.description = QString::fromStdString(request.description());
  group.typeId = request.type();
  group.isHidden = request.isHidden().is_set() ? request.isHidden().get() : false;

  ObjectGroup *ifs(new ObjectGroup(m_mainHandler));
  Core::FunctionReplyObject ret = ifs->createObject(group, request.memberships().is_set() ? request.memberships().get() : std::vector<int32_t>());
  if (ret.error())
  {
    delete ifs;
    return ret;
  }
  m_groupObjMap.insert(ifs->getId(), ifs);

  return ret;
}

void HandlerGroup::onGroupCreateRequest(const rti::core::SampleIdentity &cookie,
                                        const GroupCreateRequest &request)
{
  DEBUG_LOG(m_logger) << "onGroupCreateRequest" << request;
  Core::FunctionReplyObject ret = create(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_mainHandler->fts()->groupCreateReply(cookie, ret);
}

Core::FunctionReplyObject HandlerGroup::changeName(const OperatorManagement::GroupChangeNameRequest &request)
{
  ObjectGroup *ifs = m_groupObjMap.value(request.id());
  if (!ifs)
    return Core::FunctionReplyObject(0, tr_lts("dds", "No valid group id for renaming."));

  Database::OpmGroup group = ifs->data();
  group.name        = QString::fromStdString(request.name());
  group.description = QString::fromStdString(request.description());

  for (const ObjectGroup *g : qAsConst(m_groupObjMap))
  {
    if (g == ifs)
      continue;
    if (g->name().compare(group.name, Qt::CaseInsensitive) == 0)
      return Core::FunctionReplyObject(-1, tr_lts("dds", "Name '%1' already exists")).arg(group.name);
  }

  return ifs->updateObject(group);
}

void HandlerGroup::onGroupChangeNameRequest(const rti::core::SampleIdentity &cookie,
                                            const GroupChangeNameRequest &request)
{
  DEBUG_LOG(m_logger) << "onGroupChangeNameRequest" << request;

  Core::FunctionReplyObject ret;
  ObjectGroup *ifs = m_groupObjMap.value(request.id());
  if (!ifs)
  {
    ret = Core::FunctionReplyObject(0, tr_lts("dds", "No valid group id for renaming."));
    m_mainHandler->fts()->groupChangeNameReply(cookie, ret);
    return;
  }

  Database::OpmGroup group = ifs->data();
  if (group.typeId == GroupType_def::OperatorGroup && (group.name != QString::fromStdString(request.name())))
  {
    ret = Core::FunctionReplyObject(0, tr_lts("dds", "Operator group may not be renamed."));
    m_mainHandler->fts()->groupChangeNameReply(cookie, ret);
    return;
  }
  ret = changeName(request);
  m_mainHandler->fts()->groupChangeNameReply(cookie, ret);
}

Core::FunctionReplyObject HandlerGroup::remove(const Core::RemoveElementRequest &request)
{
  ObjectGroup *ifs = m_groupObjMap.value(request.id());
  if (!ifs)
    return Core::FunctionReplyObject(0, tr_lts("dds", "No valid group id for deleting."));

  OperatorManagement::Group ddsData;
  ddsData.id(request.id());

  if (m_mainHandler->dds()->topicLockMaster()->isLocked(ddsData, 0))
    return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Group '%1' is used by another user!")).arg(ifs->name());

  Core::FunctionReplyObject ret = ifs->removeObject();
  if (ret.error())
    return ret;
  m_groupObjMap.remove(request.id());
  m_groupGroupMap.remove(request.id());
  for (auto it = m_groupGroupMap.begin(); it != m_groupGroupMap.end();)
    if (it.value() == request.id())
      it = m_groupGroupMap.erase(it);
    else
      ++it;

  delete ifs;
  return ret;
}

void HandlerGroup::onGroupRemoveRequest(const rti::core::SampleIdentity &cookie,
                                        const Core::RemoveElementRequest &request)
{
  DEBUG_LOG(m_logger) << "onGroupRemoveRequest" << request;
  Core::FunctionReplyObject ret = remove(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_mainHandler->fts()->groupRemoveReply(cookie, ret);
}

} // Namespace OperatorManagement