#include <DataSource/DataSourceItem.h>
#include <DataSource/DataSourceItemAction.h>
#include <DataSource/DataSourceItemMergeHelper.h>
#include <QVector>

const QString DataSourceItem::NAME_DATA_KEY   = QStringLiteral("name");
const QString DataSourceItem::PLUGIN_DATA_KEY = QStringLiteral("plugin");
const QString DataSourceItem::ID_DATA_KEY     = QStringLiteral("uuid");

struct DataSourceItem::DataSourceItemPrivate
{
  explicit DataSourceItemPrivate(DataSourceItemType type, QVariantHash data)
      : m_Parent{nullptr},
        m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
  {}

  DataSourceItem* m_Parent;
  std::vector<std::unique_ptr<DataSourceItem>> m_Children;
  DataSourceItemType m_Type;
  QVariantHash m_Data;
  std::vector<std::unique_ptr<DataSourceItemAction>> m_Actions;
};

DataSourceItem::DataSourceItem(DataSourceItemType type, const QString& name)
    : DataSourceItem{type, QVariantHash{{NAME_DATA_KEY, name}}}
{}

DataSourceItem::DataSourceItem(DataSourceItemType type, QVariantHash data)
    : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type,
                                                           std::move(data))}
{}

std::unique_ptr<DataSourceItem> DataSourceItem::clone() const
{
  auto result = std::make_unique<DataSourceItem>(impl->m_Type, impl->m_Data);

  // Clones children
  for(const auto& child : impl->m_Children)
  {
    result->appendChild(std::move(child->clone()));
  }

  // Clones actions
  for(const auto& action : impl->m_Actions)
  {
    result->addAction(std::move(action->clone()));
  }

  return result;
}

QVector<DataSourceItemAction*> DataSourceItem::actions() const noexcept
{
  auto result = QVector<DataSourceItemAction*>{};

  std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                 std::back_inserter(result),
                 [](const auto& action) { return action.get(); });

  return result;
}

void DataSourceItem::addAction(
    std::unique_ptr<DataSourceItemAction> action) noexcept
{
  action->setDataSourceItem(this);
  impl->m_Actions.push_back(std::move(action));
}

void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
{
  child->impl->m_Parent = this;
  impl->m_Children.push_back(std::move(child));
}

DataSourceItem* DataSourceItem::child(int childIndex) const noexcept
{
  if(childIndex < 0 || childIndex >= childCount()) { return nullptr; }
  else
  {
    return impl->m_Children.at(childIndex).get();
  }
}

int DataSourceItem::childCount() const noexcept
{
  return impl->m_Children.size();
}

QVariant DataSourceItem::data(const QString& key) const noexcept
{
  return impl->m_Data.value(key);
}

QVariantHash DataSourceItem::data() const noexcept { return impl->m_Data; }

void DataSourceItem::merge(const DataSourceItem& item)
{
  DataSourceItemMergeHelper::merge(item, *this);
}

bool DataSourceItem::isRoot() const noexcept
{
  return impl->m_Parent == nullptr;
}

QString DataSourceItem::name() const noexcept
{
  return data(NAME_DATA_KEY).toString();
}

DataSourceItem* DataSourceItem::parentItem() const noexcept
{
  return impl->m_Parent;
}

const DataSourceItem& DataSourceItem::rootItem() const noexcept
{
  return isRoot() ? *this : parentItem()->rootItem();
}

void DataSourceItem::setData(const QString& key, const QVariant& value,
                             bool append) noexcept
{
  auto it = impl->m_Data.constFind(key);
  if(append && it != impl->m_Data.constEnd())
  {
    // Case of an existing value to which we want to add to the new value
    if(it->canConvert<QVariantList>())
    {
      auto variantList = it->value<QVariantList>();
      variantList.append(value);

      impl->m_Data.insert(key, variantList);
    }
    else
    {
      impl->m_Data.insert(key, QVariantList{*it, value});
    }
  }
  else
  {
    // Other cases :
    // - new value in map OR
    // - replacement of an existing value (not appending)
    impl->m_Data.insert(key, value);
  }
}

DataSourceItemType DataSourceItem::type() const noexcept
{
  return impl->m_Type;
}

DataSourceItem* DataSourceItem::findItem(const QVariantHash& data,
                                         bool recursive)
{
  for(const auto& child : impl->m_Children)
  {
    if(child->impl->m_Data == data) { return child.get(); }

    if(recursive)
    {
      if(auto foundItem = child->findItem(data, true)) { return foundItem; }
    }
  }

  return nullptr;
}

DataSourceItem* DataSourceItem::findItem(const QString& name)
{
  auto item =
      std::find_if(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
                   [name](const auto& item) { return item->name() == name; });
  if(item != std::cend(impl->m_Children)) return item->get();
  return nullptr;
}

DataSourceItem* DataSourceItem::findItem(const QString& datasourceIdKey,
                                         bool recursive)
{
  for(const auto& child : impl->m_Children)
  {
    auto childId = child->impl->m_Data.value(ID_DATA_KEY);
    if(childId == datasourceIdKey) { return child.get(); }

    if(recursive)
    {
      if(auto foundItem = child->findItem(datasourceIdKey, true))
      { return foundItem; }
    }
  }

  return nullptr;
}

bool DataSourceItem::operator==(const DataSourceItem& other)
{
  // Compares items' attributes
  if(std::tie(impl->m_Type, impl->m_Data) ==
     std::tie(other.impl->m_Type, other.impl->m_Data))
  {
    // Compares contents of items' children
    return std::equal(
        std::cbegin(impl->m_Children), std::cend(impl->m_Children),
        std::cbegin(other.impl->m_Children), std::cend(other.impl->m_Children),
        [](const auto& itemChild, const auto& otherChild) {
          return *itemChild == *otherChild;
        });
  }
  else
  {
    return false;
  }
}

bool DataSourceItem::operator!=(const DataSourceItem& other)
{
  return !(*this == other);
}