/**
  * @RDE_HEADER@
  * ISM Object Main Structure Element
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Iuliana Ojog, SLSE, 2016-11-26
  */

#include "object_presentation.h"
#include "initialization.h"
#include "dds_handler.h"
#include <ngldb/dbtransaction.h>

namespace PresentationManagement
{
//----------------------------------------------------------------------------------------------------
ObjectPresentation::ObjectPresentation(Initialization *mainHandler)
  : m_mainHandler(mainHandler)
  , m_logger(getLogger("ObjectPresentation"))
{
}

ObjectPresentation::ObjectPresentation(const Presentation &data, Initialization *mainHandler)
  : m_mainHandler(mainHandler)
  , m_data(data)
  , m_logger(getLogger("ObjectPresentation"))
{
}

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

//------------------------------------------------------------------------------------------------------------
bool ObjectPresentation::isValid() const
{
  return m_data.id > 0;
}

void ObjectPresentation::addPresentationContent(PresentationContent &&data)
{
  m_content.push_back(std::move(data));
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::createObject(const PresentationModifyRequest &request)
{
  m_data = Presentation();
  m_content.clear();

  m_data.name = request.name;
  m_data.description = request.description;
  m_data.operatorId = request.operatorId;
  m_data.lastModified = request.lastModified;

  m_content = request.content;
  //for(auto it = request.content().begin(); it != request.content().end(); ++it)
  //  m_content.append(*it);

  DBTransaction trans(m_mainHandler->db()->database());

  // Insert Presentation
  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->insert(dbData))
    return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting Presentation-data into database"));
  m_data.id = dbData.id;

  // Insert PresentationContent
  for (PresentationContent &conData : m_content)
  {
    conData.presentationId = m_data.id;

    Database::PrePresentationContent conDbData = toDbData(conData);
    conDbData.id = 0;
    conDbData.presentationId = m_data.id;

    if (!m_mainHandler->db()->insert(conDbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting PresentationContent-data into database"));
    else
    {
      DEBUG_LOG(m_logger) << "New presentation content id : " << conDbData.id;
      conData.id = conDbData.id;
    }
  }

  DEBUG_LOG(m_logger) << "New Id: " << m_data.id;
  trans.commit();

  onPublishData();

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

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

  m_data.id = request.id;
  m_data.name = request.name;
  m_data.description = request.description;
  m_data.operatorId = request.operatorId;
  m_data.lastModified = request.lastModified;
  m_data.fileStatus = request.fileStatus;

  DBTransaction trans(m_mainHandler->db()->database());

  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->update(dbData))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error updating Presentation-data into database"));

  for (const auto &content : qAsConst(m_content))
  {
    if (m_mainHandler->db()->removePrePresentationContent(content.id))
      DEBUG_LOG(m_logger) << "Removed presentation content id " << content.id;
    else
      ERROR_LOG(m_logger) << "Failed to remove presentation content id " << content.id;
  }

  m_content = request.content;
  for (PresentationContent &conData : m_content)
  {
    conData.presentationId = m_data.id;

    Database::PrePresentationContent conDbData = toDbData(conData);
    conDbData.presentationId = m_data.id;
    conDbData.id = 0;

    if (!m_mainHandler->db()->insert(conDbData))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting PresentationContent-data into database"));
    else
    {
      DEBUG_LOG(m_logger) << "New presentation content id : " << conDbData.id;
      conData.id = conDbData.id;
    }

  }

  trans.commit();

  onPublishData();

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

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::removeObject()
{
  // remove also presentationContent data via foreign key
  if (!m_mainHandler->db()->removePrePresentation(m_data.id))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Presentation with id %1 can not be removed from DB")).arg(m_data.id);

  int id = m_data.id;
  m_content.clear();
  m_data = Presentation();

  return Core::FunctionReplyObject(id);
}

//------------------------------------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectPresentation::changeStatus(const PresentationChangeStatusRequest &request)
{
  if (!isValid())
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Trying to update an already removed Presentation object"));

  m_data.fileStatus = request.fileStatus;
  m_data.operatorId = request.operatorId;
  m_data.lastModified = request.lastModified;
  Database::PrePresentation dbData(toDbData(m_data));
  if (!m_mainHandler->db()->update(dbData))
    return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "Error updating Presentation-data into database"));
  // Publish Data via DTS
  onPublishData();

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

//------------------------------------------------------------------------------------------------------------
void ObjectPresentation::onPublishData()
{
  INFO_LOG(m_logger) << "Publish Presentation-data to dds (" << m_data.id << ") ...";

  m_mainHandler->dds()->dts()->publish(m_data);
}

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

// PresentationManagement::Presentation => Database::PrePresentation
Database::PrePresentation ObjectPresentation::toDbData(const Presentation &ddsData)
{
  Database::PrePresentation dbData;

  dbData.id = ddsData.id;
  dbData.name = QString::fromStdString(ddsData.name);
  dbData.description  = QString::fromStdString(ddsData.description);
  dbData.lastModified = ddsData.lastModified;
  dbData.operatorId   = ddsData.operatorId;
  dbData.fileStatusId = ddsData.fileStatus;

  return dbData;
}

// -------------------------------------------------------------------------------------------------------
// Database::PrePresentation => PresentationManagement::Presentation
Presentation ObjectPresentation::toDdsData(const Database::PrePresentation &dbData)
{
  Presentation ddsData;

  ddsData.id = dbData.id;
  ddsData.name = dbData.name.toStdString();
  ddsData.description = dbData.description.toStdString();
  ddsData.operatorId = dbData.operatorId;
  ddsData.lastModified = dbData.lastModified;
  ddsData.fileStatus = dbData.fileStatusId;

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

  return ddsData;
}

Database::PrePresentationContent ObjectPresentation::toDbData(const PresentationContent &ddsData)
{
  Database::PrePresentationContent dbData;
  dbData.id             = ddsData.id;
  dbData.presentationId = ddsData.presentationId;
  dbData.presentationTopicType = QString::fromStdString(ddsData.presentationTopicType);
  dbData.channel        = QString::fromStdString(ddsData.channel);
  dbData.description    = QString::fromStdString(ddsData.description);
  dbData.duration       = ddsData.duration;
  dbData.startTime      = ddsData.startTime;
  dbData.attributes     = QString::fromStdString(ddsData.attributes);
  dbData.x              = ddsData.x;
  dbData.y              = ddsData.y;
  dbData.width          = ddsData.width;
  dbData.height         = ddsData.height;
  dbData.index          = ddsData.index;

  return dbData;
}

PresentationContent ObjectPresentation::toDdsData(const Database::PrePresentationContent &dbData)
{
  PresentationContent ddsData;
  ddsData.id = dbData.id;
  ddsData.presentationId = dbData.presentationId;
  ddsData.presentationTopicType = dbData.presentationTopicType.toStdString();
  ddsData.channel = dbData.channel.toStdString();
  ddsData.description = dbData.description.toStdString();
  ddsData.startTime = dbData.startTime;
  ddsData.attributes = dbData.attributes.toStdString();
  ddsData.duration = dbData.duration;
  ddsData.x = dbData.x;
  ddsData.y = dbData.y;
  ddsData.width = dbData.width;
  ddsData.height = dbData.height;
  ddsData.index = dbData.index;

  return ddsData;
}

} // namespace PresentationManagement