/**
  * @RDE_HEADER@
  * $Id$
  * $HeadURL$
  * $Author$
  */


#include "object_menu_struct.h"
#include "handler_menu_struct.h"
#include "main_handler.h"
#include "dds_handler.h"
#include "logger.h"
#include <AudioVideoManagement/avm_dts.h>
#include <AudioVideoManagement/avm_db.h>
#include <DDS/Core/function_reply_object.h>
#include <ngldb/dbtransaction.h>
#include <vector>
#include <set>
#include <algorithm>
#include <cstdint>


namespace
{

AudioVideoManagement::Database::AvmMenuStruct toDb(const AudioVideoManagement::AvMenuEntry &ddsItem, int32_t parentId)
{
  AudioVideoManagement::Database::AvmMenuStruct   dbItem;

  dbItem.id = ddsItem.id() <= 0 ? 0 : ddsItem.id();
  dbItem.parentId = parentId;
  dbItem.isGroup = ddsItem.isGroup();
  dbItem.rowid = ddsItem.rowId();

  if (ddsItem.isGroup())
    dbItem.name = QString::fromStdString(ddsItem.name().get());
  else
    dbItem.mountingPointId = ddsItem.mountingPointId().get();

  return dbItem;
}

void checkHierarchy(const std::vector<AudioVideoManagement::AvMenuEntry> &entries_, int32_t toplevelId)
{
  std::vector<AudioVideoManagement::AvMenuEntry>   entries = entries_;

  auto   isToplevel = [toplevelId] (const AudioVideoManagement::AvMenuEntry &entry) { return entry.parentId() == toplevelId; };
  auto   sublevelStart = std::partition(entries.begin(), entries.end(), isToplevel);

  std::set<int32_t>  ids;
  std::set<int32_t>  groupIds;
  for (auto entry = entries.begin(); entry != sublevelStart; ++entry)
  {
    auto   result = ids.insert(entry->id());
    Q_ASSERT(result.second);

    if (entry->isGroup())
      groupIds.insert(entry->id());
  }

  for (auto entry = sublevelStart; entry != entries.end(); ++entry)
  {
    auto   result = ids.insert(entry->id());
    Q_ASSERT(result.second);

    Q_ASSERT(!entry->isGroup());
    Q_ASSERT(groupIds.count(entry->parentId()) > 0);
  }
}

} // anonymous namespace


