/**
  * Marker object
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-04-12
  */

#include "object_marker.h"
#include "dds_handler.h"
#include <ngldb/dbtransaction.h>

namespace MarkerManagement
{

ObjectMarker::ObjectMarker(const std::shared_ptr<DdsHandler> &ddsHandler, const std::shared_ptr<DatabaseInterface> &db)
  : m_ddsHandler(ddsHandler)
  , m_db(db)
  , m_logger(getLogger("ObjectMarker"))
{
} // end of ctor()
//-----------------------------------------------------------------------------

ObjectMarker::~ObjectMarker()
{
  m_ddsHandler->dts()->removeMarkerByKey(m_dataMarkerObject.id);
} // end of dtor()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectMarker::createObject(const Marker &data)
{
  m_dataMarkerObject = data;

  if (data.id <= 0)
  {
    Database::MrkMarker dbDataMarker = toDbData(data);
    DBTransaction trans(m_db->database());
    if (!m_db->insert(dbDataMarker))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting MrkMarker-data into database"));

    // Neue DB Id in lokale Struktur uebernehmen
    m_dataMarkerObject.id = dbDataMarker.id;
    DEBUG_LOG(m_logger) << "New MarkerId: " << dbDataMarker.id;

    DEBUG_LOG(m_logger) << "Handle MarkerDescription for markerId:" << dbDataMarker.id << "  number of depending descriptions: " << data.descriptions.size();

    // Behandlung von MarkerDescription
    for (size_t i = 0; i < data.descriptions.size(); ++i)
    {
      MarkerDescription &mrkDesc = m_dataMarkerObject.descriptions[i];
      Database::MrkMarkerDescription dbDataDesc = toDbData(mrkDesc);

      // Struct MarkerDescription vorbereiten
      dbDataDesc.markerId = dbDataMarker.id;  // FK auf MarkerId
      dbDataDesc.id = 0;
      if (!m_db->insert(dbDataDesc))
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting MarkerDescription-data into database"));
      // Neue DB Id in lokale Struktur uebernehmen
      mrkDesc.id = dbDataDesc.id;
    }

    trans.commit();
  }

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_dataMarkerObject.id);

} // end of createObject()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectMarker::updateObject(const Marker &data)
{
  if (!isValid())
    return Core::FunctionReplyObject(data.id, tr_lts("dds", "Object not valid/blocked"));

  const Database::MrkMarker dbDataMarker = toDbData(data);
  auto newData = data;

  DBTransaction trans(m_db->database());
  if (!m_db->update(dbDataMarker))
    return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating MrkMarker-data into database"));

  DEBUG_LOG(m_logger) << "Data changed for markerId: " << m_dataMarkerObject.id;


  INFO_LOG(m_logger) << "Handle MarkerDescriptions for markerId:" << data.id
                     << ". Number of pending descriptions (new/previous):"
                     << data.descriptions.size() << "/" << m_dataMarkerObject.descriptions.size();

  // Descriptions mit id -> schon vorhanden
  // Desctiptions ohne id -> neu einfügen
  for (auto &desc : newData.descriptions)
  {
    Database::MrkMarkerDescription dbDesc = toDbData(desc);
    dbDesc.markerId = dbDataMarker.id;  // FK auf MarkerId
    if (desc.id > 0)
    {
      // immer update ...
      if (!m_db->update(dbDesc))
        return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating MrkMarkerDescription-data into database"));
    }
    else
    {
      if (!m_db->insert(dbDesc))
        return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error inserting MarkerDescription-data into database"));
      desc.id = dbDesc.id;
    }
  }

  // jetzt noch prüfen ob ggf. etwas rausgefallen ist
  for (const auto &oldDesc : m_dataMarkerObject.descriptions)
  {
    bool bFound = false;
    for (const auto &newDesc : newData.descriptions)
    {
      if (newDesc.id == oldDesc.id)
      {
        bFound = true;
        break;
      }
    }
    if (!bFound)
    {
      DEBUG_LOG(m_logger) << "Description with id " << oldDesc.id << " was removed - removing from db";
      if (!m_db->removeMrkMarkerDescription(oldDesc.id))
        return Core::FunctionReplyObject(data.id,
                                         tr_lts("dds", "MarkerDescription with id %1 can not be removed"))
            .arg(oldDesc.id);
    }
  }

  trans.commit();

  m_dataMarkerObject = newData;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_dataMarkerObject.id);
} // end of updateObject()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectMarker::removeObject()
{
  if (isUsed())
    return Core::FunctionReplyObject(m_dataMarkerObject.id, tr_lts("dds", "Marker still in use"));

  // MarkerDescription werden automatisch entfernt (ON DELETE CASCADE)
  if (!m_db->removeMrkMarker(m_dataMarkerObject.id))
    return Core::FunctionReplyObject(m_dataMarkerObject.id, tr_lts("dds", "Marker with id %1 can not be removed")).arg(m_dataMarkerObject.id);

  m_ddsHandler->dts()->removeMarkerByKey(m_dataMarkerObject.id);

  return Core::FunctionReplyObject(m_dataMarkerObject.id);
} // end of removeObject()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectMarker::setUsed(bool isUsed)
{
  if (!isValid())
    return Core::FunctionReplyObject(m_dataMarkerObject.id, tr_lts("dds", "Trying to update an already removed Marker object"));

  m_dataMarkerObject.isUsed = isUsed;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_dataMarkerObject.id);
} // end of setUsed()
//-----------------------------------------------------------------------------

