/**
  * Codification data object
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-11-18
  */

#include "object_codification_data.h"
#include "dds_handler.h"

using namespace CodificationManagement;

ObjectCodificationData::ObjectCodificationData(const std::shared_ptr<DdsHandler> &ddsHandler,
                                               const std::shared_ptr<DbHandler> &dbHandler)
  : m_ddsHandler(ddsHandler)
  , m_dbHandler(dbHandler)
  , m_logger(getLogger("ObjectCodificationData"))
{
} // end of ctor()
//-----------------------------------------------------------------------------

ObjectCodificationData::~ObjectCodificationData()
{
  m_ddsHandler->dts()->removeCodificationDataByKey(m_ddsData.id());
} // end of dtor()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectCodificationData::createObject(const CodificationData &ddsData)
{
  DEBUG_LOG(m_logger) << "ObjectCodificationData::createObject()";

  m_ddsData = ddsData;
  if (m_ddsData.id() <= 0)
  {
    m_ddsData.isUsed(false);

    Database::CodCodificationTable dbData;
    dbData = toDbData(ddsData);

    if (!m_dbHandler->db()->insert(dbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting codification_table data into database"));

    m_ddsData.id(dbData.id);
    DEBUG_LOG(m_logger) << "New codificationTable id: " << m_ddsData.id();
  }

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_ddsData.id());
} // end of createObject()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectCodificationData::updateObject(const CodificationManagement::CodificationData &ddsData)
{
  DEBUG_LOG(m_logger) << "ObjectCodificationData::updateObject()";

  if (!isValid())
    return Core::FunctionReplyObject(ddsData.id(), tr_lts("dds", "Object not valid/blocked"));

  // convert request ddsData -> dbData
  Database::CodCodificationTable dbData;
  dbData = toDbData(ddsData);

  if (!m_dbHandler->db()->update(dbData))
    return Core::FunctionReplyObject(ddsData.id(), tr_lts("dds", "Error updating codification_table data in database"));
  // update internal objectdata
  m_ddsData = ddsData;
  DEBUG_LOG(m_logger) << "Data changed for codification_table id: " << m_ddsData.id();

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_ddsData.id());

} // end of updateObject()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject ObjectCodificationData::removeObject()
{
  DEBUG_LOG(m_logger) << "ObjectCodificationData::removeObject()";

  if (isUsed())
    return Core::FunctionReplyObject(m_ddsData.id(), tr_lts("dds", "codification_table data still in use"));

  if (!m_dbHandler->db()->removeCodCodificationTable(m_ddsData.id()))
    return Core::FunctionReplyObject(m_ddsData.id(), tr_lts("dds", "codification_table with id %1 can not be removed")).arg(m_ddsData.id());

  DEBUG_LOG(m_logger) << "Removed codification_table id " << m_ddsData.id();
  m_ddsHandler->dts()->removeCodificationDataByKey(m_ddsData.id());

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

void ObjectCodificationData::onPublishData()
{
  INFO_LOG(m_logger) << "Publish CodificationData data to dds (" << m_ddsData.id() << ") ...";

  if (!m_ddsHandler->dts()->publish(m_ddsData))
    ERROR_LOG(m_logger) << "Error publishing CodificationData data to dds";
} // end of onPublishData()
//-----------------------------------------------------------------------------

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

bool ObjectCodificationData::isUsed() const
{
  return m_ddsData.isUsed();
} // end of isUsed()
//-----------------------------------------------------------------------------


CodificationManagement::CodificationData ObjectCodificationData::toDdsData(const Database::CodCodificationTable &dbData)
{
  CodificationManagement::CodificationData ddsData;

  ddsData.id(dbData.id);
  ddsData.numeralCodeTableColumnIndex(dbData.numeralCodeTableColumnIndex.toStdString());
  ddsData.numeralCodeTableRowIndex(dbData.numeralCodeTableRowIndex.toStdString());
  ddsData.authenticationTableColumnIndex(dbData.authenticationTableColumnIndex.toStdString());
  ddsData.authenticationTableRowIndex(dbData.authenticationTableRowIndex.toStdString());
  ddsData.authenticationTableMatirx(dbData.authenticationTableMatirx.toStdString());
  ddsData.logisticalTermTableColumnIndex(dbData.logisticalTermTableColumnIndex.toStdString());
  ddsData.logisticalTermTableRowIndex(dbData.logisticalTermTableRowIndex.toStdString());
  ddsData.logisticalTermTableMatrix(dbData.logisticalTermTableMatrix.toStdString());
  ddsData.phraseTable(dbData.phraseTable.toStdString());
  ddsData.note(dbData.note.toStdString());
  ddsData.identifier(dbData.identifier.toStdString()),
  ddsData.validityTime(dbData.validityTime);
  ddsData.partyId(dbData.partyId);

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

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

Database::CodCodificationTable ObjectCodificationData::toDbData(const CodificationManagement::CodificationData &ddsData)
{
  Database::CodCodificationTable dbData;

  dbData.id = ddsData.id();
  dbData.numeralCodeTableColumnIndex    = QString::fromStdString(ddsData.numeralCodeTableColumnIndex());
  dbData.numeralCodeTableRowIndex       = QString::fromStdString(ddsData.numeralCodeTableRowIndex());
  dbData.authenticationTableColumnIndex = QString::fromStdString(ddsData.authenticationTableColumnIndex());
  dbData.authenticationTableRowIndex    = QString::fromStdString(ddsData.authenticationTableRowIndex());
  dbData.authenticationTableMatirx      = QString::fromStdString(ddsData.authenticationTableMatirx());
  dbData.logisticalTermTableColumnIndex = QString::fromStdString(ddsData.logisticalTermTableColumnIndex());
  dbData.logisticalTermTableRowIndex    = QString::fromStdString(ddsData.logisticalTermTableRowIndex());
  dbData.logisticalTermTableMatrix      = QString::fromStdString(ddsData.logisticalTermTableMatrix());
  dbData.phraseTable                    = QString::fromStdString(ddsData.phraseTable());
  dbData.note                           = QString::fromStdString(ddsData.note());
  dbData.identifier                     = QString::fromStdString(ddsData.identifier());
  dbData.validityTime                   = ddsData.validityTime();
  dbData.partyId                        = ddsData.partyId();

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