/**
  * Handler for borderline objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2017-06-14
  */

#include "handler_borderline.h"
#include "object_borderline.h"


namespace AreaEffectSimulation
{

HandlerBorderline::HandlerBorderline(MainHandler *mainHandler)
  : HandlerBaseTmpl<ObjectBorderline>(mainHandler, QStringLiteral("ExplosionArea"), s_areaCount[AesType::AtBorderline], s_areaCountCentral[AesType::AtBorderline])
  , Interface::Fts::BorderlineModifyRequestHandler(mainHandler->dds()->fts())
  , Interface::Fts::BorderlineRemoveRequestHandler(mainHandler->dds()->fts())
{
} // end of ctor()
//-----------------------------------------------------------------------------

HandlerBorderline::~HandlerBorderline()
{
} // end of dtor()
//-----------------------------------------------------------------------------

bool HandlerBorderline::init()
{
  DEBUG_LOG(m_logger) << "--- Start AreaEffectSimulation HandlerBorderline.";

  QVector<Database::AesBorderline> borderlineVec;
  QVector<Database::AesBorderlineSegment> segmentVec;

  //  get all data for borderlines from database
  if (!m_mainHandler->db()->select(borderlineVec) || !m_mainHandler->db()->select(segmentVec))
  {
    ERROR_LOG(m_logger) << LOGFUNCTION << " Error reading data from database!";
    return false;
  }

  DEBUG_LOG(m_logger) << "read all data for borderlines from database"
                      << " aes_borderline.size(): " << borderlineVec.size()
                      << " aes_Borderline_segment.size(): " << segmentVec.size();

  // contains all segments of an borderline in ascending order
  QVector<Database::AesBorderlineSegment> dbBorderlineSegments;

  for (const Database::AesBorderline &dbBorderline : qAsConst(borderlineVec))
  {
    if (dbBorderline.effectStateId == AesEffectState_def::EsRemoved)
      continue;

    dbBorderlineSegments.clear();
    for (const Database::AesBorderlineSegment &segment : qAsConst(segmentVec))
    {
      if (segment.borderlineId == dbBorderline.privBorderlineId)
        dbBorderlineSegments.insert(segment.positionIndex, segment);
    }

    // create and publish a new object
    ObjectBorderline *ifs(new ObjectBorderline(m_mainHandler, this));
    Core::FunctionReplyObject ret = ifs->createObject(dbBorderline,
                                                      std::vector<Core::GeoPosition2D>(),
                                                      dbBorderlineSegments);
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG(m_logger) << ret();
      return false;
    }

    m_objectMap.insert(ifs->id(), ifs);
  }

  DEBUG_LOG(m_logger) << " m_borderlineObjMap.size() = " << m_objectMap.size();
  return true;
} // end of init()
//-----------------------------------------------------------------------------

void HandlerBorderline::onBorderlineModifyRequest(const rti::core::SampleIdentity &cookie,
                                                  const BorderlineModifyRequest &request)
{
  DEBUG_LOG(m_logger) << "onBorderlineModifyRequest: " << request;
  Core::FunctionReplyObject ret = request.id() > 0 ? borderlineModifyRequest(request) : borderlineCreateRequest(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_mainHandler->dds()->fts()->borderlineModifyReply(cookie, ret);
}
//-----------------------------------------------------------------------------

Core::FunctionReplyObject HandlerBorderline::borderlineCreateRequest(const BorderlineModifyRequest &request)
{
  Database::AesBorderline newData;

  newData.name = QString::fromStdString(request.name());
  newData.operatorId = request.operatorId() > 0 ? request.operatorId() : QVariant();
  newData.partyId = request.partyId();


  ObjectBorderline *ifs(new ObjectBorderline(m_mainHandler, this));
  Core::FunctionReplyObject ret = ifs->createObject(newData,
                                                    request.segments(),
                                                    QVector<Database::AesBorderlineSegment>());
  if (ret.error())
  {
    delete ifs;
    return ret;
  }
  m_objectMap.insert(ifs->id(), ifs);

  return ret;
} // end of onBorderlineCreateRequest()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject HandlerBorderline::borderlineModifyRequest(const BorderlineModifyRequest &request)
{
  Core::FunctionReplyObject ret;
  ObjectBorderline *ifs = getObjectFromMap(m_objectMap, request.id(), ret);
  if (!ifs)
    return ret;

  Database::AesBorderline newData;

  newData.name = QString::fromStdString(request.name());
  newData.operatorId = request.operatorId() > 0 ? request.operatorId() : QVariant();
  newData.partyId = request.partyId();

  return ifs->updateObject(newData, request.segments());
} // end of onBorderlineModifyRequest()
//-----------------------------------------------------------------------------

void HandlerBorderline::onBorderlineRemoveRequest(const rti::core::SampleIdentity &cookie,
                                                  const Core::RemoveElementRequest &request)
{
  m_mainHandler->dds()->fts()->borderlineRemoveReply(cookie, removeReply(&DatabaseInterface::removeAesBorderline, request));

} // end of onBorderlineRemoveRequest()
//-----------------------------------------------------------------------------


} // Namespace AreaEffectSimulation