bool ObjectMarker::isValid() const
{
  return m_dataMarkerObject.id > 0;
} // end of isValid()
//-----------------------------------------------------------------------------

bool ObjectMarker::isUsed() const
{
  return m_dataMarkerObject.isUsed;
} // end of isUsed()
//-----------------------------------------------------------------------------

void ObjectMarker::onPublishData()
{
  INFO_LOG(m_logger) << "Publish MrkMarker-data to dds   markerId:" << m_dataMarkerObject.id ;

  if (!m_ddsHandler->dts()->publish(m_dataMarkerObject))
    WARNING_LOG(m_logger) << "Error publishing MrkMarker-data to dds";

} // end of onPublishData()
//-----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// convert methods
// ----------------------------------------------------------------------------

// MarkerManagement::Marker => Database::MrkMarker
Database::MrkMarker ObjectMarker::toDbData(const Marker &ddsData)
{
  Database::MrkMarker dbData;

  dbData.id              = ddsData.id;
  dbData.operatorId      = ddsData.operatorId;
  dbData.note            = QString::fromStdString(ddsData.note);
  dbData.timeStamp       = ddsData.timeStamp;
  dbData.timeStampOffset = ddsData.timeStampOffset;
  dbData.mapSettings     = QString::fromStdString(ddsData.mapSettings);
  dbData.filter          = QString::fromStdString(ddsData.filter);
  dbData.position.setX(ddsData.position.lon);
  dbData.position.setY(ddsData.position.lat);
  dbData.fileContentId   = ddsData.fileContentId;

  return dbData;
} // end of toDbData()
//-----------------------------------------------------------------------------

//Database::MrkMarker => MarkerManagement::Marker
Marker ObjectMarker::toDdsData(const Database::MrkMarker &dbData)
{
  Marker ddsData;

  ddsData.id = dbData.id;
  ddsData.operatorId = dbData.operatorId;
  ddsData.note = dbData.note.toStdString();
  ddsData.timeStamp = dbData.timeStamp;
  ddsData.timeStampOffset = dbData.timeStampOffset;
  ddsData.mapSettings = dbData.mapSettings.toStdString();
  ddsData.filter = dbData.filter.toStdString();
  ddsData.position = Core::GeoPosition(dbData.position.x(), dbData.position.y(), 0.0);
  ddsData.fileContentId = dbData.fileContentId;

  // init data not in db
  ddsData.isDeleted = false;
  ddsData.isUsed = false;

  return ddsData;
} // end of toDdsData()
//-----------------------------------------------------------------------------

// MarkerManagement::MarkerDescription => Database::MrkMarkerDescription
Database::MrkMarkerDescription ObjectMarker::toDbData(const MarkerDescription &ddsData)
{
  Database::MrkMarkerDescription dbData;

  dbData.id            = ddsData.id;
  dbData.markerTypeId  = ddsData.markerType;
  dbData.content       = QString::fromStdString(ddsData.content);

  return dbData;
} // end of toDbData()
//-----------------------------------------------------------------------------

//Database::MrkMarkerDescription => MarkerManagement::MarkerDescription
MarkerDescription ObjectMarker::toDdsData(const Database::MrkMarkerDescription &dbData)
{
  MarkerDescription ddsData;

  ddsData.id = dbData.id;
  ddsData.markerType = dbData.markerTypeId;
  ddsData.content = dbData.content.toStdString();

  return ddsData;
} // end of toDdsData()
//-----------------------------------------------------------------------------

} // namespace MarkerManagement