/**
  * Handler for the HMI language
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "object_frequency_planning_status.h"
#include "dds_handler.h"
#include "logger.h"

namespace AudioVideoManagement
{
//-------------------------------------------------------------------------------------------------------------
ObjectFrequencyPlanningStatus::ObjectFrequencyPlanningStatus(Interface::Dts *dts,
                                 DatabaseInterface *db)
  : m_dts(dts)
  , m_db(db)
  , m_logger(getLogger("ObjectVideoTeam"))
{
}

//-------------------------------------------------------------------------------------------------------------
ObjectFrequencyPlanningStatus::~ObjectFrequencyPlanningStatus()
{
}

Core::FunctionReplyObject ObjectFrequencyPlanningStatus::clearValues()
{
  auto data(m_data);
  data.uuid = std::string();
  data.sent.reset();
  data.received.reset();
  data.activated.reset();
  data.isActive = false;
  data.requester = std::string();
  data.content = std::string();
  data.reason = TransmissionReason::TR_Unknown;
  return updateObject(data);
}

//-------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectFrequencyPlanningStatus::createObject(const FrequencyPlanningStatus &data)
{
  Q_ASSERT(m_data.id <= 0);
  Q_ASSERT(data.id > 0); // only allow creation from existing db-entries

  m_data = data;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(m_data.id);
}

//-------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectFrequencyPlanningStatus::createObjectFromDDS(const FrequencyPlanningStatus &data)
{
  m_data = data;

  Database::AvmFrequencyPlanningStatus dbData(toDbData(data));
  if (!m_db->insert(dbData))
    return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating VideoTeam into database"));

  m_data.id = dbData.id;
  DEBUG_LOG(m_logger) << "Data changed for VideoTeam Id: " << m_data.id;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(data.id);
}

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

  m_data = data;

  Database::AvmFrequencyPlanningStatus dbData(toDbData(m_data));
  if (!m_db->update(dbData))
    return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating FrequencyPlanningStatus into database"));

  DEBUG_LOG(m_logger) << "Data changed for FrequencyPlanningStatus Id: " << data.id;

  // Publish Data via DTS
  onPublishData();

  return Core::FunctionReplyObject(data.id);
}

Core::FunctionReplyObject ObjectFrequencyPlanningStatus::removeObject()
{
  if (!m_db->removeAvmFrequencyPlanningStatus(m_data.id))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "FrequencyPlanningStatus with id %1 can not be removed from DB")).arg(m_data.id);

  if (!m_dts->removeFrequencyPlanningStatusByKey(m_data.id))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "FrequencyPlanningStatus with id %1 can not be removed from DDS")).arg(m_data.id);

  return Core::FunctionReplyObject(m_data.id);
}

//-------------------------------------------------------------------------------------------------------------
void ObjectFrequencyPlanningStatus::onPublishData()
{
  INFO_LOG(m_logger) << "Publish ObjectFrequencyPlanningStatus to dds (" << m_data.id << ") ..." << m_data.client << ") ...";

  if (!m_dts->publish(m_data))
    ERROR_LOG(m_logger) << "Error publishing ObjectFrequencyPlanningStatus to dds";
}

//-------------------------------------------------------------------------------------------------------------
Database::AvmFrequencyPlanningStatus ObjectFrequencyPlanningStatus::toDbData(const FrequencyPlanningStatus &ddsData)
{
  Database::AvmFrequencyPlanningStatus dbData;

  dbData.id         = ddsData.id;
  dbData.uuid       = QString::fromStdString(ddsData.uuid);
  dbData.client     = ddsData.client;
  dbData.isActive   = ddsData.isActive;
  dbData.requester  = QString::fromStdString(ddsData.requester);
  dbData.content    = QString::fromStdString(ddsData.content);
  dbData.reason     = static_cast<int>(ddsData.reason);

  if (ddsData.sent.is_set())
    dbData.sent = static_cast<qint64>(ddsData.sent.get());
  if (ddsData.received.is_set())
    dbData.received = static_cast<qint64>(ddsData.received.get());
  if (ddsData.activated.is_set())
    dbData.activated = static_cast<qint64>(ddsData.activated.get());

  return dbData;
}

//-------------------------------------------------------------------------------------------------------------
AudioVideoManagement::FrequencyPlanningStatus ObjectFrequencyPlanningStatus::toDdsData(const Database::AvmFrequencyPlanningStatus &dbData)
{
  AudioVideoManagement::FrequencyPlanningStatus ddsData;

  ddsData.id = dbData.id;
  ddsData.uuid = dbData.uuid.toStdString();
  ddsData.client = dbData.client;
  ddsData.isActive = dbData.isActive;
  ddsData.requester = dbData.requester.toStdString();
  ddsData.content = dbData.content.toStdString();
  ddsData.reason = static_cast<TransmissionReason>(dbData.reason);

  if (!dbData.sent.isNull())
    ddsData.sent = dbData.sent.value<int>();
  if (!dbData.received.isNull())
    ddsData.received = dbData.received.value<int>();
  if (!dbData.activated.isNull())
    ddsData.activated = dbData.activated.value<int>();

  return ddsData;
} // end of toDdsData()

} // Namespace