namespace AudioVideoManagement
{

ObjectMenuStruct::ObjectMenuStruct(Interface::Dts *dts, DatabaseInterface *db)
  : m_dts(dts)
  , m_db(db)
  , m_logger(getLogger("ObjectMenuStruct"))
{
  Q_ASSERT(dts);
  Q_ASSERT(db);
}

ObjectMenuStruct::~ObjectMenuStruct()
{
  m_dts->removeMenuStructByKey(m_data.id());
}

Core::FunctionReplyObject ObjectMenuStruct::createFromDds(const MenuStruct &data)
{
  Q_ASSERT(data.id() <= 0 && m_data.id() <= 0);
  auto   reply = insertUpdateDb(data);
  onPublishData();
  return reply;
}

Core::FunctionReplyObject ObjectMenuStruct::updateFromDds(const MenuStruct &data)
{
  Q_ASSERT(data.id() > 0 && data.id() == m_data.id());
  auto   reply = insertUpdateDb(data);
  onPublishData();
  return reply;
}

void ObjectMenuStruct::createFromDb(const MenuStruct &data)
{
  Q_ASSERT(data.id() > 0 && m_data.id() <= 0);
  checkHierarchy(data.menuEntries(), data.id());
  m_data = data;
  onPublishData();
}

void ObjectMenuStruct::updateFromDb(const MenuStruct &data)
{
  Q_ASSERT(data.id() > 0 && data.id() == m_data.id());
  if (data == m_data)
    return;

  checkHierarchy(data.menuEntries(), data.id());
  m_data = data;
  onPublishData();
}

Core::FunctionReplyObject ObjectMenuStruct::remove()
{
  DBTransaction trans(m_db->database());

  INFO_LOG(m_logger) << "menuEntries.size(): " << m_data.menuEntries().size();
  for (const AudioVideoManagement::AvMenuEntry &me : m_data.menuEntries())
  {
    INFO_LOG(m_logger) << "Remove entries with id/parentId: " << me.id();
    // no recursion needed, only 2 levels allowed
    if (me.isGroup())
      if (!m_db->removeAvmMenuStructByParentId(me.id()))
        return Core::FunctionReplyObject(m_data.id(), "Error while removing menu entries");
    if (!m_db->removeAvmMenuStruct(me.id()))
      return Core::FunctionReplyObject(m_data.id(), "Error while removing menu entries");
  }
  if (!m_db->removeAvmMenuStruct(m_data.id()))
    return Core::FunctionReplyObject(m_data.id(), "Error while removing menu struct");

  trans.commit();

  m_dts->removeMenuStructByKey(m_data.id());

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

void ObjectMenuStruct::onPublishData()
{

  INFO_LOG(m_logger) << "Publish MenuStruct-data to dds (" << m_data.id() << ") ...";

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


Core::FunctionReplyObject ObjectMenuStruct::insertUpdateDb(const MenuStruct &data)
{
  checkHierarchy(data.menuEntries(), data.id());

  const auto oldEntries = m_data.menuEntries();
  m_data = data;

  Database::AvmMenuStruct ms;

  // Insert Parent
  ms.parentId = 0;
  ms.name = QString::fromStdString(data.name());
  ms.isAudio = data.isAudio();
  ms.isGroup = true;

  DBTransaction trans(m_db->database());

  if (m_data.id() > 0)
  {
    ms.id = m_data.id();
    if (!m_db->update(ms))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting AvmMenuStruct-data into database"));
  }
  else
  {
    if (!m_db->insert(ms))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting AvmMenuStruct-data into database"));
  }

  m_data.id(ms.id);
  const int virtualMenuStructId = data.id();
  const int realMenuStructId = m_data.id();

  std::vector<AvMenuEntry> newEntries;
  newEntries.reserve(data.menuEntries().size());

  auto ret = insertUpdateChildren(virtualMenuStructId, realMenuStructId, data.menuEntries(), newEntries);
  if (ret.error())
    return ret;

  DEBUG_LOG(m_logger) << "old entries: " << m_data;
  for (const AvMenuEntry &me : oldEntries)
  {
    // new entries - ignore
    if (me.id() <= 0)
      continue;

    auto   found = std::find_if(newEntries.begin(), newEntries.end(), [&me] (const AvMenuEntry &newEntry) { return me.id() == newEntry.id(); });
    if (found == newEntries.end())
    {
      DEBUG_LOG(m_logger) << "Menu Entry with id not found - was removed: " << me.id();
      m_db->removeAvmMenuStruct(me.id());
    }
  }

  m_data.menuEntries(newEntries);
  HandlerMenuStruct::sortEntries(m_data);
  DEBUG_LOG(m_logger) << "new entries: " << m_data;

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

Core::FunctionReplyObject ObjectMenuStruct::insertUpdateChildren(int virtualParentId,
                                                                 int realParentId,
                                                                 const std::vector<AudioVideoManagement::AvMenuEntry>& entries,
                                                                 std::vector<AudioVideoManagement::AvMenuEntry> &newEntries)
{
  for(const AudioVideoManagement::AvMenuEntry &ddsItem : entries)
  {
    if (ddsItem.parentId() != virtualParentId)
      continue;

    Database::AvmMenuStruct   dbEntry = ::toDb(ddsItem, realParentId);

    if (dbEntry.id == 0)
    {
      if (!m_db->insert(dbEntry))
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting AvmMenuStruct-data into database"));
    }
    else
    {
      if (!m_db->update(dbEntry))
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error updating AvmMenuStruct-data into database"));
    }

    // update database ids in dds data
    newEntries.push_back(HandlerMenuStruct::toDds(dbEntry));

    if (dbEntry.isGroup)
    {
      const int virtualId = ddsItem.id();
      const int realId = dbEntry.id;
      insertUpdateChildren(virtualId, realId, entries, newEntries);
    }
  }

  return Core::FunctionReplyObject();
}

} // namespace AudioVideoManagement