/**
  * 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